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\Kernel\Handlers\XoopsModule;
 13: 
 14: /**
 15:  * @copyright       XOOPS Project (http://xoops.org)
 16:  * @license         GNU GPL 2 or later (http://www.gnu.org/licenses/gpl-2.0.html)
 17:  * @author          trabis <lusopoemas@gmail.com>
 18:  * @version         $Id$
 19:  */
 20: 
 21: class Notifications extends Xoops\Module\Helper\HelperAbstract
 22: {
 23:     /**
 24:      * Init the module
 25:      *
 26:      * @return null|void
 27:      */
 28:     public function init()
 29:     {
 30:         $this->setDirname('notifications');
 31:         define('NOTIFICATIONS_MODE_SENDALWAYS', 0);
 32:         define('NOTIFICATIONS_MODE_SENDONCETHENDELETE', 1);
 33:         define('NOTIFICATIONS_MODE_SENDONCETHENWAIT', 2);
 34:         define('NOTIFICATIONS_MODE_WAITFORLOGIN', 3);
 35: 
 36:         define('NOTIFICATIONS_METHOD_DISABLE', 0);
 37:         define('NOTIFICATIONS_METHOD_PM', 1);
 38:         define('NOTIFICATIONS_METHOD_EMAIL', 2);
 39: 
 40:         define('NOTIFICATIONS_DISABLE', 0);
 41:         define('NOTIFICATIONS_ENABLEBLOCK', 1);
 42:         define('NOTIFICATIONS_ENABLEINLINE', 2);
 43:         define('NOTIFICATIONS_ENABLEBOTH', 3);
 44:     }
 45: 
 46:     /**
 47:      * @return string
 48:      */
 49:     public static function getInstance()
 50:     {
 51:         return parent::getInstance();
 52:     }
 53: 
 54:     /**
 55:      * @return NotificationsNotificationHandler
 56:      */
 57:     public function getHandlerNotification()
 58:     {
 59:         return $this->getHandler('notification');
 60:     }
 61: 
 62:     /**
 63:      * @param string       $style
 64:      * @param null|string  $module_dirname
 65:      *
 66:      * @return bool
 67:      */
 68:     public function enabled($style, $module_dirname = null)
 69:     {
 70:         $xoops = Xoops::getInstance();
 71:         if ($status = $xoops->getModuleConfig('notifications_enabled')) {
 72:         } else {
 73:             if (!isset($module_dirname)) {
 74:                 return false;
 75:             }
 76: 
 77:             if (!$status = $xoops->getModuleConfig('notifications_enabled', $module_dirname)) {
 78:                 return false;
 79:             }
 80:         }
 81:         if (($style === 'block') && ($status == NOTIFICATIONS_ENABLEBLOCK || $status == NOTIFICATIONS_ENABLEBOTH)) {
 82:             return true;
 83:         }
 84:         if (($style === 'inline') && ($status == NOTIFICATIONS_ENABLEINLINE || $status == NOTIFICATIONS_ENABLEBOTH)) {
 85:             return true;
 86:         }
 87: 
 88:         return false;
 89:     }
 90: 
 91:     /**
 92:      * @param string $category
 93:      * @param int    $item_id
 94:      * @param string $dirname Module dirname
 95:      *
 96:      * @return array|bool
 97:      */
 98:     public function getItem($category, $item_id, $dirname = null)
 99:     {
100:         $xoops = Xoops::getInstance();
101:         if (!isset($dirname)) {
102:             $dirname = $xoops->module->getVar('dirname');
103:         }
104: 
105:         /* @var $plugin NotificationsPluginInterface */
106:         if ($plugin = \Xoops\Module\Plugin::getPlugin($dirname, 'notifications')) {
107:             return $plugin->item($category, (int)($item_id));
108:         }
109:         return false;
110:     }
111: 
112:     /**
113:      * @param string $category
114:      * @param int    $item_id
115:      * @param string $event
116:      * @param string $dirname Module dirname
117:      *
118:      * @return array|bool
119:      */
120:     public function getTags($category, $item_id, $event, $dirname = null)
121:     {
122:         $xoops = Xoops::getInstance();
123:         if (!isset($dirname)) {
124:             $dirname = $xoops->module->getVar('dirname');
125:         }
126: 
127:         /* @var $plugin NotificationsPluginInterface */
128:         if ($plugin = \Xoops\Module\Plugin::getPlugin($dirname, 'notifications')) {
129:             return $plugin->tags($category, (int)($item_id), $event, $dirname);
130:         }
131:         return array();
132:     }
133: 
134:     /**
135:      * Get an associative array of info for a particular notification
136:      * category in the selected module.  If no category is selected,
137:      * return an array of info for all categories.
138:      *
139:      * @param string $category_name Category name (default all categories)
140:      * @param string $dirname       ID of the module (default current module)
141:      *
142:      * @return mixed
143:      */
144:     public function getCategory($category_name = '', $dirname = null)
145:     {
146:         $xoops = Xoops::getInstance();
147:         if (!isset($dirname)) {
148:             $dirname = $xoops->module->getVar('dirname');
149:         }
150: 
151:         /* @var $plugin NotificationsPluginInterface */
152:         if ($plugin = \Xoops\Module\Plugin::getPlugin($dirname, 'notifications')) {
153:             $categories = $plugin->categories();
154:             if (empty($category_name)) {
155:                 return $categories;
156:             }
157:             foreach ($categories as $category) {
158:                 if ($category['name'] == $category_name) {
159:                     return $category;
160:                 }
161:             }
162:         }
163:         return false;
164:     }
165: 
166:     /**
167:      * Get associative array of info for the category to which comment events
168:      * belong.
169:      *
170:      * todo, this belongs in the comment module no? - trabis
171:      *
172:      * @param string $dirname Dirname of the module (default current module)
173:      *
174:      * @return mixed Associative array of category info
175:      */
176:     public function getCommentsCategory($dirname = null)
177:     {
178:         $ret = array();
179:         $all_categories = $this->getCategory('', $dirname);
180:         if (empty($all_categories)) {
181:             return $ret;
182:         }
183:         foreach ($all_categories as $category) {
184:             $all_events = $this->getEvents($category['name'], false, $dirname);
185:             if (empty($all_events)) {
186:                 continue;
187:             }
188:             foreach ($all_events as $event) {
189:                 if ($event['name'] === 'comment') {
190:                     return $category;
191:                 }
192:             }
193:         }
194:         return $ret;
195:     }
196: 
197:     // TODO: some way to include or exclude admin-only events...
198: 
199:     /**
200:      * Get an array of info for all events (each event has associative array)
201:      * in the selected category of the selected module.
202:      *
203:      * @param string $category_name Category name
204:      * @param bool   $enabled_only  If true, return only enabled events
205:      * @param string $dirname       Dirname of the module (default current module)
206:      *
207:      * @return mixed
208:      */
209:     public function getEvents($category_name, $enabled_only, $dirname = null)
210:     {
211:         $xoops = Xoops::getInstance();
212:         $helper = Notifications::getInstance();
213:         $commentHelper = $xoops->getModuleHelper('comments');
214: 
215:         if (!isset($dirname)) {
216:             $dirname = $xoops->isModule() ? $xoops->module->getVar('dirname') : '';
217:         }
218:         /* @var $plugin NotificationsPluginInterface */
219:         if ($plugin = \Xoops\Module\Plugin::getPlugin($dirname, 'notifications')) {
220: 
221:             $events = $plugin->events();
222: 
223:             $category = $this->getCategory($category_name, $dirname);
224: 
225:             $event_array = array();
226: 
227:             $override_comment = false;
228:             $override_commentsubmit = false;
229:             $override_bookmark = false;
230: 
231:             foreach ($events as $event) {
232:                 if ($event['category'] == $category_name) {
233:                     if (!is_dir($dir = \XoopsBaseConfig::get('root-path') . '/modules/' . $dirname . '/locale/' . $xoops->getConfig('locale') . '/templates/')) {
234:                         $dir = \XoopsBaseConfig::get('root-path') . '/modules/' . $dirname . '/locale/en_US/templates/';
235:                     }
236:                     $event['mail_template_dir'] = $dir;
237:                     if (!$enabled_only || $this->eventEnabled($category, $event, $dirname)) {
238:                         $event_array[] = $event;
239:                     }
240:                     if ($event['name'] === 'comment') {
241:                         $override_comment = true;
242:                     }
243:                     if ($event['name'] === 'comment_submit') {
244:                         $override_commentsubmit = true;
245:                     }
246:                     if ($event['name'] === 'bookmark') {
247:                         $override_bookmark = true;
248:                     }
249:                 }
250:             }
251: 
252:             $helper->loadLanguage('main');
253:             // Insert comment info if applicable
254: 
255:             /* @var $commentsPlugin CommentsPluginInterface */
256:             if (false!==$commentHelper && $commentsPlugin = \Xoops\Module\Plugin::getPlugin($dirname, 'comments')) {
257:                 //todo replace this
258:                 if (!empty($category['item_name']) && $category['item_name'] == $commentsPlugin->itemName()) {
259:                     if (!is_dir($dir = \XoopsBaseConfig::get('root-path') . '/locale/' . $xoops->getConfig('locale') . '/templates/')) {
260:                         $dir = \XoopsBaseConfig::get('root-path') . '/locale/en_US/templates/';
261:                     }
262:                     $mail_template_dir = $dir;
263: 
264:                     $com_config = $xoops->getModuleConfigs($dirname);
265:                     if (!$enabled_only) {
266:                         $insert_comment = true;
267:                         $insert_submit = true;
268:                     } else {
269:                         $insert_comment = false;
270:                         $insert_submit = false;
271:                         switch ($com_config['com_rule']) {
272:                             case Comments::APPROVE_NONE:
273:                                 // comments disabled, no comment events
274:                                 break;
275:                             case Comments::APPROVE_ALL:
276:                                 // all comments are automatically approved, no 'submit'
277:                                 if (!$override_comment) {
278:                                     $insert_comment = true;
279:                                 }
280:                                 break;
281:                             case Comments::APPROVE_USER:
282:                             case Comments::APPROVE_ADMIN:
283:                                 // comments first submitted, require later approval
284:                                 if (!$override_comment) {
285:                                     $insert_comment = true;
286:                                 }
287:                                 if (!$override_commentsubmit) {
288:                                     $insert_submit = true;
289:                                 }
290:                                 break;
291:                         }
292:                     }
293:                     if ($insert_comment) {
294:                         $event = array(
295:                             'name'              => 'comment',
296:                             'category'          => $category['name'],
297:                             'title'             => _MD_NOTIFICATIONS_COMMENT_NOTIFY,
298:                             'caption'           => _MD_NOTIFICATIONS_COMMENT_NOTIFYCAP,
299:                             'description'       => _MD_NOTIFICATIONS_COMMENT_NOTIFYDSC,
300:                             'mail_template_dir' => $mail_template_dir,
301:                             'mail_template'     => 'comment_notify',
302:                             'mail_subject'      => _MD_NOTIFICATIONS_COMMENT_NOTIFYSBJ
303:                         );
304:                         if (!$enabled_only || $this->eventEnabled($category, $event, $dirname)) {
305:                             $event_array[] = $event;
306:                         }
307:                     }
308:                     if ($insert_submit) {
309:                         $event = array(
310:                             'name'              => 'comment_submit',
311:                             'category'          => $category['name'],
312:                             'title'             => _MD_NOTIFICATIONS_COMMENTSUBMIT_NOTIFY,
313:                             'caption'           => _MD_NOTIFICATIONS_COMMENTSUBMIT_NOTIFYCAP,
314:                             'description'       => _MD_NOTIFICATIONS_COMMENTSUBMIT_NOTIFYDSC,
315:                             'mail_template_dir' => $mail_template_dir,
316:                             'mail_template'     => 'commentsubmit_notify',
317:                             'mail_subject'      => _MD_NOTIFICATIONS_COMMENTSUBMIT_NOTIFYSBJ,
318:                             'admin_only'        => 1
319:                         );
320:                         if (!$enabled_only || $this->eventEnabled($category, $event, $dirname)) {
321:                             $event_array[] = $event;
322:                         }
323:                     }
324:                 }
325:             }
326: 
327:             // Insert bookmark info if appropriate
328: 
329:             if (!empty($category['allow_bookmark'])) {
330:                 if (!$override_bookmark) {
331:                     $event = array(
332:                         'name'        => 'bookmark',
333:                         'category'    => $category['name'],
334:                         'title'       => _MD_NOTIFICATIONS_BOOKMARK_NOTIFY,
335:                         'caption'     => _MD_NOTIFICATIONS_BOOKMARK_NOTIFYCAP,
336:                         'description' => _MD_NOTIFICATIONS_BOOKMARK_NOTIFYDSC
337:                     );
338:                     if (!$enabled_only || $this->eventEnabled($category, $event, $dirname)) {
339:                         $event_array[] = $event;
340:                     }
341:                 }
342:             }
343: 
344:             return $event_array;
345:         }
346:         return array();
347:     }
348: 
349:     /**
350:      * Determine whether a particular notification event is enabled.
351:      * Depends on module config options.
352:      *
353:      * @todo  Check that this works correctly for comment and other
354:      *        events which depend on additional config options...
355:      *
356:      * @param array  &$category Category info array
357:      * @param array  &$event    Event info array
358:      * @param string $dirname   Module
359:      *
360:      * @return bool
361:      **/
362:     public function eventEnabled(&$category, &$event, $dirname)
363:     {
364:         $xoops = Xoops::getInstance();
365: 
366:         $mod_config = $xoops->getModuleConfigs($dirname);
367: 
368:         if (is_array($mod_config['notification_events']) && $mod_config['notification_events'] != array()) {
369:             $option_name = $this->generateConfig($category, $event, 'option_name');
370:             if (in_array($option_name, $mod_config['notification_events'])) {
371:                 return true;
372:             }
373:         }
374:         return false;
375:     }
376: 
377:     /**
378:      * Get associative array of info for the selected event in the selected
379:      * category (for the selected module).
380:      *
381:      * @param string $category_name  Notification category
382:      * @param string $event_name     Notification event
383:      * @param string $module_dirname Dirname of the module (default current module)
384:      *
385:      * @return mixed
386:      */
387:     public function getEvent($category_name, $event_name, $module_dirname = null)
388:     {
389:         $all_events = $this->getEvents($category_name, false, $module_dirname);
390:         foreach ($all_events as $event) {
391:             if ($event['name'] == $event_name) {
392:                 return $event;
393:             }
394:         }
395:         return false;
396:     }
397: 
398:     /**
399:      * Get an array of associative info arrays for subscribable categories
400:      * for the selected module.
401:      *
402:      * @param string $module_dirname ID of the module
403:      *
404:      * @return mixed
405:      */
406:     public function getSubscribableCategories($module_dirname = null)
407:     {
408:         $all_categories = $this->getCategory('', $module_dirname);
409: 
410:         // FIXME: better or more standardized way to do this?
411:         $script_url = explode('/', $_SERVER['PHP_SELF']);
412:         $script_name = $script_url[count($script_url) - 1];
413: 
414:         $sub_categories = array();
415:         foreach ($all_categories as $category) {
416:             // Check the script name
417:             $subscribe_from = $category['subscribe_from'];
418:             if (!is_array($subscribe_from)) {
419:                 if ($subscribe_from === '*') {
420:                     $subscribe_from = array(
421:                         $script_name
422:                     );
423:                     // FIXME: this is just a hack: force a match
424:                 } else {
425:                     $subscribe_from = array(
426:                         $subscribe_from
427:                     );
428:                 }
429:             }
430:             if (!in_array($script_name, $subscribe_from)) {
431:                 continue;
432:             }
433:             // If 'item_name' is missing, automatic match.  Otherwise
434:             // check if that argument exists...
435:             if (empty($category['item_name'])) {
436:                 $category['item_name'] = '';
437:                 $category['item_id'] = 0;
438:                 $sub_categories[] = $category;
439:             } else {
440:                 $item_name = $category['item_name'];
441:                 $id = ($item_name != '' && isset($_GET[$item_name])) ? (int)($_GET[$item_name]) : 0;
442:                 if ($id > 0) {
443:                     $category['item_id'] = $id;
444:                     $sub_categories[] = $category;
445:                 }
446:             }
447:         }
448:         return $sub_categories;
449:     }
450: 
451:     /**
452:      * Generate module config info for a particular category, event pair.
453:      * The selectable config options are given names depending on the
454:      * category and event names, and the text depends on the category
455:      * and event titles.  These are pieced together in this function in
456:      * case we wish to alter the syntax.
457:      *
458:      * @param array  &$category Array of category info
459:      * @param array  &$event    Array of event info
460:      * @param string $type      The particular name to generate
461:      *
462:      * @return bool|string
463:      */
464:     public function generateConfig(&$category, &$event, $type)
465:     {
466:         switch ($type) {
467:             case 'option_value':
468:             case 'name':
469:                 return 'notify:' . $category['name'] . '-' . $event['name'];
470:                 break;
471:             case 'option_name':
472:                 return $category['name'] . '-' . $event['name'];
473:                 break;
474:             default:
475:                 return false;
476:                 break;
477:         }
478:     }
479: 
480:     /**
481:      * @param XoopsModule $module
482:      */
483:     public function insertModuleRelations(XoopsModule $module)
484:     {
485:         $xoops = Xoops::getInstance();
486:         $config_handler = $xoops->getHandlerConfig();
487:         $configs = $this->getPluginableConfigs($module);
488: 
489:         //$existingConfigs = $xoops->getModuleConfigs($module->getVar('dirname'));
490:         $existingConfigs = $config_handler->getConfigsByModule($module->getVar('mid'));
491:         $order = $config_handler->getConfigCount(
492:             new \Xoops\Core\Kernel\Criteria('conf_modid', $module->getVar('mid'))
493:         );
494:         //$order = count($existingConfigs);
495:         foreach ($configs as $config) {
496:             if (!isset($existingConfigs[$config['name']])) {
497:                 $confobj = $config_handler->createConfig();
498:                 $confobj->setVar('conf_modid', $module->getVar('mid'));
499:                 $confobj->setVar('conf_catid', 0);
500:                 $confobj->setVar('conf_name', $config['name']);
501:                 $confobj->setVar('conf_title', $config['title']);
502:                 $confobj->setVar('conf_desc', $config['description']);
503:                 $confobj->setVar('conf_formtype', $config['formtype']);
504:                 $confobj->setVar('conf_valuetype', $config['valuetype']);
505:                 $confobj->setConfValueForInput($config['default']);
506:                 $confobj->setVar('conf_order', $order);
507:                 if (isset($config['options']) && is_array($config['options'])) {
508:                     foreach ($config['options'] as $key => $value) {
509:                         $confop = $config_handler->createConfigOption();
510:                         $confop->setVar('confop_name', $key);
511:                         $confop->setVar('confop_value', $value);
512:                         $confobj->setConfOptions($confop);
513:                         unset($confop);
514:                     }
515:                 }
516:                 ++$order;
517:                 $config_handler->insertConfig($confobj);
518:             }
519:         }
520:     }
521: 
522:     /**
523:      * @param XoopsModule $module
524:      */
525:     public function deleteModuleRelations(XoopsModule $module)
526:     {
527:         $xoops = Xoops::getInstance();
528:         $this->getHandlerNotification()->unsubscribeByModule($module->getVar('mid'));
529: 
530: 
531:         $configNames = array('notifications_enabled', 'notification_events');
532:         $config_handler = $xoops->getHandlerConfig();
533: 
534:         //Delete all configs
535:         $criteria = new CriteriaCompo();
536:         $criteria->add(new Criteria('conf_modid', $module->getVar('mid')));
537:         $criteria->add(new Criteria('conf_name', "('" . implode("','", $configNames) . "')", 'IN'));
538:         $configs = $config_handler->getConfigs($criteria);
539:         /* @var $config XoopsConfigItem */
540:         foreach ($configs as $config) {
541:             $config_handler->deleteConfig($config);
542:         }
543:     }
544: 
545:     /**
546:      * @param XoopsModule $module
547:      *
548:      * @return array
549:      */
550:     public function getPluginableConfigs(XoopsModule $module)
551:     {
552:         $configs = array();
553:         $options['_MD_NOTIFICATIONS_CONFIG_DISABLE'] = NOTIFICATIONS_DISABLE;
554:         $options['_MD_NOTIFICATIONS_CONFIG_ENABLEBLOCK'] = NOTIFICATIONS_ENABLEBLOCK;
555:         $options['_MD_NOTIFICATIONS_CONFIG_ENABLEINLINE'] = NOTIFICATIONS_ENABLEINLINE;
556:         $options['_MD_NOTIFICATIONS_CONFIG_ENABLEBOTH'] = NOTIFICATIONS_ENABLEBOTH;
557: 
558:         $configs[] = array(
559:             'name'        => 'notifications_enabled',
560:             'title'       => '_MD_NOTIFICATIONS_CONFIG_ENABLE',
561:             'description' => '_MD_NOTIFICATIONS_CONFIG_ENABLEDSC',
562:             'formtype'    => 'select',
563:             'valuetype'   => 'int',
564:             'default'     => NOTIFICATIONS_ENABLEBOTH,
565:             'options'     => $options
566:         );
567:         // Event-specific notification options
568:         // FIXME: doesn't work when update module... can't read back the array of options properly...  " changing to &quot;
569:         $options = array();
570:         $categories = $this->getCategory('', $module->getVar('dirname'));
571:         foreach ($categories as $category) {
572:             $events = $this->getEvents($category['name'], false, $module->getVar('dirname'));
573:             foreach ($events as $event) {
574:                 if (!empty($event['invisible'])) {
575:                     continue;
576:                 }
577:                 $option_name = $category['title'] . ' : ' . $event['title'];
578:                 $option_value = $category['name'] . '-' . $event['name'];
579:                 $options[$option_name] = $option_value;
580:             }
581:             unset($events);
582:         }
583:         unset($categories);
584:         $configs[] = array(
585:             'name'        => 'notification_events',
586:             'title'       => '_MD_NOTIFICATIONS_CONFIG_EVENTS',
587:             'description' => '_MD_NOTIFICATIONS_CONFIG_EVENTSDSC',
588:             'formtype'    => 'select_multi',
589:             'valuetype'   => 'array',
590:             'default'     => array_values($options),
591:             'options'     => $options
592:         );
593:         return $configs;
594:     }
595: }
596: