You are here

function notifications_content_notifications in Notifications 6.2

Same name and namespace in other branches
  1. 5 notifications_content/notifications_content.module \notifications_content_notifications()
  2. 6.4 notifications_content/notifications_content.module \notifications_content_notifications()
  3. 6 notifications_content/notifications_content.module \notifications_content_notifications()
  4. 6.3 notifications_content/notifications_content.module \notifications_content_notifications()
  5. 7 notifications_content/notifications_content.module \notifications_content_notifications()

Implementation of hook_notifications()

File

notifications_content/notifications_content.module, line 193
Subscriptions to content events

Code

function notifications_content_notifications($op, &$arg0, $arg1 = NULL, $arg2 = NULL) {
  switch ($op) {
    case 'names':
      $subs =& $arg0;
      if ($subs->event_type == 'node') {
        $subs->type_name = t('Content');
        if (!empty($subs->fields['type'])) {
          $subs->names['type'] = t('Content type: @type', array(
            '@type' => notifications_translate('type:' . $subs->fields['type'] . ':name', node_get_types('name', $subs->fields['type']), NULL, 'nodetype'),
          ));
        }
        if (!empty($subs->fields['author']) && ($author = user_load(array(
          'uid' => $subs->fields['author'],
        )))) {
          $subs->names['author'] = t('Author: @name', array(
            '@name' => $author->name,
          ));
        }
        if (!empty($subs->fields['nid']) && ($node = node_load($subs->fields['nid']))) {
          $subs->names['thread'] = t('Thread: @title', array(
            '@title' => $node->title,
          ));
        }
      }
      break;
    case 'subscription types':

      // Some types may be globally disabled (for all content types), mark as such
      $disabled = !variable_get('notifications_content_per_type', 0);
      $types['thread'] = array(
        'event_type' => 'node',
        'title' => t('Thread'),
        'access' => 'subscribe to content',
        'page callback' => 'notifications_content_page_thread',
        'user page' => 'user/%user/notifications/thread',
        'fields' => array(
          'nid',
        ),
        'description' => t('Subscribe to all changes and comments for a thread.'),
        'disabled' => $disabled && !notifications_content_type_enabled(NULL, 'thread'),
      );
      $types['nodetype'] = array(
        'event_type' => 'node',
        'title' => t('Content type'),
        'access' => 'subscribe to content type',
        'page callback' => 'notifications_content_page_nodetype',
        'user page' => 'user/%user/notifications/nodetype',
        'fields' => array(
          'type',
        ),
        'description' => t('Subscribe to all content of a given type.'),
        'disabled' => $disabled && !notifications_content_type_enabled(NULL, 'nodetype'),
      );
      $types['author'] = array(
        'event_type' => 'node',
        'title' => t('Author'),
        'access' => 'subscribe to author',
        'page callback' => 'notifications_content_page_author',
        'user page' => 'user/%user/notifications/author',
        'fields' => array(
          'author',
        ),
        'description' => t('Subscribe to all content submitted by a user.'),
        'disabled' => $disabled && !notifications_content_type_enabled(NULL, 'author'),
      );

      // This is a complex type, combining two fields
      $types['typeauthor'] = array(
        'event_type' => 'node',
        'title' => t('Content type and Author'),
        'access' => 'subscribe to content type and author',
        //'page callback' => 'notifications_content_page_author',
        'fields' => array(
          'author',
          'type',
        ),
        'description' => t('Subscribe to all content of a given type submitted by a user.'),
        'disabled' => $disabled && !notifications_content_type_enabled(NULL, 'typeauthor'),
      );
      return $types;
    case 'subscription fields':

      // Information about available fields for subscriptions
      // - format callback => will be used to convert the value into a displayable output
      // - value callback => will be used to convert autocomplete name into field value
      // - autocomplete path => path for autocomplete field
      // - options callback / arguments => used to produce a drop down field
      $fields['nid'] = array(
        'name' => t('Node'),
        'field' => 'nid',
        'type' => 'int',
        'autocomplete path' => 'notifications/autocomplete/node/title',
        'autocomplete callback' => 'notifications_node_nid2autocomplete',
        'format callback' => 'notifications_node_nid2title',
        'value callback' => 'notifications_node_title2nid',
      );
      $fields['author'] = array(
        'name' => t('Author'),
        'field' => 'author',
        'type' => 'int',
        'autocomplete path' => 'user/autocomplete',
        'autocomplete callback' => 'notifications_content_author_name_callback',
        'format callback' => 'notifications_content_author_name',
        'value callback' => 'notifications_content_author_uid',
      );
      $fields['type'] = array(
        'name' => t('Node type'),
        'field' => 'type',
        'type' => 'string',
        'options callback' => 'notifications_content_types_callback',
      );
      return $fields;
    case 'query':

      // $arg2 is $event array.
      if ($arg0 == 'event' && $arg1 == 'node' && ($node = $arg2->node) || $arg0 == 'user' && $arg1 == 'node' && ($node = $arg2)) {
        $query[]['fields'] = array(
          'nid' => $node->nid,
          'type' => $node->type,
          'author' => $node->uid,
        );
        return $query;
      }
      break;
    case 'node options':

      // Subscription options for a node, args will be account and node
      return _notifications_content_node_options($arg0, $arg1);
    case 'user options':

      // Subscription options for a user account, args will be account and author
      return _notifications_content_user_options($arg0, $arg1);
    case 'event load':

      // $arg0 is event
      $event =& $arg0;
      $load = array();
      if ($event->type == 'node') {
        if (!empty($event->params['nid']) && empty($event->objects['node'])) {
          if ($node = node_load($event->params['nid'])) {
            $event->objects['node'] = $node;
          }
          else {

            // Node not available anymore, mark event for deletion
            $event->delete = TRUE;
          }
        }
        if (!empty($event->params['cid']) && empty($event->objects['comment'])) {
          if ($comment = notifications_content_comment_load($event->params['cid'])) {
            $event->objects['comment'] = $comment;
          }
          else {

            // Comment not available anymore, mark event for deletion
            $event->delete = TRUE;
          }
        }
      }
      break;
    case 'event objects':
      return array(
        'node' => t('Node'),
      );
    case 'event types':

      // Node inserts are not grouped by node but all together. The digest will look like:
      //   New content has been submitted
      //   - Story Title1 by Author1
      //   - Event Title2 by Author2
      $types[] = array(
        'type' => 'node',
        'action' => 'insert',
        'name' => t('New content of type [type-name] has been submitted'),
        'line' => t('[type-name] [title] by [author-name]'),
        'digest' => array(
          'node',
          'type',
        ),
        'description' => t('Node creation'),
      );

      // These other events are grouped for each node. The digest will look like:
      //   Story: Title of the story
      //   - The story has been updated
      //   - New comment by User: Comment title
      $types[] = array(
        'type' => 'node',
        'action' => 'update',
        'name' => t('[type-name]: [title]'),
        'line' => t('The [type-name] has been updated'),
        'digest' => array(
          'node',
          'nid',
        ),
        'description' => t('Node update'),
      );
      $types[] = array(
        'type' => 'node',
        'action' => 'comment',
        'name' => t('[type-name]: [title]'),
        'line' => t('New comment by [comment-author-name]: [comment-title]'),
        'digest' => array(
          'node',
          'nid',
        ),
        'description' => t('Node comment'),
      );
      return $types;
    case 'access':

      // Return an array with some TRUE value if the user has access to this event objects or subscription type
      $type = $arg0;
      $account =& $arg1;
      $object =& $arg2;
      $access = TRUE;

      // For events we check that node and comment are allowed
      if ($type == 'event' && $object->type == 'node') {
        if (!empty($object->objects['node'])) {
          $access = notifications_content_node_allow($account, $object->objects['node']);
        }

        // If no access to node, we don't check more
        if ($access && !empty($object->objects['comment'])) {
          $access = $access && notifications_content_comment_allow($account, $object->objects['comment']);
        }

        // For node subscriptions we check that user can view the node
      }
      elseif ($type == 'subscription') {
        $access = TRUE;
        if (!empty($object->fields['nid'])) {
          if ($node = node_load($object->fields['nid'])) {
            $access = notifications_content_node_allow($account, $node) && notifications_content_type_enabled($node->type, $object->type);
          }
          else {
            $access = FALSE;
          }
        }
        if (!empty($object->fields['type'])) {
          $access = $access && notifications_content_type_enabled($object->fields['type'], $object->type);
        }
      }

      // We return an array that will be merged with the ones from other modules
      return array(
        $access,
      );
      break;
  }
}