notification.php

讲的是网络编程

	function isSubscribed ($category, $item_id, $event, $module_id, $user_id)
	{
		$criteria = new CriteriaCompo();
		$criteria->add(new Criteria('not_modid', intval($module_id)));
		$criteria->add(new Criteria('not_category', $category));
		$criteria->add(new Criteria('not_itemid', intval($item_id)));
		$criteria->add(new Criteria('not_event', $event));
		$criteria->add(new Criteria('not_uid', intval($user_id)));
		return $this->getCount($criteria);

	}


	// TODO: how about a function to subscribe a whole group of users???
	// e.g. if we want to add all moderators to be notified of subscription
	// of new threads...

    /**
     * Subscribe for notification for an event(s)
     *
     * @param  string $category    category of notification
     * @param  int    $item_id     ID of the item
     * @param  mixed  $events      event string or array of events
     * @param  int    $mode        force a particular notification mode
     *                             (e.g. once_only) (default to current user preference)
     * @param  int    $module_id   ID of the module (default to current module)
     * @param  int    $user_id     ID of the user (default to current user)
     **/
    function subscribe ($category, $item_id, $events, $mode=null, $module_id=null, $user_id=null)
    {
        if (!isset($user_id)) {
            global $xoopsUser;
            if (empty($xoopsUser)) {
                return false;  // anonymous cannot subscribe
            } else {
                $user_id = $xoopsUser->getVar('uid');
            }
        }

        if (!isset($module_id)) {
            global $xoopsModule;
            $module_id = $xoopsModule->getVar('mid');
        }

        if (!isset($mode)) {
            $user = new XoopsUser($user_id);
            $mode = $user->getVar('notify_mode');
        }

        if (!is_array($events)) $events = array($events);
        foreach ($events as $event) {
            if ($notification =& $this->getNotification($module_id, $category, $item_id, $event, $user_id)) {
                if ($notification->getVar('not_mode') != $mode) {
                    $this->updateByField($notification, 'not_mode', $mode);
            	}
            } else {
                $notification =& $this->create();
                $notification->setVar('not_modid', $module_id);
                $notification->setVar('not_category', $category);
                $notification->setVar('not_itemid', $item_id);
                $notification->setVar('not_uid', $user_id);
                $notification->setVar('not_event', $event);
                $notification->setVar('not_mode', $mode);
                $this->insert($notification);
            }
        }
    }


// TODO: this will be to provide a list of everything a particular
// user has subscribed to... e.g. for on the 'Profile' page, similar
// to how we see the various posts etc. that the user has made.
// We may also want to have a function where we can specify module id
    /**
     * Get a list of notifications by user ID
     *
     * @param  int  $user_id  ID of the user
     *
     * @return array  Array of {@link XoopsNotification} objects
     **/
    function getByUser ($user_id)
    {
        $criteria = new Criteria ('not_uid', $user_id);
        return $this->getObjects($criteria, true);
    }

	// TODO: rename this??
    /**
     * Get a list of notification events for the current item/mod/user
     *
     **/
	function getSubscribedEvents ($category, $item_id, $module_id, $user_id)
    {
        $criteria = new CriteriaCompo();
        $criteria->add (new Criteria('not_modid', $module_id));
        $criteria->add (new Criteria('not_category', $category));
        if ($item_id) {
            $criteria->add (new Criteria('not_itemid', $item_id));
        }
        $criteria->add (new Criteria('not_uid', $user_id));
        $results = $this->getObjects($criteria, true);
        $ret = array();
        foreach (array_keys($results) as $i) {
            $ret[] = $results[$i]->getVar('not_event');
        }
        return $ret;
    }

