1: <?php
  2: /**
  3:  * XOOPS Notifications
  4:  *
  5:  * You may not change or alter any portion of this comment or credits
  6:  * of supporting developers from this source code or any supporting source code
  7:  * which is considered copyrighted (c) material of the original comment or credit authors.
  8:  * This program is distributed in the hope that it will be useful,
  9:  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 10:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 11:  *
 12:  * @copyright       (c) 2000-2016 XOOPS Project (www.xoops.org)
 13:  * @license             GNU GPL 2 (http://www.gnu.org/licenses/gpl-2.0.html)
 14:  * @package             kernel
 15:  * @subpackage          Xoop Notifications Functions
 16:  * @since               2.0.0
 17:  * @author              Kazumi Ono (AKA onokazu) http://www.myweb.ne.jp/, http://jp.xoops.org/
 18:  */
 19: defined('XOOPS_ROOT_PATH') || exit('Restricted access');
 20: 
 21: // RMV-NOTIFY
 22: 
 23: // FIXME: Do some caching, so we don't retrieve the same category / event
 24: // info many times.
 25: 
 26: /**
 27:  * Determine if notification is enabled for the selected module.
 28:  *
 29:  * @param  string $style     Subscription style: 'block' or 'inline'
 30:  * @param  int    $module_id ID of the module  (default current module)
 31:  * @return bool
 32:  */
 33: function notificationEnabled($style, $module_id = null)
 34: {
 35:     if (isset($GLOBALS['xoopsModuleConfig']['notification_enabled'])) {
 36:         $status = $GLOBALS['xoopsModuleConfig']['notification_enabled'];
 37:     } else {
 38:         if (!isset($module_id)) {
 39:             return false;
 40:         }
 41:         /* @var $module_handler XoopsModuleHandler */
 42:         $module_handler = xoops_getHandler('module');
 43:         $module         = $module_handler->get($module_id);
 44:         if (!empty($module) && $module->getVar('hasnotification') == 1) {
 45:             /* @var $config_handler XoopsConfigHandler  */
 46:             $config_handler = xoops_getHandler('config');
 47:             $config         = $config_handler->getConfigsByCat(0, $module_id);
 48:             $status         = $config['notification_enabled'];
 49:         } else {
 50:             return false;
 51:         }
 52:     }
 53:     include_once $GLOBALS['xoops']->path('include/notification_constants.php');
 54:     if (($style === 'block') && ($status === XOOPS_NOTIFICATION_ENABLEBLOCK || $status === XOOPS_NOTIFICATION_ENABLEBOTH)) {
 55:         return true;
 56:     }
 57: 
 58:     return ($style === 'inline') && ($status === XOOPS_NOTIFICATION_ENABLEINLINE || $status === XOOPS_NOTIFICATION_ENABLEBOTH);
 59: }
 60: 
 61: /**
 62:  * Get an associative array of info for a particular notification
 63:  * category in the selected module.  If no category is selected,
 64:  * return an array of info for all categories.
 65:  *
 66:  * @param string $category_name
 67:  * @param  int   $module_id ID of the module (default current module)
 68:  *
 69:  * @internal param string $name Category name (default all categories)
 70:  * @return mixed
 71:  */
 72: function &notificationCategoryInfo($category_name = '', $module_id = null)
 73: {
 74:     if (!isset($module_id)) {
 75:         global $xoopsModule;
 76:         $module_id = !empty($xoopsModule) ? $xoopsModule->getVar('mid') : 0;
 77:         $module    =& $xoopsModule;
 78:     } else {
 79:         /* @var $module_handler XoopsModuleHandler */
 80:         $module_handler = xoops_getHandler('module');
 81:         $module         = $module_handler->get($module_id);
 82:     }
 83:     $not_config = &$module->getInfo('notification');
 84:     if (empty($category_name)) {
 85:         return $not_config['category'];
 86:     }
 87:     foreach ($not_config['category'] as $category) {
 88:         if ($category['name'] == $category_name) {
 89:             return $category;
 90:         }
 91:     }
 92:     $ret = false;
 93: 
 94:     return $ret;
 95: }
 96: 
 97: /**
 98:  * Get associative array of info for the category to which comment events
 99:  * belong.
100:  *
101:  * @todo This could be more efficient... maybe specify in
102:  *        $modversion['comments'] the notification category.
103:  *       This would also serve as a way to enable notification
104:  *        of comments, and also remove the restriction that
105:  *        all notification categories must have unique item_name. (TODO)
106:  *
107:  * @param  int $module_id ID of the module (default current module)
108:  * @return mixed            Associative array of category info
109:  */
110: function &notificationCommentCategoryInfo($module_id = null)
111: {
112:     $ret            = false;
113:     $all_categories =& notificationCategoryInfo('', $module_id);
114:     if (empty($all_categories)) {
115:         return $ret;
116:     }
117:     foreach ($all_categories as $category) {
118:         $all_events =& notificationEvents($category['name'], false, $module_id);
119:         if (empty($all_events)) {
120:             continue;
121:         }
122:         foreach ($all_events as $event) {
123:             if ($event['name'] === 'comment') {
124:                 return $category;
125:             }
126:         }
127:     }
128: 
129:     return $ret;
130: }
131: 
132: // TODO: some way to include or exclude admin-only events...
133: 
134: /**
135:  * Get an array of info for all events (each event has associative array)
136:  * in the selected category of the selected module.
137:  *
138:  * @param  string $category_name Category name
139:  * @param  bool   $enabled_only  If true, return only enabled events
140:  * @param  int    $module_id     ID of the module (default current module)
141:  * @return mixed
142:  */
143: function &notificationEvents($category_name, $enabled_only, $module_id = null)
144: {
145:     if (!isset($module_id)) {
146:         global $xoopsModule;
147:         $module_id = !empty($xoopsModule) ? $xoopsModule->getVar('mid') : 0;
148:         $module    =& $xoopsModule;
149:     } else {
150:         /* @var $module_handler XoopsModuleHandler */
151:         $module_handler = xoops_getHandler('module');
152:         $module         = $module_handler->get($module_id);
153:     }
154:     $not_config     = $module->getInfo('notification');
155:     /* @var $config_handler XoopsConfigHandler  */
156:     $config_handler = xoops_getHandler('config');
157:     $mod_config     = $config_handler->getConfigsByCat(0, $module_id);
158: 
159:     $category =& notificationCategoryInfo($category_name, $module_id);
160: 
161:     global $xoopsConfig;
162:     $event_array = array();
163: 
164:     $override_comment       = false;
165:     $override_commentsubmit = false;
166:     $override_bookmark      = false;
167: 
168:     foreach ($not_config['event'] as $event) {
169:         if ($event['category'] == $category_name) {
170:             if (!is_dir($dir = XOOPS_ROOT_PATH . '/modules/' . $module->getVar('dirname') . '/language/' . $xoopsConfig['language'] . '/mail_template/')) {
171:                 $dir = XOOPS_ROOT_PATH . '/modules/' . $module->getVar('dirname') . '/language/english/mail_template/';
172:             }
173:             $event['mail_template_dir'] = $dir;
174:             if (!$enabled_only || notificationEventEnabled($category, $event, $module)) {
175:                 $event_array[] = $event;
176:             }
177:             if ($event['name'] === 'comment') {
178:                 $override_comment = true;
179:             }
180:             if ($event['name'] === 'comment_submit') {
181:                 $override_commentsubmit = true;
182:             }
183:             if ($event['name'] === 'bookmark') {
184:                 $override_bookmark = true;
185:             }
186:         }
187:     }
188: 
189:     xoops_loadLanguage('notification');
190:     // Insert comment info if applicable
191: 
192:     if ($module->getVar('hascomments')) {
193:         $com_config = $module->getInfo('comments');
194:         if (!empty($category['item_name']) && $category['item_name'] == $com_config['itemName']) {
195:             if (!is_dir($dir = XOOPS_ROOT_PATH . '/language/' . $xoopsConfig['language'] . '/mail_template/')) {
196:                 $dir = XOOPS_ROOT_PATH . '/language/english/mail_template/';
197:             }
198:             $mail_template_dir = $dir;
199: 
200:             include_once $GLOBALS['xoops']->path('include/comment_constants.php');
201:             $config_handler = xoops_getHandler('config');
202:             $com_config     = $config_handler->getConfigsByCat(0, $module_id);
203:             if (!$enabled_only) {
204:                 $insert_comment = true;
205:                 $insert_submit  = true;
206:             } else {
207:                 $insert_comment = false;
208:                 $insert_submit  = false;
209:                 switch ($com_config['com_rule']) {
210:                     case XOOPS_COMMENT_APPROVENONE:
211:                         // comments disabled, no comment events
212:                         break;
213:                     case XOOPS_COMMENT_APPROVEALL:
214:                         // all comments are automatically approved, no 'submit'
215:                         if (!$override_comment) {
216:                             $insert_comment = true;
217:                         }
218:                         break;
219:                     case XOOPS_COMMENT_APPROVEUSER:
220:                     case XOOPS_COMMENT_APPROVEADMIN:
221:                         // comments first submitted, require later approval
222:                         if (!$override_comment) {
223:                             $insert_comment = true;
224:                         }
225:                         if (!$override_commentsubmit) {
226:                             $insert_submit = true;
227:                         }
228:                         break;
229:                 }
230:             }
231:             if ($insert_comment) {
232:                 $event = array(
233:                     'name'              => 'comment',
234:                     'category'          => $category['name'],
235:                     'title'             => _NOT_COMMENT_NOTIFY,
236:                     'caption'           => _NOT_COMMENT_NOTIFYCAP,
237:                     'description'       => _NOT_COMMENT_NOTIFYDSC,
238:                     'mail_template_dir' => $mail_template_dir,
239:                     'mail_template'     => 'comment_notify',
240:                     'mail_subject'      => _NOT_COMMENT_NOTIFYSBJ);
241:                 if (!$enabled_only || notificationEventEnabled($category, $event, $module)) {
242:                     $event_array[] = $event;
243:                 }
244:             }
245:             if ($insert_submit) {
246:                 $event = array(
247:                     'name'              => 'comment_submit',
248:                     'category'          => $category['name'],
249:                     'title'             => _NOT_COMMENTSUBMIT_NOTIFY,
250:                     'caption'           => _NOT_COMMENTSUBMIT_NOTIFYCAP,
251:                     'description'       => _NOT_COMMENTSUBMIT_NOTIFYDSC,
252:                     'mail_template_dir' => $mail_template_dir,
253:                     'mail_template'     => 'commentsubmit_notify',
254:                     'mail_subject'      => _NOT_COMMENTSUBMIT_NOTIFYSBJ,
255:                     'admin_only'        => 1);
256:                 if (!$enabled_only || notificationEventEnabled($category, $event, $module)) {
257:                     $event_array[] = $event;
258:                 }
259:             }
260:         }
261:     }
262: 
263:     // Insert bookmark info if appropriate
264: 
265:     if (!empty($category['allow_bookmark'])) {
266:         if (!$override_bookmark) {
267:             $event = array(
268:                 'name'        => 'bookmark',
269:                 'category'    => $category['name'],
270:                 'title'       => _NOT_BOOKMARK_NOTIFY,
271:                 'caption'     => _NOT_BOOKMARK_NOTIFYCAP,
272:                 'description' => _NOT_BOOKMARK_NOTIFYDSC);
273:             if (!$enabled_only || notificationEventEnabled($category, $event, $module)) {
274:                 $event_array[] = $event;
275:             }
276:         }
277:     }
278: 
279:     return $event_array;
280: }
281: 
282: /**
283:  * Determine whether a particular notification event is enabled.
284:  * Depends on module config options.
285:  *
286:  * @todo  Check that this works correctly for comment and other
287:  *   events which depend on additional config options...
288:  *
289:  * @param  array  $category Category info array
290:  * @param  array  $event    Event info array
291:  * @param  object $module   Module
292:  * @return bool
293:  **/
294: function notificationEventEnabled(&$category, &$event, &$module)
295: {
296:     /* @var $config_handler XoopsConfigHandler  */
297:     $config_handler = xoops_getHandler('config');
298:     $mod_config     = $config_handler->getConfigsByCat(0, $module->getVar('mid'));
299: 
300:     if (is_array($mod_config['notification_events']) && $mod_config['notification_events'] != array()) {
301:         $option_name = notificationGenerateConfig($category, $event, 'option_name');
302:         if (in_array($option_name, $mod_config['notification_events'])) {
303:             return true;
304:         }
305:         $notification_handler = xoops_getHandler('notification');
306:     }
307: 
308:     return false;
309: }
310: 
311: /**
312:  * Get associative array of info for the selected event in the selected
313:  * category (for the selected module).
314:  *
315:  * @param  string $category_name Notification category
316:  * @param  string $event_name    Notification event
317:  * @param  int    $module_id     ID of the module (default current module)
318:  * @return mixed
319:  */
320: function &notificationEventInfo($category_name, $event_name, $module_id = null)
321: {
322:     $all_events =& notificationEvents($category_name, false, $module_id);
323:     foreach ($all_events as $event) {
324:         if ($event['name'] == $event_name) {
325:             return $event;
326:         }
327:     }
328:     $ret = false;
329: 
330:     return $ret;
331: }
332: 
333: /**
334:  * Get an array of associative info arrays for subscribable categories
335:  * for the selected module.
336:  *
337:  * @param  int $module_id ID of the module
338:  * @return mixed
339:  */
340: 
341: function &notificationSubscribableCategoryInfo($module_id = null)
342: {
343:     $all_categories =& notificationCategoryInfo('', $module_id);
344: 
345:     // FIXME: better or more standardized way to do this?
346:     $script_url  = explode('/', $_SERVER['PHP_SELF']);
347:     $script_name = $script_url[count($script_url) - 1];
348: 
349:     $sub_categories = array();
350:     if (null != $all_categories) {
351:     foreach ($all_categories as $category) {
352:         // Check the script name
353:         $subscribe_from = $category['subscribe_from'];
354:         if (!is_array($subscribe_from)) {
355:             if ($subscribe_from === '*') {
356:                 $subscribe_from = array(
357:                     $script_name);
358:                 // FIXME: this is just a hack: force a match
359:             } else {
360:                 $subscribe_from = array(
361:                     $subscribe_from);
362:             }
363:         }
364:         if (!in_array($script_name, $subscribe_from)) {
365:             continue;
366:         }
367:         // If 'item_name' is missing, automatic match.  Otherwise
368:         // check if that argument exists...
369:         if (empty($category['item_name'])) {
370:             $category['item_name'] = '';
371:             $category['item_id']   = 0;
372:             $sub_categories[]      = $category;
373:         } else {
374:             $item_name = $category['item_name'];
375:             $id        = ($item_name != '' && isset($_GET[$item_name])) ? (int)$_GET[$item_name] : 0;
376:             if ($id > 0) {
377:                 $category['item_id'] = $id;
378:                 $sub_categories[]    = $category;
379:             }
380:         }
381:     }
382:     }
383:     return $sub_categories;
384: }
385: 
386: /**
387:  * Generate module config info for a particular category, event pair.
388:  * The selectable config options are given names depending on the
389:  * category and event names, and the text depends on the category
390:  * and event titles.  These are pieced together in this function in
391:  * case we wish to alter the syntax.
392:  *
393:  * @param  array  $category Array of category info
394:  * @param  array  $event    Array of event info
395:  * @param  string $type     The particular name to generate
396:  *                          return string
397:  *                          *
398:  *
399:  * @return bool|string
400:  */
401: function notificationGenerateConfig(&$category, &$event, $type)
402: {
403:     switch ($type) {
404:         case 'option_value':
405:         case 'name':
406:             return 'notify:' . $category['name'] . '-' . $event['name'];
407:             break;
408:         case 'option_name':
409:             return $category['name'] . '-' . $event['name'];
410:             break;
411:         default:
412:             return false;
413:             break;
414:     }
415: }
416: