<?php

// $Id: node.module,v 1.947.2.15 2009/02/16 14:39:40 goba Exp $

/**

 * @file

 * The core that allows content to be submitted to the site. Modules and scripts may

 * programmatically submit nodes using the usual form API pattern.

 */

define('NODE_NEW_LIMIT', time() - 30 * 24 * 60 * 60);

define('NODE_BUILD_NORMAL', 0);

define('NODE_BUILD_PREVIEW', 1);

define('NODE_BUILD_SEARCH_INDEX', 2);

define('NODE_BUILD_SEARCH_RESULT', 3);

define('NODE_BUILD_RSS', 4);

define('NODE_BUILD_PRINT', 5);

/**

 * Implementation of hook_help().

 */

function node_help($path, $arg) {

  // Remind site administrators about the {node_access} table being flagged

  // for rebuild. We don't need to issue the message on the confirm form, or

  // while the rebuild is being processed.

  if ($path != 'admin/content/node-settings/rebuild' && $path != 'batch' && strpos($path, '#') === FALSE

      && user_access('access administration pages') && node_access_needs_rebuild()) {

    if ($path == 'admin/content/node-settings') {

      $message = t('The content access permissions need to be rebuilt.');

    }

    else {

      $message = t('The content access permissions need to be rebuilt. Please visit <a href="@node_access_rebuild">this page</a>.', array('@node_access_rebuild' => url('admin/content/node-settings/rebuild')));

    }

    drupal_set_message($message, 'error');

  }

  switch ($path) {

    case 'admin/help#node':

      $output = '<p>'. t('The node module manages content on your site, and stores all posts (regardless of type) as a "node". In addition to basic publishing settings, including whether the post has been published, promoted to the site front page, or should remain present (or sticky) at the top of lists, the node module also records basic information about the author of a post. Optional revision control over edits is available. For additional functionality, the node module is often extended by other modules.') .'</p>';

      $output .= '<p>'. t('Though each post on your site is a node, each post is also of a particular <a href="@content-type">content type</a>. <a href="@content-type">Content types</a> are used to define the characteristics of a post, including the title and description of the fields displayed on its add and edit pages. Each content type may have different default settings for <em>Publishing options</em> and other workflow controls. By default, the two content types in a standard Drupal installation are <em>Page</em> and <em>Story</em>. Use the <a href="@content-type">content types page</a> to add new or edit existing content types. Additional content types also become available as you enable additional core, contributed and custom modules.', array('@content-type' => url('admin/content/types'))) .'</p>';

      $output .= '<p>'. t('The administrative <a href="@content">content page</a> allows you to review and manage your site content. The <a href="@post-settings">post settings page</a> sets certain options for the display of posts. The node module makes a number of permissions available for each content type, which may be set by role on the <a href="@permissions">permissions page</a>.', array('@content' => url('admin/content/node'), '@post-settings' => url('admin/content/node-settings'), '@permissions' => url('admin/user/permissions'))) .'</p>';

      $output .= '<p>'. t('For more information, see the online handbook entry for <a href="@node">Node module</a>.', array('@node' => 'http://drupal.org/handbook/modules/node/')) .'</p>';

      return $output;

    case 'admin/content/node':

      return ' '; // Return a non-null value so that the 'more help' link is shown.

    case 'admin/content/types':

      return '<p>'. t('Below is a list of all the content types on your site. All posts that exist on your site are instances of one of these content types.') .'</p>';

    case 'admin/content/types/add':

      return '<p>'. t('To create a new content type, enter the human-readable name, the machine-readable name, and all other relevant fields that are on this page. Once created, users of your site will be able to create posts that are instances of this content type.') .'</p>';

    case 'node/%/revisions':

      return '<p>'. t('The revisions let you track differences between multiple versions of a post.') .'</p>';

    case 'node/%/edit':

      $node = node_load($arg[1]);

      $type = node_get_types('type', $node->type);

      return (!empty($type->help) ? '<p>'. filter_xss_admin($type->help) .'</p>' : '');

  }

  if ($arg[0] == 'node' && $arg[1] == 'add' && $arg[2]) {

    $type = node_get_types('type', str_replace('-', '_', $arg[2]));

    return (!empty($type->help) ? '<p>'. filter_xss_admin($type->help) .'</p>' : '');

  }

}

/**

 * Implementation of hook_theme()

 */

function node_theme() {

  return array(

    'node' => array(

      'arguments' => array('node' => NULL, 'teaser' => FALSE, 'page' => FALSE),

      'template' => 'node',

    ),

    'node_list' => array(

      'arguments' => array('items' => NULL, 'title' => NULL),

    ),

    'node_search_admin' => array(

      'arguments' => array('form' => NULL),

    ),

    'node_filter_form' => array(

      'arguments' => array('form' => NULL),

      'file' => 'node.admin.inc',

    ),

    'node_filters' => array(

      'arguments' => array('form' => NULL),

      'file' => 'node.admin.inc',

    ),

    'node_admin_nodes' => array(

      'arguments' => array('form' => NULL),

      'file' => 'node.admin.inc',

    ),

    'node_add_list' => array(

      'arguments' => array('content' => NULL),

      'file' => 'node.pages.inc',

    ),

    'node_form' => array(

      'arguments' => array('form' => NULL),

      'file' => 'node.pages.inc',

    ),

    'node_preview' => array(

      'arguments' => array('node' => NULL),

      'file' => 'node.pages.inc',

    ),

    'node_log_message' => array(

      'arguments' => array('log' => NULL),

    ),

    'node_submitted' => array(

      'arguments' => array('node' => NULL),

    ),

  );

}

/**

 * Implementation of hook_cron().

 */

function node_cron() {

  db_query('DELETE FROM {history} WHERE timestamp < %d', NODE_NEW_LIMIT);

}

/**

 * Gather a listing of links to nodes.

 *

 * @param $result

 *   A DB result object from a query to fetch node objects. If your query

 *   joins the <code>node_comment_statistics</code> table so that the

 *   <code>comment_count</code> field is available, a title attribute will

 *   be added to show the number of comments.

 * @param $title

 *   A heading for the resulting list.

 *

 * @return

 *   An HTML list suitable as content for a block, or FALSE if no result can

 *   fetch from DB result object.

 */

function node_title_list($result, $title = NULL) {

  $items = array();

  $num_rows = FALSE;

  while ($node = db_fetch_object($result)) {

    $items[] = l($node->title, 'node/'. $node->nid, !empty($node->comment_count) ? array('attributes' => array('title' => format_plural($node->comment_count, '1 comment', '@count comments'))) : array());

    $num_rows = TRUE;

  }

  return $num_rows ? theme('node_list', $items, $title) : FALSE;

}

/**

 * Format a listing of links to nodes.

 *

 * @ingroup themeable

 */

function theme_node_list($items, $title = NULL) {

  return theme('item_list', $items, $title);

}

/**

 * Update the 'last viewed' timestamp of the specified node for current user.

 */

function node_tag_new($nid) {

  global $user;

  if ($user->uid) {

    if (node_last_viewed($nid)) {

      db_query('UPDATE {history} SET timestamp = %d WHERE uid = %d AND nid = %d', time(), $user->uid, $nid);

    }

    else {

      @db_query('INSERT INTO {history} (uid, nid, timestamp) VALUES (%d, %d, %d)', $user->uid, $nid, time());

    }

  }

}

/**

 * Retrieves the timestamp at which the current user last viewed the

 * specified node.

 */

function node_last_viewed($nid) {

  global $user;

  static $history;

  if (!isset($history[$nid])) {

    $history[$nid] = db_fetch_object(db_query("SELECT timestamp FROM {history} WHERE uid = %d AND nid = %d", $user->uid, $nid));

  }

  return (isset($history[$nid]->timestamp) ? $history[$nid]->timestamp : 0);

}

