1: <?php
  2: /*
  3:  You may not change or alter any portion of this comment or credits
  4:  of supporting developers from this source code or any supporting source code
  5:  which is considered copyrighted (c) material of the original comment or credit authors.
  6: 
  7:  This program is distributed in the hope that it will be useful,
  8:  but WITHOUT ANY WARRANTY; without even the implied warranty of
  9:  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 10: */
 11: 
 12: use Xoops\Core\PreloadItem;
 13: 
 14: /**
 15:  * LegacyLogger core preloads
 16:  *
 17:  * @category  LegacyLogger
 18:  * @package   LegacyLogger
 19:  * @author    Richard Griffith <richard@geekwright.com>
 20:  * @author    trabis <lusopoemas@gmail.com>
 21:  * @copyright 2013 XOOPS Project (http://xoops.org)
 22:  * @license   GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 23:  * @version   Release: 1.0
 24:  * @link      http://xoops.org
 25:  * @since     1.0
 26:  */
 27: class LoggerPreload extends PreloadItem
 28: {
 29:     /**
 30:      * getConfigs
 31:      *
 32:      * @return array of config options
 33:      */
 34:     private static function getConfigs()
 35:     {
 36:         static $configs = null;
 37: 
 38:         if (is_null($configs)) {
 39:             $xoops = Xoops::getInstance();
 40:             $user_groups = $xoops->getUserGroups();
 41:             $moduleperm_handler = $xoops->getHandlerGroupPermission();
 42:             $helper = $xoops->getModuleHelper('logger');
 43:             $mid = $helper->getModule()->getVar('mid');
 44:             if ($moduleperm_handler->checkRight('use_logger', 0, $user_groups, $mid)) {
 45:                 // get default settings
 46:                 $configs['logger_enable'] = $helper->getConfig('logger_enable');
 47:                 $configs['logger_popup'] = $helper->getConfig('logger_popup');
 48:                 $configs['debug_smarty_enable'] = $helper->getConfig('debug_smarty_enable');
 49:                 // override with settings
 50:                 $uchelper = $xoops->getModuleHelper('userconfigs');
 51:                 if ($xoops->isUser() && $uchelper) {
 52:                     $config_handler = $uchelper->getHandlerConfig();
 53:                     $user_configs =
 54:                         $config_handler->getConfigsByUser($xoops->user->getVar('uid'), $mid);
 55:                     if (array_key_exists('logger_enable', $user_configs)) {
 56:                         $configs['logger_enable'] = $user_configs['logger_enable'];
 57:                     }
 58:                     if (array_key_exists('logger_popup', $user_configs)) {
 59:                         $configs['logger_popup'] = $user_configs['logger_popup'];
 60:                     }
 61:                     if (array_key_exists('debug_smarty_enable', $user_configs)) {
 62:                         $configs['debug_smarty_enable'] = $user_configs['debug_smarty_enable'];
 63:                     }
 64:                 }
 65:             } else {
 66:                 // user has no permissions, turn everything off
 67:                 $configs['logger_enable'] = 0;
 68:                 $configs['logger_popup'] = 0;
 69:                 $configs['debug_smarty_enable'] = 0;
 70:             }
 71:         }
 72: 
 73:         return $configs;
 74:     }
 75: 
 76:     /**
 77:      * eventCoreException
 78:      *
 79:      * @param Exception $e an exception
 80:      *
 81:      * @return void
 82:      */
 83:     public static function eventCoreException($e)
 84:     {
 85:         LegacyLogger::getInstance()->addException($e);
 86:     }
 87: 
 88:     /**
 89:      * listen for core.include.common.classmaps
 90:      * add any module specific class map entries
 91:      *
 92:      * @param mixed $args not used
 93:      *
 94:      * @return void
 95:      */
 96:     public static function eventCoreIncludeCommonClassmaps($args)
 97:     {
 98:         $path = dirname(__DIR__);
 99:         XoopsLoad::addMap(array(
100:             'legacylogger' => $path . '/class/legacylogger.php',
101:         ));
102:     }
103: 
104:     /**
105:      * eventCoreIncludeCommonStart
106:      *
107:      * @param mixed $args arguments supplied to triggerEvent
108:      *
109:      * @return void
110:      */
111:     public static function eventCoreIncludeCommonStart($args)
112:     {
113:         if (class_exists('LegacyLogger')) {
114:             LegacyLogger::getInstance()->enable();//until we get a db connection debug is enabled
115:             LegacyLogger::getInstance()->startTime();
116:             LegacyLogger::getInstance()->startTime('XOOPS Boot');
117:         }
118:     }
119: 
120:     /**
121:      * core.database.noconn
122:      *
123:      * @param array $args arguments
124:      *
125:      * @return void
126:      */
127:     public static function eventCoreDatabaseNoconn($args)
128:     {
129:         if (!class_exists('LegacyLogger')) {
130:             return;
131:         }
132:         /* @var $db Xoops\Core\Database\Connection */
133:         $db = $args[0];
134:         LegacyLogger::getInstance()->addQuery('', $db->error(), $db->errno());
135:     }
136: 
137:     /**
138:      * eventCoreDatabaseNodb
139:      *
140:      * @param mixed $args arguments supplied to triggerEvent
141:      *
142:      * @return void
143:      */
144:     public static function eventCoreDatabaseNodb($args)
145:     {
146:         if (!class_exists('LegacyLogger')) {
147:             return;
148:         }
149:         /* @var $db Xoops\Core\Database\Connection */
150:         $db = $args[0];
151:         LegacyLogger::getInstance()->addQuery('', $db->error(), $db->errno());
152:     }
153: 
154:     /**
155:      * eventCoreDatabaseQueryComplete
156:      *
157:      * @param mixed $args arguments supplied to triggerEvent
158:      *
159:      * @return void
160:      */
161:     public static function eventCoreDatabaseQueryComplete($args)
162:     {
163:         $sql = $args['sql'];
164:         //XoopsLoad::addMap(array('legacylogger' => dirname(__DIR__) . '/class/legacylogger.php'));
165:         LegacyLogger::getInstance()->addQuery($sql, null, null, $args['executionMS']);
166:     }
167: 
168:     /**
169:      * eventCoreIncludeCommonConfigsSuccess
170:      *
171:      * @param mixed $args arguments supplied to triggerEvent
172:      *
173:      * @return void
174:      */
175:     public static function eventCoreIncludeCommonConfigsSuccess($args)
176:     {
177:         /*
178:         $xoops = Xoops::getInstance();
179:         $logger = LegacyLogger::getInstance();
180:         $configs = self::getConfigs();
181:         if ($configs['logger_enable']) {
182:             $xoops->loadLocale();
183:             $xoops->loadLanguage('main', 'logger');
184:             $logger->enable();
185:         } else {
186:             $xoops->disableErrorReporting();
187:         }
188:         */
189:     }
190: 
191:     /**
192:      * eventCoreIncludeCommonAuthSuccess
193:      *
194:      * @return void
195:      */
196:     public static function eventCoreIncludeCommonAuthSuccess()
197:     {
198:         $xoops = Xoops::getInstance();
199:         $logger = LegacyLogger::getInstance();
200:         $configs = self::getConfigs();
201:         if ($configs['logger_enable']) {
202:             $xoops->loadLocale();
203:             $xoops->loadLanguage('main', 'logger');
204:             $logger->setConfigs($configs);
205:             $logger->enable();
206:         } else {
207:             $logger->disable();
208:         }
209:     }
210: 
211:     /**
212:      * eventCoreIncludeCommonEnd
213:      *
214:      * @param mixed $args arguments supplied to triggerEvent
215:      *
216:      * @return void
217:      */
218:     public static function eventCoreIncludeCommonEnd($args)
219:     {
220:         $logger = LegacyLogger::getInstance();
221:         $logger->stopTime('XOOPS Boot');
222:         $logger->startTime('Module init');
223:     }
224: 
225:     /**
226:      * eventCoreTemplateConstructStart
227:      *
228:      * @param mixed $args arguments supplied to triggerEvent
229:      *
230:      * @return void
231:      */
232:     public static function eventCoreTemplateConstructStart($args)
233:     {
234:         $tpl = $args[0];
235:         $configs = self::getConfigs();
236:         if ($configs['logger_enable']) {
237:             $tpl->debugging_ctrl = 'URL';
238:         }
239:         if ($configs['debug_smarty_enable']) {
240:                 $tpl->debugging = true;
241:         }
242:     }
243: 
244:     /**
245:      * eventCoreThemeRenderStart
246:      *
247:      * @param mixed $args arguments supplied to triggerEvent
248:      *
249:      * @return void
250:      */
251:     public static function eventCoreThemeRenderStart($args)
252:     {
253:         LegacyLogger::getInstance()->startTime('Page rendering');
254:     }
255: 
256:     /**
257:      * eventCoreThemeRenderEnd
258:      *
259:      * @param mixed $args arguments supplied to triggerEvent
260:      *
261:      * @return void
262:      */
263:     public static function eventCoreThemeRenderEnd($args)
264:     {
265:         LegacyLogger::getInstance()->stopTime('Page rendering');
266:     }
267: 
268:     /**
269:      * eventCoreThemeCheckcacheSuccess
270:      *
271:      * @param mixed $args arguments supplied to triggerEvent
272:      *
273:      * @return void
274:      */
275:     public static function eventCoreThemeCheckcacheSuccess($args)
276:     {
277:         $template = $args[0];
278:         $theme = $args[1];
279:         LegacyLogger::getInstance()
280:             ->addExtra($template, sprintf('Cached (regenerates every %d seconds)', $theme->contentCacheLifetime));
281:     }
282: 
283:     /**
284:      * eventCoreThemeblocksBuildblockStart
285:      *
286:      * @param mixed $args arguments supplied to triggerEvent
287:      *
288:      * @return void
289:      */
290:     public static function eventCoreThemeblocksBuildblockStart($args)
291:     {
292:         /* @var $block XoopsBlock */
293:         $block = $args[0];
294:         $isCached= $args[1];
295:         LegacyLogger::getInstance()->addBlock($block->getVar('name'), $isCached, $block->getVar('bcachetime'));
296:     }
297: 
298:     /**
299:      * eventCoreDeprecated
300:      *
301:      * @param mixed $args arguments supplied to triggerEvent
302:      *
303:      * @return void
304:      */
305:     public static function eventCoreDeprecated($args)
306:     {
307:         $message = $args[0];
308:         LegacyLogger::getInstance()->addDeprecated($message);
309:     }
310: 
311:     /**
312:      * eventCoreDisableerrorreporting
313:      *
314:      * @param mixed $args arguments supplied to triggerEvent
315:      *
316:      * @return void
317:      */
318:     public static function eventCoreDisableerrorreporting($args)
319:     {
320:         LegacyLogger::getInstance()->disable();
321:     }
322: 
323:     /**
324:      * eventCoreHeaderStart
325:      *
326:      * @param mixed $args arguments supplied to triggerEvent
327:      *
328:      * @return void
329:      */
330:     public static function eventCoreHeaderStart($args)
331:     {
332:         $logger = LegacyLogger::getInstance();
333:         $logger->stopTime('Module init');
334:         $logger->startTime('XOOPS output init');
335:     }
336: 
337:     /**
338:      * eventCoreHeaderEnd
339:      *
340:      * @param mixed $args arguments supplied to triggerEvent
341:      *
342:      * @return void
343:      */
344:     public static function eventCoreHeaderEnd($args)
345:     {
346:         $logger = LegacyLogger::getInstance();
347:         $logger->stopTime('XOOPS output init');
348:         $logger->startTime('Module display');
349:     }
350: 
351:     /**
352:      * eventCoreFooterStart
353:      *
354:      * @param mixed $args arguments supplied to triggerEvent
355:      *
356:      * @return void
357:      */
358:     public static function eventCoreFooterStart($args)
359:     {
360:         $logger = LegacyLogger::getInstance();
361:         $logger->stopTime('Module display');
362:     }
363: 
364:     /**
365:      * eventCoreFooterEnd
366:      *
367:      * @param mixed $args arguments supplied to triggerEvent
368:      *
369:      * @return void
370:      */
371:     public static function eventCoreFooterEnd($args)
372:     {
373:         $logger = LegacyLogger::getInstance();
374:         $logger->stopTime();
375:     }
376: 
377:     /**
378:      * eventCoreIncludeFunctionsRedirectheaderEnd
379:      *
380:      * @param mixed $args arguments supplied to triggerEvent
381:      *
382:      * @return void
383:      */
384:     public static function eventCoreIncludeFunctionsRedirectheaderEnd($args)
385:     {
386:         $xoops = Xoops::getInstance();
387:         $logger = LegacyLogger::getInstance();
388:         $debug_mode = $xoops->getModuleConfig('debug_mode', 'logger');
389:         if ($debug_mode == 2) {
390:             //Should we give extra time ?
391:             //$xoops->tpl()->assign('time', 300);
392:             $xoops->tpl()->assign('xoops_logdump', $logger->dump());
393:         }
394:     }
395: 
396:     /**
397:      * eventCoreSecurityValidatetokenEnd
398:      *
399:      * @param mixed $args arguments supplied to triggerEvent
400:      *
401:      * @return void
402:      */
403:     public static function eventCoreSecurityValidatetokenEnd($args)
404:     {
405:         $logger = LegacyLogger::getInstance();
406:         $logs = $args[0];
407:         foreach ($logs as $log) {
408:             $logger->addExtra($log[0], $log[1]);
409:         }
410:     }
411: 
412:     /**
413:      * eventCoreModuleAddlog
414:      *
415:      * @param mixed $args arguments supplied to triggerEvent
416:      *
417:      * @return void
418:      */
419:     public static function eventCoreModuleAddlog($args)
420:     {
421:         LegacyLogger::getInstance()->addExtra($args[0], $args[1]);
422:     }
423: 
424:     /**
425:      * system.preferences.save
426:      *
427:      * @param mixed $args arguments supplied to triggerEvent
428:      *
429:      * @return void
430:      */
431:     public static function eventSystemPreferencesSave($args)
432:     {
433:         XoopsLoad::addMap(array('legacylogger' => dirname(__DIR__) . '/class/legacylogger.php'));
434:     }
435: }
436: