OSDN Git Service

fixed/added $NucleusJP$ etc.
[nucleus-jp/nucleus-jp-ancient.git] / utf8 / nucleus / libs / MANAGER.php
1 <?php
2 /*
3  * Nucleus: PHP/MySQL Weblog CMS (http://nucleuscms.org/)
4  * Copyright (C) 2002-2006 The Nucleus Group
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  * (see nucleus/documentation/index.html#license for more info)
11  */
12 /**
13  * This class makes sure each item/weblog/comment object gets requested from
14  * the database only once, by keeping them in a cache. The class also acts as
15  * a dynamic classloader, loading classes _only_ when they are first needed,
16  * hoping to diminish execution time
17  *
18  * The class is a singleton, meaning that there will be only one object of it
19  * active at all times. The object can be requested using MANAGER::instance()
20  *
21  * @license http://nucleuscms.org/license.txt GNU General Public License
22  * @copyright Copyright (C) 2002-2006 The Nucleus Group
23  * @version $Id: MANAGER.php,v 1.6 2006-07-20 08:01:52 kimitake Exp $
24  * $NucleusJP: MANAGER.php,v 1.5 2006/07/17 20:03:44 kimitake Exp $
25  */
26 class MANAGER {
27
28         /**
29          * Cached ITEM, BLOG, PLUGIN, KARMA and MEMBER objects. When these objects are requested
30          * through the global $manager object (getItem, getBlog, ...), only the first call
31          * will create an object. Subsequent calls will return the same object.
32          *
33          * The $items, $blogs, ... arrays map an id to an object (for plugins, the name is used
34          * rather than an ID)
35          */
36         var $items;
37         var $blogs;
38         var $plugins;
39         var $karma;
40         var $templates;
41         var $members;
42
43         /**
44          * cachedInfo to avoid repeated SQL queries (see pidInstalled/pluginInstalled/getPidFromName)
45          * e.g. which plugins exists?
46          *
47          * $cachedInfo['installedPlugins'] = array($pid -> $name)
48          */
49         var $cachedInfo;
50
51         /**
52           * The plugin subscriptionlist
53           *
54           * The subcription array has the following structure
55           *             $subscriptions[$EventName] = array containing names of plugin classes to be
56           *                                                                      notified when that event happens
57           */
58         var $subscriptions;
59
60         /**
61           * Returns the only instance of this class. Creates the instance if it
62           * does not yet exists. Users should use this function as
63           * $manager =& MANAGER::instance(); to get a reference to the object
64           * instead of a copy
65           */
66         function &instance() {
67                 static $instance = array();
68                 if (empty($instance)) {
69                         $instance[0] =& new MANAGER();
70                 }
71                 return $instance[0];
72         }
73
74         /**
75           * The constructor of this class initializes the object caches
76           */
77         function MANAGER() {
78                 $this->items = array();
79                 $this->blogs = array();
80                 $this->plugins = array();
81                 $this->karma = array();
82                 $this->parserPrefs = array();
83                 $this->cachedInfo = array();
84         }
85
86         /**
87           * Returns the requested item object. If it is not in the cache, it will
88           * first be loaded and then placed in the cache.
89           * Intended use: $item =& $manager->getItem(1234)
90           */
91         function &getItem($itemid, $allowdraft, $allowfuture) {
92                 $item =& $this->items[$itemid];
93
94                 // check the draft and future rules if the item was already cached
95                 if ($item) {
96                         if ((!$allowdraft) && ($item['draft']))
97                                 return 0;
98
99                         $blog =& $this->getBlog(getBlogIDFromItemID($itemid));
100                         if ((!$allowfuture) && ($item['timestamp'] > $blog->getCorrectTime()))
101                                 return 0;
102                 }
103                 if (!$item) {
104                         // load class if needed
105                         $this->loadClass('ITEM');
106                         // load item object
107                         $item = ITEM::getitem($itemid, $allowdraft, $allowfuture);
108                         $this->items[$itemid] = $item;
109                 }
110                 return $item;
111         }
112
113         /**
114           * Loads a class if it has not yet been loaded
115           */
116         function loadClass($name) {
117                 $this->_loadClass($name, $name . '.php');
118         }
119
120         /**
121           * Checks if an item exists
122           */
123         function existsItem($id,$future,$draft) {
124                 $this->_loadClass('ITEM','ITEM.php');
125                 return ITEM::exists($id,$future,$draft);
126         }
127
128         /**
129           * Checks if a category exists
130           */
131         function existsCategory($id) {
132                 return (quickQuery('SELECT COUNT(*) as result FROM '.sql_table('category').' WHERE catid='.intval($id)) > 0);
133         }
134
135         function &getBlog($blogid) {
136                 $blog =& $this->blogs[$blogid];
137
138                 if (!$blog) {
139                         // load class if needed
140                         $this->_loadClass('BLOG','BLOG.php');
141                         // load blog object
142                         $blog =& new BLOG($blogid);
143                         $this->blogs[$blogid] =& $blog;
144                 }
145                 return $blog;
146         }
147
148         function existsBlog($name) {
149                 $this->_loadClass('BLOG','BLOG.php');
150                 return BLOG::exists($name);
151         }
152
153         function existsBlogID($id) {
154                 $this->_loadClass('BLOG','BLOG.php');
155                 return BLOG::existsID($id);
156         }
157
158         /**
159          * Returns a previously read template
160          */
161         function &getTemplate($templateName) {
162                 $template =& $this->templates[$templateName];
163
164                 if (!$template) {
165                         $template = TEMPLATE::read($templateName);
166                         $this->templates[$templateName] =& $template;
167                 }
168                 return $template;
169         }
170
171         /**
172          * Returns a KARMA object (karma votes)
173          */
174         function &getKarma($itemid) {
175                 $karma =& $this->karma[$itemid];
176
177                 if (!$karma) {
178                         // load class if needed
179                         $this->_loadClass('KARMA','KARMA.php');
180                         // create KARMA object
181                         $karma =& new KARMA($itemid);
182                         $this->karma[$itemid] =& $karma;
183                 }
184                 return $karma;
185         }
186
187         /**
188          * Returns a MEMBER object
189          */
190         function &getMember($memberid) {
191                 $mem =& $this->members[$memberid];
192
193                 if (!$mem) {
194                         // load class if needed
195                         $this->_loadClass('MEMBER','MEMBER.php');
196                         // create MEMBER object
197                         $mem =& MEMBER::createFromID($memberid);
198                         $this->members[$memberid] =& $mem;
199                 }
200                 return $mem;
201         }
202
203         /**
204          * Global parser preferences
205          */
206         function setParserProperty($name, $value) {
207                 $this->parserPrefs[$name] = $value;
208         }
209         function getParserProperty($name) {
210                 return $this->parserPrefs[$name];
211         }
212
213         /**
214           * A private helper class to load classes
215           */
216         function _loadClass($name, $filename) {
217                 if (!class_exists($name)) {
218                                 global $DIR_LIBS;
219                                 include($DIR_LIBS . $filename);
220                 }
221         }
222
223         function _loadPlugin($name) {
224                 if (!class_exists($name)) {
225                                 global $DIR_PLUGINS;
226
227                                 $fileName = $DIR_PLUGINS . $name . '.php';
228
229                                 if (!file_exists($fileName))
230                                 {
231                                         ACTIONLOG::add(WARNING, 'Plugin ' . $name . ' was not loaded (File not found)');
232                                         return 0;
233                                 }
234
235                                 // load plugin
236                                 include($fileName);
237
238                                 // check if class exists (avoid errors in eval'd code)
239                                 if (!class_exists($name))
240                                 {
241                                         ACTIONLOG::add(WARNING, 'Plugin ' . $name . ' was not loaded (Class not found in file, possible parse error)');
242                                         return 0;
243                                 }
244
245                                 // add to plugin array
246                                 eval('$this->plugins[$name] =& new ' . $name . '();');
247
248                                 // get plugid
249                                 $this->plugins[$name]->plugid = $this->getPidFromName($name);
250
251                                 // unload plugin if a prefix is used and the plugin cannot handle this^
252                                 global $MYSQL_PREFIX;
253                                 if (($MYSQL_PREFIX != '') && !$this->plugins[$name]->supportsFeature('SqlTablePrefix'))
254                                 {
255                                         unset($this->plugins[$name]);
256                                         ACTIONLOG::add(WARNING, 'Plugin ' . $name . ' was not loaded (does not support SqlTablePrefix)');
257                                         return 0;
258                                 }
259
260                                 // call init method
261                                 $this->plugins[$name]->init();
262
263                 }
264         }
265
266         function &getPlugin($name) {
267                 $plugin =& $this->plugins[$name];
268
269                 if (!$plugin) {
270                         // load class if needed
271                         $this->_loadPlugin($name);
272                         $plugin =& $this->plugins[$name];
273                 }
274                 return $plugin;
275         }
276
277         /**
278           * checks if the given plugin IS installed or not
279           */
280         function pluginInstalled($name) {
281                 $this->_initCacheInfo('installedPlugins');
282                 return ($this->getPidFromName($name) != -1);
283         }
284         function pidInstalled($pid) {
285                 $this->_initCacheInfo('installedPlugins');
286                 return ($this->cachedInfo['installedPlugins'][$pid] != '');
287         }
288         function getPidFromName($name) {
289                 $this->_initCacheInfo('installedPlugins');
290                 foreach ($this->cachedInfo['installedPlugins'] as $pid => $pfile)
291                 {
292                         if ($pfile == $name)
293                                 return $pid;
294                 }
295                 return -1;
296         }
297         function clearCachedInfo($what) {
298                 unset($this->cachedInfo[$what]);
299         }
300
301         /**
302          * Loads some info on the first call only
303          */
304         function _initCacheInfo($what)
305         {
306                 if (isset($this->cachedInfo[$what]) && is_array($this->cachedInfo[$what]))
307                         return;
308                 switch ($what)
309                 {
310                         // 'installedPlugins' = array ($pid => $name)
311                         case 'installedPlugins':
312                                 $this->cachedInfo['installedPlugins'] = array();
313                                 $res = sql_query('SELECT pid, pfile FROM ' . sql_table('plugin'));
314                                 while ($o = mysql_fetch_object($res))
315                                 {
316                                         $this->cachedInfo['installedPlugins'][$o->pid] = $o->pfile;
317                                 }
318                                 break;
319                 }
320         }
321
322         /**
323           * A function to notify plugins that something has happened. Only the plugins
324           * that are subscribed to the event will get notified.
325           * Upon the first call, the list of subscriptions will be fetched from the
326           * database. The plugins itsself will only get loaded when they are first needed
327           *
328           * @param $eventName
329           *             Name of the event (method to be called on plugins)
330           * @param $data
331           *             Can contain any type of data, depending on the event type. Usually this is
332           *             an itemid, blogid, ... but it can also be an array containing multiple values
333           */
334         function notify($eventName, $data) {
335                 // load subscription list if needed
336                 if (!is_array($this->subscriptions))
337                         $this->_loadSubscriptions();
338
339
340                 // get listening objects
341                 $listeners = false;
342                 if (isset($this->subscriptions[$eventName])) {
343                         $listeners = $this->subscriptions[$eventName];
344                 }
345
346                 // notify all of them
347                 if (is_array($listeners)) {
348                         foreach($listeners as $listener) {
349                                 // load class if needed
350                                 $this->_loadPlugin($listener);
351                                 // do notify (if method exists)
352                                 if (method_exists($this->plugins[$listener], 'event_' . $eventName))
353                                         call_user_func(array(&$this->plugins[$listener],'event_' . $eventName), $data);
354                         }
355                 }
356
357         }
358
359         /**
360           * Loads plugin subscriptions
361           */
362         function _loadSubscriptions() {
363                 // initialize as array
364                 $this->subscriptions = array();
365
366                 $res = sql_query('SELECT p.pfile as pfile, e.event as event FROM '.sql_table('plugin_event').' as e, '.sql_table('plugin').' as p WHERE e.pid=p.pid ORDER BY p.porder ASC');
367                 while ($o = mysql_fetch_object($res)) {
368                         $pluginName = $o->pfile;
369                         $eventName = $o->event;
370                         $this->subscriptions[$eventName][] = $pluginName;
371                 }
372
373         }
374
375         /*
376                 Ticket functions. These are uses by the admin area to make it impossible to simulate certain GET/POST
377                 requests. tickets are user specific
378         */
379
380         var $currentRequestTicket = '';
381
382         /**
383          * GET requests: Adds ticket to URL (URL should NOT be html-encoded!, ticket is added at the end)
384          */
385         function addTicketToUrl($url)
386         {
387                 $ticketCode = 'ticket=' . $this->_generateTicket();
388                 if (strstr($url, '?'))
389                         return $url . '&' . $ticketCode;
390                 else
391                         return $url . '?' . $ticketCode;
392         }
393
394         /**
395          * POST requests: Adds ticket as hidden formvar
396          */
397         function addTicketHidden()
398         {
399                 $ticket = $this->_generateTicket();
400
401                 echo '<input type="hidden" name="ticket" value="', htmlspecialchars($ticket), '" />';
402         }
403
404         /**
405          * Get a new ticket
406          * (xmlHTTPRequest AutoSaveDraft uses this to refresh the ticket)
407          */
408         function getNewTicket()
409         {
410                 $this->currentRequestTicket = '';
411                 return $this->_generateTicket();
412         }
413
414         /**
415          * Checks the ticket that was passed along with the current request
416          */
417         function checkTicket()
418         {
419                 global $member;
420
421                 // get ticket from request
422                 $ticket = requestVar('ticket');
423
424                 // no ticket -> don't allow
425                 if ($ticket == '')
426                         return false;
427
428                 // remove expired tickets first
429                 $this->_cleanUpExpiredTickets();
430
431                 // get member id
432                 if (!$member->isLoggedIn())
433                         $memberId = -1;
434                 else
435                         $memberId = $member->getID();
436
437                 // check if ticket is a valid one
438                 $query = 'SELECT COUNT(*) as result FROM ' . sql_table('tickets') . ' WHERE member=' . intval($memberId). ' and ticket=\''.addslashes($ticket).'\'';
439                 if (quickQuery($query) == 1)
440                 {
441                         // [in the original implementation, the checked ticket was deleted. This would lead to invalid
442                         //  tickets when using the browsers back button and clicking another link/form
443                         //  leaving the keys in the database is not a real problem, since they're member-specific and
444                         //  only valid for a period of one hour
445                         // ]
446                         // sql_query('DELETE FROM '.sql_table('tickets').' WHERE member=' . intval($memberId). ' and ticket=\''.addslashes($ticket).'\'');
447                         return true;
448                 } else {
449                         // not a valid ticket
450                         return false;
451                 }
452
453         }
454
455         /**
456          * (internal method) Removes the expired tickets
457          */
458         function _cleanUpExpiredTickets()
459         {
460                 // remove tickets older than 1 hour
461                 $oldTime = time() - 60 * 60;
462                 $query = 'DELETE FROM ' . sql_table('tickets'). ' WHERE ctime < \'' . date('Y-m-d H:i:s',$oldTime) .'\'';
463                 sql_query($query);
464         }
465
466         /**
467          * (internal method) Generates/returns a ticket (one ticket per page request)
468          */
469         function _generateTicket()
470         {
471                 if ($this->currentRequestTicket == '')
472                 {
473                         // generate new ticket (only one ticket will be generated per page request)
474                         // and store in database
475                         global $member;
476                         // get member id
477                         if (!$member->isLoggedIn())
478                                 $memberId = -1;
479                         else
480                                 $memberId = $member->getID();
481
482                         $ok = false;
483                         while (!$ok)
484                         {
485                                 // generate a random token
486                                 srand((double)microtime()*1000000);
487                                 $ticket = md5(uniqid(rand(), true));
488
489                                 // add in database as non-active
490                                 $query = 'INSERT INTO ' . sql_table('tickets') . ' (ticket, member, ctime) ';
491                                 $query .= 'VALUES (\'' . addslashes($ticket). '\', \'' . intval($memberId). '\', \'' . date('Y-m-d H:i:s',time()) . '\')';
492                                 if (sql_query($query))
493                                         $ok = true;
494                         }
495
496                         $this->currentRequestTicket = $ticket;
497                 }
498                 return $this->currentRequestTicket;
499         }
500
501 }
502
503 ?>