/**

 * Decide on the type of marker to be displayed for a given node.

 *

 * @param $nid

 *   Node ID whose history supplies the "last viewed" timestamp.

 * @param $timestamp

 *   Time which is compared against node's "last viewed" timestamp.

 * @return

 *   One of the MARK constants.

 */

function node_mark($nid, $timestamp) {

  global $user;

  static $cache;

  if (!$user->uid) {

    return MARK_READ;

  }

  if (!isset($cache[$nid])) {

    $cache[$nid] = node_last_viewed($nid);

  }

  if ($cache[$nid] == 0 && $timestamp > NODE_NEW_LIMIT) {

    return MARK_NEW;

  }

  elseif ($timestamp > $cache[$nid] && $timestamp > NODE_NEW_LIMIT) {

    return MARK_UPDATED;

  }

  return MARK_READ;

}

/**

 * See if the user used JS to submit a teaser.

 */

function node_teaser_js(&$form, &$form_state) {

  if (isset($form['#post']['teaser_js'])) {

    // Glue the teaser to the body.

    if (trim($form_state['values']['teaser_js'])) {

      // Space the teaser from the body

      $body = trim($form_state['values']['teaser_js']) ."\r\n<!--break-->\r\n". trim($form_state['values']['body']);

    }

    else {

      // Empty teaser, no spaces.

      $body = '<!--break-->'. $form_state['values']['body'];

    }

    // Pass updated body value on to preview/submit form processing.

    form_set_value($form['body'], $body, $form_state);

    // Pass updated body value back onto form for those cases

    // in which the form is redisplayed.

    $form['body']['#value'] = $body;

  }

  return $form;

}

/**

 * Ensure value of "teaser_include" checkbox is consistent with other form data.

 *

 * This handles two situations in which an unchecked checkbox is rejected:

 *

 *   1. The user defines a teaser (summary) but it is empty;

 *   2. The user does not define a teaser (summary) (in this case an

 *      unchecked checkbox would cause the body to be empty, or missing

 *      the auto-generated teaser).

 *

 * If JavaScript is active then it is used to force the checkbox to be

 * checked when hidden, and so the second case will not arise.

 *

 * In either case a warning message is output.

 */

function node_teaser_include_verify(&$form, &$form_state) {

  $message = '';

  // $form['#post'] is set only when the form is built for preview/submit.

  if (isset($form['#post']['body']) && isset($form_state['values']['teaser_include']) && !$form_state['values']['teaser_include']) {

    // "teaser_include" checkbox is present and unchecked.

    if (strpos($form_state['values']['body'], '<!--break-->') === 0) {

      // Teaser is empty string.

      $message = t('You specified that the summary should not be shown when this post is displayed in full view. This setting is ignored when the summary is empty.');

    }

    elseif (strpos($form_state['values']['body'], '<!--break-->') === FALSE) {

      // Teaser delimiter is not present in the body.

      $message = t('You specified that the summary should not be shown when this post is displayed in full view. This setting has been ignored since you have not defined a summary for the post. (To define a summary, insert the delimiter "<!--break-->" (without the quotes) in the Body of the post to indicate the end of the summary and the start of the main content.)');

    }

    if (!empty($message)) {

      drupal_set_message($message, 'warning');

      // Pass new checkbox value on to preview/submit form processing.

      form_set_value($form['teaser_include'], 1, $form_state);

      // Pass new checkbox value back onto form for those cases

      // in which form is redisplayed.

      $form['teaser_include']['#value'] = 1;

    }

  }

  return $form;

}

/**

 * Generate a teaser for a node body.

 *

 * If the end of the teaser is not indicated using the <!--break--> delimiter

 * then we generate the teaser automatically, trying to end it at a sensible

 * place such as the end of a paragraph, a line break, or the end of a

 * sentence (in that order of preference).

 *

 * @param $body

 *   The content for which a teaser will be generated.

 * @param $format

 *   The format of the content. If the content contains PHP code, we do not

 *   split it up to prevent parse errors. If the line break filter is present

 *   then we treat newlines embedded in $body as line breaks.

 * @param $size

 *   The desired character length of the teaser. If omitted, the default

 *   value will be used. Ignored if the special delimiter is present

 *   in $body.

 * @return

 *   The generated teaser.

 */