// TODO: is this a useful function?? (Copied from comment_handler)
    /**
     * Retrieve items by their ID
     *
     * @param   int     $module_id  Module ID
     * @param   int     $item_id    Item ID
     * @param   string  $order      Sort order
     *
     * @return  array   Array of {@link XoopsNotification} objects
     **/
    function getByItemId($module_id, $item_id, $order = null, $status = null)
    {
        $criteria = new CriteriaCompo(new Criteria('com_modid', intval($module_id)));
        $criteria->add(new Criteria('com_itemid', intval($item_id)));
        if (isset($status)) {
            $criteria->add(new Criteria('com_status', intval($status)));
        }
        if (isset($order)) {
            $criteria->setOrder($order);
        }
        return $this->getObjects($criteria);
    }


    /**
     * Send notifications to users
     *
     * @param  string $category   notification category
     * @param  int $item_id    ID of the item
     * @param  string  $event  notification event
     * @param  array  $extra_tags array of substitutions for template to be
     *                             merged with the one from function..
	 * @param  array  $user_list  only notify the selected users
     * @param  int $module_id  ID of the module
     * @param  int $omit_user_id    ID of the user to omit from notifications. (default to current user).  set to 0 for all users to receive notification.
     **/
    // TODO:(?) - pass in an event LIST.  This will help to avoid
    // problem of sending people multiple emails for similar events.
    // BUT, then we need an array of mail templates, etc...  Unless
    // mail templates can include logic in the future, then we can
    // tailor the mail so it makes sense for any of the possible
    // (or combination of) events.

    function triggerEvents ($category, $item_id, $events, $extra_tags=array(), $user_list=array(), $module_id=null, $omit_user_id=null)
    {
        if (!is_array($events)) {
            $events = array($events);
        }
        foreach ($events as $event) {
            $this->triggerEvent($category, $item_id, $event, $extra_tags, $user_list, $module_id, $omit_user_id);
        }
    }

    function triggerEvent ($category, $item_id, $event, $extra_tags=array(), $user_list=array(), $module_id=null, $omit_user_id=null)
    {

        if (!isset($module_id)) {
            global $xoopsModule;
            $module =& $xoopsModule;
            $module_id = !empty($xoopsModule) ? $xoopsModule->getVar('mid') : 0;
        } else {
            $module_handler =& xoops_gethandler('module');
            $module =& $module_handler->get($module_id);
        }

		// Check if event is enabled
		$config_handler =& xoops_gethandler('config');
		$mod_config =& $config_handler->getConfigsByCat(0,$module->getVar('mid'));
		if (empty($mod_config['notification_enabled'])) {
			return false;
		}
		$category_info =& notificationCategoryInfo ($category, $module_id);
		$event_info =& notificationEventInfo ($category, $event, $module_id);
		if (!in_array(notificationGenerateConfig($category_info,$event_info,'option_name'),$mod_config['notification_events']) && empty($event_info['invisible'])) {
			return false;
		}

        if (!isset($omit_user_id)) {
            global $xoopsUser;
            if (!empty($xoopsUser)) {
                $omit_user_id = $xoopsUser->getVar('uid');
            } else {
                $omit_user_id = 0;
            }
        }
        $criteria = new CriteriaCompo();
        $criteria->add(new Criteria('not_modid', intval($module_id)));
        $criteria->add(new Criteria('not_category', $category));
        $criteria->add(new Criteria('not_itemid', intval($item_id)));
        $criteria->add(new Criteria('not_event', $event));
        $mode_criteria = new CriteriaCompo();
        $mode_criteria->add (new Criteria('not_mode', XOOPS_NOTIFICATION_MODE_SENDALWAYS), 'OR');
        $mode_criteria->add (new Criteria('not_mode', XOOPS_NOTIFICATION_MODE_SENDONCETHENDELETE), 'OR');
        $mode_criteria->add (new Criteria('not_mode', XOOPS_NOTIFICATION_MODE_SENDONCETHENWAIT), 'OR');
        $criteria->add($mode_criteria);
		if (!empty($user_list)) {
			$user_criteria = new CriteriaCompo();
			foreach ($user_list as $user) {
				$user_criteria->add (new Criteria('not_uid', $user), 'OR');
			}
			$criteria->add($user_criteria);
		}
        $notifications =& $this->getObjects($criteria);
        if (empty($notifications)) {
            return;
        }

        // Add some tag substitutions here

        $not_config = $module->getInfo('notification');
        $tags = array();
        if (!empty($not_config)) {
            if (!empty($not_config['tags_file'])) {
                $tags_file = XOOPS_ROOT_PATH . '/modules/' . $module->getVar('dirname') . '/' . $not_config['tags_file'];
                if (file_exists($tags_file)) {
                    include_once $tags_file;
                    if (!empty($not_config['tags_func'])) {
                        $tags_func = $not_config['tags_func'];
                        if (function_exists($tags_func)) {
                            $tags = $tags_func($category, intval($item_id), $event);
                        }
                    }
                }
            }
			// RMV-NEW
			if (!empty($not_config['lookup_file'])) {
				$lookup_file = XOOPS_ROOT_PATH . '/modules/' . $module->getVar('dirname') . '/' . $not_config['lookup_file'];
				if (file_exists($lookup_file)) {
					include_once $lookup_file;
					if (!empty($not_config['lookup_func'])) {
						$lookup_func = $not_config['lookup_func'];
						if (function_exists($lookup_func)) {
							$item_info = $lookup_func($category, intval($item_id));
						}
					}
				}
			}
        }
		$tags['X_ITEM_NAME'] = !empty($item_info['name']) ? $item_info['name'] : '[' . _NOT_ITEMNAMENOTAVAILABLE . ']';
		$tags['X_ITEM_URL']  = !empty($item_info['url']) ? $item_info['url'] : '[' . _NOT_ITEMURLNOTAVAILABLE . ']';
		$tags['X_ITEM_TYPE'] = !empty($category_info['item_name']) ? $category_info['title'] : '[' . _NOT_ITEMTYPENOTAVAILABLE . ']';
        $tags['X_MODULE'] = $module->getVar('name');
        $tags['X_MODULE_URL'] = XOOPS_URL . '/modules/' . $module->getVar('dirname') . '/';
        $tags['X_NOTIFY_CATEGORY'] = $category;
        $tags['X_NOTIFY_EVENT'] = $event;

        $template_dir = $event_info['mail_template_dir'];
        $template = $event_info['mail_template'] . '.tpl';
        $subject = $event_info['mail_subject'];

		foreach ($notifications as $notification) {
			if (empty($omit_user_id) || $notification->getVar('not_uid') != $omit_user_id) {
				// user-specific tags
				//$tags['X_UNSUBSCRIBE_URL'] = 'TODO';
				// TODO: don't show unsubscribe link if it is 'one-time' ??
				$tags['X_UNSUBSCRIBE_URL'] = XOOPS_URL . '/notifications.php';
        		$tags = array_merge ($tags, $extra_tags);

				$notification->notifyUser($template_dir, $template, $subject, $tags);
			}
		}
	}


    /**
     * Delete all notifications for one user
     *
     * @param   int $user_id  ID of the user
     * @return  bool
     **/
    function unsubscribeByUser ($user_id)
    {
        $criteria = new Criteria('not_uid', intval($user_id));
        return $this->deleteAll($criteria);
    }