function node_teaser($body, $format = NULL, $size = NULL) {

  if (!isset($size)) {

    $size = variable_get('teaser_length', 600);

  }

  // Find where the delimiter is in the body

  $delimiter = strpos($body, '<!--break-->');

  // If the size is zero, and there is no delimiter, the entire body is the teaser.

  if ($size == 0 && $delimiter === FALSE) {

    return $body;

  }

  // If a valid delimiter has been specified, use it to chop off the teaser.

  if ($delimiter !== FALSE) {

    return substr($body, 0, $delimiter);

  }

  // We check for the presence of the PHP evaluator filter in the current

  // format. If the body contains PHP code, we do not split it up to prevent

  // parse errors.

  if (isset($format)) {

    $filters = filter_list_format($format);

    if (isset($filters['php/0']) && strpos($body, '<?') !== FALSE) {

      return $body;

    }

  }

  // If we have a short body, the entire body is the teaser.

  if (drupal_strlen($body) <= $size) {

    return $body;

  }

  // If the delimiter has not been specified, try to split at paragraph or

  // sentence boundaries.

  // The teaser may not be longer than maximum length specified. Initial slice.

  $teaser = truncate_utf8($body, $size);

  // Store the actual length of the UTF8 string -- which might not be the same

  // as $size.

  $max_rpos = strlen($teaser);

  // How much to cut off the end of the teaser so that it doesn't end in the

  // middle of a paragraph, sentence, or word.

  // Initialize it to maximum in order to find the minimum.

  $min_rpos = $max_rpos;

  // Store the reverse of the teaser.  We use strpos on the reversed needle and

  // haystack for speed and convenience.

  $reversed = strrev($teaser);

  // Build an array of arrays of break points grouped by preference.

  $break_points = array();

  // A paragraph near the end of sliced teaser is most preferable.

  $break_points[] = array('</p>' => 0);

  // If no complete paragraph then treat line breaks as paragraphs.

  $line_breaks = array('<br />' => 6, '<br>' => 4);

  // Newline only indicates a line break if line break converter

  // filter is present.

  if (isset($filters['filter/1'])) {

    $line_breaks["\n"] = 1;

  }

  $break_points[] = $line_breaks;

  // If the first paragraph is too long, split at the end of a sentence.

  $break_points[] = array('. ' => 1, '! ' => 1, '? ' => 1, '。' => 0, '؟ ' => 1);

  // Iterate over the groups of break points until a break point is found.

  foreach ($break_points as $points) {

    // Look for each break point, starting at the end of the teaser.

    foreach ($points as $point => $offset) {

      // The teaser is already reversed, but the break point isn't.

      $rpos = strpos($reversed, strrev($point));

      if ($rpos !== FALSE) {

        $min_rpos = min($rpos + $offset, $min_rpos);

      }

    }

    // If a break point was found in this group, slice and return the teaser.

    if ($min_rpos !== $max_rpos) {

      // Don't slice with length 0.  Length must be <0 to slice from RHS.

      return ($min_rpos === 0) ? $teaser : substr($teaser, 0, 0 - $min_rpos);

    }

  }

  // If a break point was not found, still return a teaser.

  return $teaser;

}

/**

 * Builds a list of available node types, and returns all of part of this list

 * in the specified format.

 *

 * @param $op

 *   The format in which to return the list. When this is set to 'type',

 *   'module', or 'name', only the specified node type is returned. When set to

 *   'types' or 'names', all node types are returned.

 * @param $node

 *   A node object, array, or string that indicates the node type to return.

 *   Leave at default value (NULL) to return a list of all node types.

 * @param $reset

 *   Whether or not to reset this function's internal cache (defaults to

 *   FALSE).

 *

 * @return

 *   Either an array of all available node types, or a single node type, in a

 *   variable format. Returns FALSE if the node type is not found.

 */