// TODO: allow these to use current module, etc...

    /**
     * Unsubscribe notifications for an event(s).
     *
     * @param  string  $category    category of the events
     * @param  int     $item_id     ID of the item
     * @param  mixed   $events      event string or array of events
     * @param  int     $module_id   ID of the module (default current module)
     * @param  int     $user_id     UID of the user (default current user)
     *
     * @return bool
     **/

    function unsubscribe ($category, $item_id, $events, $module_id=null, $user_id=null)
    {
        if (!isset($user_id)) {
            global $xoopsUser;
            if (empty($xoopsUser)) {
                return false;  // anonymous cannot subscribe
            } else {
                $user_id = $xoopsUser->getVar('uid');
            }
        }

        if (!isset($module_id)) {
            global $xoopsModule;
            $module_id = $xoopsModule->getVar('mid');
        }

        $criteria = new CriteriaCompo();
        $criteria->add (new Criteria('not_modid', intval($module_id)));
        $criteria->add (new Criteria('not_category', $category));
        $criteria->add (new Criteria('not_itemid', intval($item_id)));
        $criteria->add (new Criteria('not_uid', intval($user_id)));
        if (!is_array($events)) {
            $events = array($events);
        }
        $event_criteria = new CriteriaCompo();
        foreach ($events as $event) {
            $event_criteria->add (new Criteria('not_event', $event), 'OR');
        }
        $criteria->add($event_criteria);
        return $this->deleteAll($criteria);
    }


    // TODO: When 'update' a module, may need to switch around some
    //  notification classes/IDs...  or delete the ones that no longer
    //  exist.

    /**
     * Delete all notifications for a particular module
     *
     * @param   int $module_id  ID of the module
     * @return  bool
     **/
    function unsubscribeByModule ($module_id)
    {
        $criteria = new Criteria('not_modid', intval($module_id));
        return $this->deleteAll($criteria);
    }


    /**
     * Delete all subscriptions for a particular item.
     *
     * @param  int    $module_id  ID of the module to which item belongs
     * @param  string $category   Notification category of the item
     * @param  int    $item_id    ID of the item
     *
     * @return bool
     **/
    function unsubscribeByItem ($module_id, $category, $item_id)
	{
        $criteria = new CriteriaCompo();
        $criteria->add (new Criteria('not_modid', intval($module_id)));
        $criteria->add (new Criteria('not_category', $category));
        $criteria->add (new Criteria('not_itemid', intval($item_id)));
        return $this->deleteAll($criteria);
    }


    /**
     * Perform notification maintenance activites at login time.
     * In particular, any notifications for the newly logged-in
     * user with mode XOOPS_NOTIFICATION_MODE_WAITFORLOGIN are
     * switched to mode XOOPS_NOTIFICATION_MODE_SENDONCETHENWAIT.
     *
     * @param  int  $user_id  ID of the user being logged in
     **/
    function doLoginMaintenance ($user_id)
    {
        $criteria = new CriteriaCompo();
        $criteria->add (new Criteria('not_uid', intval($user_id)));
        $criteria->add (new Criteria('not_mode', XOOPS_NOTIFICATION_MODE_WAITFORLOGIN));

        $notifications = $this->getObjects($criteria, true);
        foreach ($notifications as $n) {
            $n->setVar('not_mode', XOOPS_NOTIFICATION_MODE_SENDONCETHENWAIT);
            $this->insert($n);
        }
    }


    /**
     * Update
     *
     * @param   object  &$notification  {@link XoopsNotification} object
     * @param   string  $field_name     Name of the field
     * @param   mixed   $field_value    Value to write
     *
     * @return  bool
     **/
    function updateByField(&$notification, $field_name, $field_value)
    {
        $notification->unsetNew();
        $notification->setVar($field_name, $field_value);
        return $this->insert($notification);
    }


}
?>