function node_get_types($op = 'types', $node = NULL, $reset = FALSE) {

  static $_node_types, $_node_names;

  if ($reset || !isset($_node_types)) {

    list($_node_types, $_node_names) = _node_types_build();

  }

  if ($node) {

    if (is_array($node)) {

      $type = $node['type'];

    }

    elseif (is_object($node)) {

      $type = $node->type;

    }

    elseif (is_string($node)) {

      $type = $node;

    }

    if (!isset($_node_types[$type])) {

      return FALSE;

    }

  }

  switch ($op) {

    case 'types':

      return $_node_types;

    case 'type':

      return isset($_node_types[$type]) ? $_node_types[$type] : FALSE;

    case 'module':

      return isset($_node_types[$type]->module) ? $_node_types[$type]->module : FALSE;

    case 'names':

      return $_node_names;

    case 'name':

      return isset($_node_names[$type]) ? $_node_names[$type] : FALSE;

  }

}

/**

 * Resets the database cache of node types, and saves all new or non-modified

 * module-defined node types to the database.

 */

function node_types_rebuild() {

  _node_types_build();

  $node_types = node_get_types('types', NULL, TRUE);

  foreach ($node_types as $type => $info) {

    if (!empty($info->is_new)) {

      node_type_save($info);

    }

    if (!empty($info->disabled)) {

      node_type_delete($info->type);

    }

  }

  _node_types_build();

}

/**

 * Saves a node type to the database.

 *

 * @param $info

 *   The node type to save, as an object.

 *

 * @return

 *   Status flag indicating outcome of the operation.

 */

function node_type_save($info) {

  $is_existing = FALSE;

  $existing_type = !empty($info->old_type) ? $info->old_type : $info->type;

  $is_existing = db_result(db_query("SELECT COUNT(*) FROM {node_type} WHERE type = '%s'", $existing_type));

  if (!isset($info->help)) {

    $info->help = '';

  }

  if (!isset($info->min_word_count)) {

    $info->min_word_count = 0;

  }

  if (!isset($info->body_label)) {

    $info->body_label = '';

  }

  if ($is_existing) {

    db_query("UPDATE {node_type} SET type = '%s', name = '%s', module = '%s', has_title = %d, title_label = '%s', has_body = %d, body_label = '%s', description = '%s', help = '%s', min_word_count = %d, custom = %d, modified = %d, locked = %d WHERE type = '%s'", $info->type, $info->name, $info->module, $info->has_title, $info->title_label, $info->has_body, $info->body_label, $info->description, $info->help, $info->min_word_count, $info->custom, $info->modified, $info->locked, $existing_type);

    module_invoke_all('node_type', 'update', $info);

    return SAVED_UPDATED;

  }

  else {

    db_query("INSERT INTO {node_type} (type, name, module, has_title, title_label, has_body, body_label, description, help, min_word_count, custom, modified, locked, orig_type) VALUES ('%s', '%s', '%s', %d, '%s', %d, '%s', '%s', '%s', %d, %d, %d, %d, '%s')", $info->type, $info->name, $info->module, $info->has_title, $info->title_label, $info->has_body, $info->body_label, $info->description, $info->help, $info->min_word_count, $info->custom, $info->modified, $info->locked, $info->orig_type);

    module_invoke_all('node_type', 'insert', $info);

    return SAVED_NEW;

  }

}

/**

 * Deletes a node type from the database.

 *

 * @param $type

 *   The machine-readable name of the node type to be deleted.

 */

function node_type_delete($type) {

  $info = node_get_types('type', $type);

  db_query("DELETE FROM {node_type} WHERE type = '%s'", $type);

  module_invoke_all('node_type', 'delete', $info);

}

/**

 * Updates all nodes of one type to be of another type.

 *

 * @param $old_type

 *   The current node type of the nodes.

 * @param $type

 *   The new node type of the nodes.

 *

 * @return

 *   The number of nodes whose node type field was modified.

 */

function node_type_update_nodes($old_type, $type) {