Rebuild permissions.', array('@node_access_rebuild' => url('admin/reports/status/rebuild'))); } drupal_set_message($message, 'error'); } switch ($path) { case 'admin/help#node': $output = ''; $output .= '
' . t('The Node module manages the creation, editing, deletion, settings, and display of the main site content. Content items managed by the Node module are typically displayed as pages on your site, and include a title, some meta-data (author, creation time, content type, etc.), and optional fields containing text or other data (fields are managed by the Field module). For more information, see the online handbook entry for Node module.', array('@node' => 'http://drupal.org/documentation/modules/node', '@field' => url('admin/help/field'))) . '
'; $output .= '' . t('Individual content types can have different fields, behaviors, and permissions assigned to them.') . '
'; case 'admin/structure/types/manage/%/display': return '' . t('Content items can be displayed using different view modes: Teaser, Full content, Print, RSS, etc. Teaser is a short format that is typically used in lists of multiple content items. Full content is typically used when the content is displayed on its own page.') . '
' . '' . t('Here, you can define which fields are shown and hidden when %type content is displayed in each view mode, and define how the fields are displayed in each view mode.', array('%type' => node_type_get_name($arg[4]))) . '
'; case 'node/%/revisions': return '' . t('Revisions allow you to track differences between multiple versions of your content, and revert back to older versions.') . '
'; case 'node/%/edit': $node = node_load($arg[1]); $type = node_type_get_type($node); return (!empty($type->help) ? '' . filter_xss_admin($type->help) . '
' : ''); } if ($arg[0] == 'node' && $arg[1] == 'add' && $arg[2]) { $type = node_type_get_type(str_replace('-', '_', $arg[2])); return (!empty($type->help) ? '' . filter_xss_admin($type->help) . '
' : ''); } } /** * Implements hook_theme(). */ function node_theme() { return array( 'node' => array( 'render element' => 'elements', 'template' => 'node', ), 'node_search_admin' => array( 'render element' => 'form', ), 'node_add_list' => array( 'variables' => array('content' => NULL), 'file' => 'node.pages.inc', ), 'node_preview' => array( 'variables' => array('node' => NULL), 'file' => 'node.pages.inc', ), 'node_admin_overview' => array( 'variables' => array('name' => NULL, 'type' => NULL), 'file' => 'content_types.inc', ), 'node_recent_block' => array( 'variables' => array('nodes' => NULL), ), 'node_recent_content' => array( 'variables' => array('node' => NULL), ), ); } /** * Implements hook_cron(). */ function node_cron() { db_delete('history') ->condition('timestamp', NODE_NEW_LIMIT, '<') ->execute(); } /** * Implements hook_entity_info(). */ function node_entity_info() { $return = array( 'node' => array( 'label' => t('Node'), 'controller class' => 'NodeController', 'base table' => 'node', 'revision table' => 'node_revision', 'uri callback' => 'node_uri', 'fieldable' => TRUE, 'entity keys' => array( 'id' => 'nid', 'revision' => 'vid', 'bundle' => 'type', 'label' => 'title', 'language' => 'language', ), 'bundle keys' => array( 'bundle' => 'type', ), 'bundles' => array(), 'view modes' => array( 'full' => array( 'label' => t('Full content'), 'custom settings' => FALSE, ), 'teaser' => array( 'label' => t('Teaser'), 'custom settings' => TRUE, ), 'rss' => array( 'label' => t('RSS'), 'custom settings' => FALSE, ), ), ), ); // Search integration is provided by node.module, so search-related view modes // for nodes are defined here and not in search.module. if (module_exists('search')) { $return['node']['view modes'] += array( 'search_index' => array( 'label' => t('Search index'), 'custom settings' => FALSE, ), 'search_result' => array( 'label' => t('Search result highlighting input'), 'custom settings' => FALSE, ), ); } // Bundles must provide a human readable name so we can create help and error // messages, and the path to attach Field admin pages to. foreach (node_type_get_names() as $type => $name) { $return['node']['bundles'][$type] = array( 'label' => $name, 'admin' => array( 'path' => 'admin/structure/types/manage/%node_type', 'real path' => 'admin/structure/types/manage/' . str_replace('_', '-', $type), 'bundle argument' => 4, 'access arguments' => array('administer content types'), ), ); } return $return; } /** * Implements hook_field_display_ENTITY_TYPE_alter(). */ function node_field_display_node_alter(&$display, $context) { // Hide field labels in search index. if ($context['view_mode'] == 'search_index') { $display['label'] = 'hidden'; } } /** * Implements callback_entity_info_uri(). */ function node_uri($node) { return array( 'path' => 'node/' . $node->nid, ); } /** * Implements hook_admin_paths(). */ function node_admin_paths() { if (variable_get('node_admin_theme')) { $paths = array( 'node/*/edit' => TRUE, 'node/*/delete' => TRUE, 'node/*/revisions' => TRUE, 'node/*/revisions/*/revert' => TRUE, 'node/*/revisions/*/delete' => TRUE, 'node/add' => TRUE, 'node/add/*' => TRUE, ); return $paths; } } /** * Gathers a listing of links to nodes. * * @param $result * A database result object from a query to fetch node entities. If your * query joins the {node_comment_statistics} table so that the comment_count * field is available, a title attribute will be added to show the number of * comments. * @param $title * A heading for the resulting list. * * @return * A renderable array containing a list of linked node titles fetched from * $result, or FALSE if there are no rows in $result. */ function node_title_list($result, $title = NULL) { $items = array(); $num_rows = FALSE; foreach ($result as $node) { $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 ? array('#theme' => 'item_list__node', '#items' => $items, '#title' => $title) : FALSE; } /** * Updates the 'last viewed' timestamp of the specified node for current user. * * @param $node * A node object. */ function node_tag_new($node) { global $user; if ($user->uid) { db_merge('history') ->key(array( 'uid' => $user->uid, 'nid' => $node->nid, )) ->fields(array('timestamp' => REQUEST_TIME)) ->execute(); } } /** * Retrieves the timestamp for the current user's last view of a specified node. * * @param $nid * A node ID. * * @return * If a node has been previously viewed by the user, the timestamp in seconds * of when the last view occurred; otherwise, zero. */ function node_last_viewed($nid) { global $user; $history = &drupal_static(__FUNCTION__, array()); if (!isset($history[$nid])) { $history[$nid] = db_query("SELECT timestamp FROM {history} WHERE uid = :uid AND nid = :nid", array(':uid' => $user->uid, ':nid' => $nid))->fetchObject(); } return (isset($history[$nid]->timestamp) ? $history[$nid]->timestamp : 0); } /** * Determines 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; $cache = &drupal_static(__FUNCTION__, array()); 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; } /** * Extracts the type name. * * @param $node * Either a string or object, containing the node type information. * * @return * Node type of the passed-in data. */ function _node_extract_type($node) { return is_object($node) ? $node->type : $node; } /** * Returns a list of all the available node types. * * This list can include types that are queued for addition or deletion. * See _node_types_build() for details. * * @return * An array of node types, as objects, keyed by the type. * * @see node_type_get_type() */ function node_type_get_types() { return _node_types_build()->types; } /** * Returns the node type of the passed node or node type string. * * @param $node * A node object or string that indicates the node type to return. * * @return * A single node type, as an object, or FALSE if the node type is not found. * The node type is an object containing fields from hook_node_info() return * values, as well as the field 'type' (the machine-readable type) and other * fields used internally and defined in _node_types_build(), * hook_node_info(), and node_type_set_defaults(). */ function node_type_get_type($node) { $type = _node_extract_type($node); $types = _node_types_build()->types; return isset($types[$type]) ? $types[$type] : FALSE; } /** * Returns the node type base of the passed node or node type string. * * The base indicates which module implements this node type and is used to * execute node-type-specific hooks. For types defined in the user interface * and managed by node.module, the base is 'node_content'. * * @param $node * A node object or string that indicates the node type to return. * * @return * The node type base or FALSE if the node type is not found. * * @see node_invoke() */ function node_type_get_base($node) { $type = _node_extract_type($node); $types = _node_types_build()->types; return isset($types[$type]) && isset($types[$type]->base) ? $types[$type]->base : FALSE; } /** * Returns a list of available node type names. * * This list can include types that are queued for addition or deletion. * See _node_types_build() for details. * * @return * An array of node type names, keyed by the type. */ function node_type_get_names() { return _node_types_build()->names; } /** * Returns the node type name of the passed node or node type string. * * @param $node * A node object or string that indicates the node type to return. * * @return * The node type name or FALSE if the node type is not found. */ function node_type_get_name($node) { $type = _node_extract_type($node); $types = _node_types_build()->names; return isset($types[$type]) ? $types[$type] : FALSE; } /** * Updates the database cache of node types. * * All new module-defined node types are saved to the database via a call to * node_type_save(), and obsolete ones are deleted via a call to * node_type_delete(). See _node_types_build() for an explanation of the new * and obsolete types. * * @see _node_types_build() */ function node_types_rebuild() { _node_types_build(TRUE); } /** * Menu argument loader: loads a node type by string. * * @param $name * The machine-readable name of a node type to load, where '_' is replaced * with '-'. * * @return * A node type object or FALSE if $name does not exist. */ function node_type_load($name) { return node_type_get_type(strtr($name, array('-' => '_'))); } /** * Saves a node type to the database. * * @param object $info * The node type to save; an object with the following properties: * - type: A string giving the machine name of the node type. * - name: A string giving the human-readable name of the node type. * - base: A string that indicates the base string for hook functions. For * example, 'node_content' is the value used by the UI when creating a new * node type. * - description: A string that describes the node type. * - help: A string giving the help information shown to the user when * creating a node of this type. * - custom: TRUE or FALSE indicating whether this type is defined by a module * (FALSE) or by a user (TRUE) via Add Content Type. * - modified: TRUE or FALSE indicating whether this type has been modified by * an administrator. Currently not used in any way. * - locked: TRUE or FALSE indicating whether the administrator can change the * machine name of this type. * - disabled: TRUE or FALSE indicating whether this type has been disabled. * - has_title: TRUE or FALSE indicating whether this type uses the node title * field. * - title_label: A string containing the label for the title. * - module: A string giving the module defining this type of node. * - orig_type: A string giving the original machine-readable name of this * node type. This may be different from the current type name if the * 'locked' key is FALSE. * * @return int * A status flag indicating the outcome of the operation, either SAVED_NEW or * SAVED_UPDATED. */ function node_type_save($info) { $existing_type = !empty($info->old_type) ? $info->old_type : $info->type; $is_existing = (bool) db_query_range('SELECT 1 FROM {node_type} WHERE type = :type', 0, 1, array(':type' => $existing_type))->fetchField(); $type = node_type_set_defaults($info); $fields = array( 'type' => (string) $type->type, 'name' => (string) $type->name, 'base' => (string) $type->base, 'has_title' => (int) $type->has_title, 'title_label' => (string) $type->title_label, 'description' => (string) $type->description, 'help' => (string) $type->help, 'custom' => (int) $type->custom, 'modified' => (int) $type->modified, 'locked' => (int) $type->locked, 'disabled' => (int) $type->disabled, 'module' => $type->module, ); if ($is_existing) { db_update('node_type') ->fields($fields) ->condition('type', $existing_type) ->execute(); if (!empty($type->old_type) && $type->old_type != $type->type) { field_attach_rename_bundle('node', $type->old_type, $type->type); } module_invoke_all('node_type_update', $type); $status = SAVED_UPDATED; } else { $fields['orig_type'] = (string) $type->orig_type; db_insert('node_type') ->fields($fields) ->execute(); field_attach_create_bundle('node', $type->type); module_invoke_all('node_type_insert', $type); $status = SAVED_NEW; } // Clear the node type cache. node_type_cache_reset(); return $status; } /** * Adds default body field to a node type. * * @param $type * A node type object. * @param $label * The label for the body instance. * * @return * Body field instance. */ function node_add_body_field($type, $label = 'Body') { // Add or remove the body field, as needed. $field = field_info_field('body'); $instance = field_info_instance('node', 'body', $type->type); if (empty($field)) { $field = array( 'field_name' => 'body', 'type' => 'text_with_summary', 'entity_types' => array('node'), ); $field = field_create_field($field); } if (empty($instance)) { $instance = array( 'field_name' => 'body', 'entity_type' => 'node', 'bundle' => $type->type, 'label' => $label, 'widget' => array('type' => 'text_textarea_with_summary'), 'settings' => array('display_summary' => TRUE), 'display' => array( 'default' => array( 'label' => 'hidden', 'type' => 'text_default', ), 'teaser' => array( 'label' => 'hidden', 'type' => 'text_summary_or_trimmed', ), ), ); $instance = field_create_instance($instance); } return $instance; } /** * Implements hook_field_extra_fields(). */ function node_field_extra_fields() { $extra = array(); foreach (node_type_get_types() as $type) { if ($type->has_title) { $extra['node'][$type->type] = array( 'form' => array( 'title' => array( 'label' => $type->title_label, 'description' => t('Node module element'), 'weight' => -5, ), ), ); } } return $extra; } /** * 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_type_get_type($type); db_delete('node_type') ->condition('type', $type) ->execute(); field_attach_delete_bundle('node', $type); module_invoke_all('node_type_delete', $info); // Clear the node type cache. node_type_cache_reset(); } /** * 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) { return db_update('node') ->fields(array('type' => $type)) ->condition('type', $old_type) ->execute(); } /** * Builds and returns the list of available node types. * * The list of types is built by invoking hook_node_info() on all modules and * comparing this information with the node types in the {node_type} table. * These two information sources are not synchronized during module installation * until node_types_rebuild() is called. * * @param $rebuild * TRUE to rebuild node types. Equivalent to calling node_types_rebuild(). * * @return * An object with two properties: * - names: Associative array of the names of node types, keyed by the type. * - types: Associative array of node type objects, keyed by the type. * Both of these arrays will include new types that have been defined by * hook_node_info() implementations but not yet saved in the {node_type} * table. These are indicated in the type object by $type->is_new being set * to the value 1. These arrays will also include obsolete types: types that * were previously defined by modules that have now been disabled, or for * whatever reason are no longer being defined in hook_node_info() * implementations, but are still in the database. These are indicated in the * type object by $type->disabled being set to TRUE. */ function _node_types_build($rebuild = FALSE) { $cid = 'node_types:' . $GLOBALS['language']->language; if (!$rebuild) { $_node_types = &drupal_static(__FUNCTION__); if (isset($_node_types)) { return $_node_types; } if ($cache = cache_get($cid)) { $_node_types = $cache->data; return $_node_types; } } $_node_types = (object) array('types' => array(), 'names' => array()); foreach (module_implements('node_info') as $module) { $info_array = module_invoke($module, 'node_info'); foreach ($info_array as $type => $info) { $info['type'] = $type; $_node_types->types[$type] = node_type_set_defaults($info); $_node_types->types[$type]->module = $module; $_node_types->names[$type] = $info['name']; } } $query = db_select('node_type', 'nt') ->addTag('translatable') ->addTag('node_type_access') ->fields('nt') ->orderBy('nt.type', 'ASC'); if (!$rebuild) { $query->condition('disabled', 0); } foreach ($query->execute() as $type_object) { $type_db = $type_object->type; // Original disabled value. $disabled = $type_object->disabled; // Check for node types from disabled modules and mark their types for removal. // Types defined by the node module in the database (rather than by a separate // module using hook_node_info) have a base value of 'node_content'. The isset() // check prevents errors on old (pre-Drupal 7) databases. if (isset($type_object->base) && $type_object->base != 'node_content' && empty($_node_types->types[$type_db])) { $type_object->disabled = TRUE; } if (isset($_node_types->types[$type_db])) { $type_object->disabled = FALSE; } if (!isset($_node_types->types[$type_db]) || $type_object->modified) { $_node_types->types[$type_db] = $type_object; $_node_types->names[$type_db] = $type_object->name; if ($type_db != $type_object->orig_type) { unset($_node_types->types[$type_object->orig_type]); unset($_node_types->names[$type_object->orig_type]); } } $_node_types->types[$type_db]->disabled = $type_object->disabled; $_node_types->types[$type_db]->disabled_changed = $disabled != $type_object->disabled; } if ($rebuild) { foreach ($_node_types->types as $type => $type_object) { if (!empty($type_object->is_new) || !empty($type_object->disabled_changed)) { node_type_save($type_object); } } } asort($_node_types->names); cache_set($cid, $_node_types); return $_node_types; } /** * Clears the node type cache. */ function node_type_cache_reset() { cache_clear_all('node_types:', 'cache', TRUE); drupal_static_reset('_node_types_build'); } /** * Sets the default values for a node type. * * The defaults are appropriate for a type defined through hook_node_info(), * since 'custom' is TRUE for types defined in the user interface, and FALSE * for types defined by modules. (The 'custom' flag prevents types from being * deleted through the user interface.) Also, the default for 'locked' is TRUE, * which prevents users from changing the machine name of the type. * * @param $info * (optional) An object or array containing values to override the defaults. * See hook_node_info() for details on what the array elements mean. Defaults * to an empty array. * * @return * A node type object, with missing values in $info set to their defaults. */ function node_type_set_defaults($info = array()) { $info = (array) $info; $new_type = $info + array( 'type' => '', 'name' => '', 'base' => '', 'description' => '', 'help' => '', 'custom' => 0, 'modified' => 0, 'locked' => 1, 'disabled' => 0, 'is_new' => 1, 'has_title' => 1, 'title_label' => 'Title', ); $new_type = (object) $new_type; // If the type has no title, set an empty label. if (!$new_type->has_title) { $new_type->title_label = ''; } if (empty($new_type->module)) { $new_type->module = $new_type->base == 'node_content' ? 'node' : ''; } $new_type->orig_type = isset($info['type']) ? $info['type'] : ''; return $new_type; } /** * Implements hook_rdf_mapping(). */ function node_rdf_mapping() { return array( array( 'type' => 'node', 'bundle' => RDF_DEFAULT_BUNDLE, 'mapping' => array( 'rdftype' => array('sioc:Item', 'foaf:Document'), 'title' => array( 'predicates' => array('dc:title'), ), 'created' => array( 'predicates' => array('dc:date', 'dc:created'), 'datatype' => 'xsd:dateTime', 'callback' => 'date_iso8601', ), 'changed' => array( 'predicates' => array('dc:modified'), 'datatype' => 'xsd:dateTime', 'callback' => 'date_iso8601', ), 'body' => array( 'predicates' => array('content:encoded'), ), 'uid' => array( 'predicates' => array('sioc:has_creator'), 'type' => 'rel', ), 'name' => array( 'predicates' => array('foaf:name'), ), 'comment_count' => array( 'predicates' => array('sioc:num_replies'), 'datatype' => 'xsd:integer', ), 'last_activity' => array( 'predicates' => array('sioc:last_activity_date'), 'datatype' => 'xsd:dateTime', 'callback' => 'date_iso8601', ), ), ), ); } /** * Determines whether a node hook exists. * * @param $node * A node object or a string containing the node type. * @param $hook * A string containing the name of the hook. * * @return * TRUE if the $hook exists in the node type of $node. */ function node_hook($node, $hook) { $base = node_type_get_base($node); return module_hook($base, $hook); } /** * Invokes a node hook. * * @param $node * A node object or a string containing the node type. * @param $hook * A string containing the name of the hook. * @param $a2, $a3, $a4 * Arguments to pass on to the hook, after the $node argument. * * @return * The returned value of the invoked hook. */ function node_invoke($node, $hook, $a2 = NULL, $a3 = NULL, $a4 = NULL) { if (node_hook($node, $hook)) { $base = node_type_get_base($node); $function = $base . '_' . $hook; return ($function($node, $a2, $a3, $a4)); } } /** * Loads node entities from the database. * * This function should be used whenever you need to load more than one node * from the database. Nodes are loaded into memory and will not require database * access if loaded again during the same page request. * * @see entity_load() * @see EntityFieldQuery * * @param $nids * An array of node IDs. * @param $conditions * (deprecated) An associative array of conditions on the {node} * table, where the keys are the database fields and the values are the * values those fields must have. Instead, it is preferable to use * EntityFieldQuery to retrieve a list of entity IDs loadable by * this function. * @param $reset * Whether to reset the internal node_load cache. * * @return * An array of node objects indexed by nid. * * @todo Remove $conditions in Drupal 8. */ function node_load_multiple($nids = array(), $conditions = array(), $reset = FALSE) { return entity_load('node', $nids, $conditions, $reset); } /** * Loads a node object from the database. * * @param $nid * The node ID. * @param $vid * The revision ID. * @param $reset * Whether to reset the node_load_multiple cache. * * @return * A fully-populated node object, or FALSE if the node is not found. */ function node_load($nid = NULL, $vid = NULL, $reset = FALSE) { $nids = (isset($nid) ? array($nid) : array()); $conditions = (isset($vid) ? array('vid' => $vid) : array()); $node = node_load_multiple($nids, $conditions, $reset); return $node ? reset($node) : FALSE; } /** * Prepares a node object for editing. * * Fills in a few default values, and then invokes hook_prepare() on the node * type module, and hook_node_prepare() on all modules. * * @param $node * A node object. */ function node_object_prepare($node) { // Set up default values, if required. $node_options = variable_get('node_options_' . $node->type, array('status', 'promote')); // If this is a new node, fill in the default values. if (!isset($node->nid) || isset($node->is_new)) { foreach (array('status', 'promote', 'sticky') as $key) { // Multistep node forms might have filled in something already. if (!isset($node->$key)) { $node->$key = (int) in_array($key, $node_options); } } global $user; $node->uid = $user->uid; $node->created = REQUEST_TIME; } else { $node->date = format_date($node->created, 'custom', 'Y-m-d H:i:s O'); // Remove the log message from the original node object. $node->log = NULL; } // Always use the default revision setting. $node->revision = in_array('revision', $node_options); node_invoke($node, 'prepare'); module_invoke_all('node_prepare', $node); } /** * Implements hook_validate(). * * Performs validation checks on the given node. */ function node_validate($node, $form, &$form_state) { if (isset($node->nid) && (node_last_changed($node->nid) > $node->changed)) { form_set_error('changed', t('The content on this page has either been modified by another user, or you have already submitted modifications using this form. As a result, your changes cannot be saved.')); } // Validate the "authored by" field. if (!empty($node->name) && !($account = user_load_by_name($node->name))) { // The use of empty() is mandatory in the context of usernames // as the empty string denotes the anonymous user. In case we // are dealing with an anonymous user we set the user ID to 0. form_set_error('name', t('The username %name does not exist.', array('%name' => $node->name))); } // Validate the "authored on" field. if (!empty($node->date) && strtotime($node->date) === FALSE) { form_set_error('date', t('You have to specify a valid date.')); } // Invoke hook_validate() for node type specific validation and // hook_node_validate() for miscellaneous validation needed by modules. Can't // use node_invoke() or module_invoke_all(), because $form_state must be // receivable by reference. $function = node_type_get_base($node) . '_validate'; if (function_exists($function)) { $function($node, $form, $form_state); } foreach (module_implements('node_validate') as $module) { $function = $module . '_node_validate'; $function($node, $form, $form_state); } } /** * Prepares node for saving by populating author and creation date. * * @param $node * A node object. * * @return * An updated node object. */ function node_submit($node) { // A user might assign the node author by entering a user name in the node // form, which we then need to translate to a user ID. if (isset($node->name)) { if ($account = user_load_by_name($node->name)) { $node->uid = $account->uid; } else { $node->uid = 0; } } $node->created = !empty($node->date) ? strtotime($node->date) : REQUEST_TIME; $node->validated = TRUE; return $node; } /** * Saves changes to a node or adds a new node. * * @param $node * The $node object to be saved. If $node->nid is * omitted (or $node->is_new is TRUE), a new node will be added. */ function node_save($node) { $transaction = db_transaction(); try { // Load the stored entity, if any. if (!empty($node->nid) && !isset($node->original)) { $node->original = entity_load_unchanged('node', $node->nid); } field_attach_presave('node', $node); global $user; // Determine if we will be inserting a new node. if (!isset($node->is_new)) { $node->is_new = empty($node->nid); } // Set the timestamp fields. if (empty($node->created)) { $node->created = REQUEST_TIME; } // The changed timestamp is always updated for bookkeeping purposes, // for example: revisions, searching, etc. $node->changed = REQUEST_TIME; $node->timestamp = REQUEST_TIME; $update_node = TRUE; // Let modules modify the node before it is saved to the database. module_invoke_all('node_presave', $node); module_invoke_all('entity_presave', $node, 'node'); if ($node->is_new || !empty($node->revision)) { // When inserting either a new node or a new node revision, $node->log // must be set because {node_revision}.log is a text column and therefore // cannot have a default value. However, it might not be set at this // point (for example, if the user submitting a node form does not have // permission to create revisions), so we ensure that it is at least an // empty string in that case. // @todo: Make the {node_revision}.log column nullable so that we can // remove this check. if (!isset($node->log)) { $node->log = ''; } } elseif (!isset($node->log) || $node->log === '') { // If we are updating an existing node without adding a new revision, we // need to make sure $node->log is unset whenever it is empty. As long as // $node->log is unset, drupal_write_record() will not attempt to update // the existing database column when re-saving the revision; therefore, // this code allows us to avoid clobbering an existing log entry with an // empty one. unset($node->log); } // When saving a new node revision, unset any existing $node->vid so as to // ensure that a new revision will actually be created, then store the old // revision ID in a separate property for use by node hook implementations. if (!$node->is_new && !empty($node->revision) && $node->vid) { $node->old_vid = $node->vid; unset($node->vid); } // Save the node and node revision. if ($node->is_new) { // For new nodes, save new records for both the node itself and the node // revision. drupal_write_record('node', $node); _node_save_revision($node, $user->uid); $op = 'insert'; } else { // For existing nodes, update the node record which matches the value of // $node->nid. drupal_write_record('node', $node, 'nid'); // Then, if a new node revision was requested, save a new record for // that; otherwise, update the node revision record which matches the // value of $node->vid. if (!empty($node->revision)) { _node_save_revision($node, $user->uid); } else { _node_save_revision($node, $user->uid, 'vid'); $update_node = FALSE; } $op = 'update'; } if ($update_node) { db_update('node') ->fields(array('vid' => $node->vid)) ->condition('nid', $node->nid) ->execute(); } // Call the node specific callback (if any). This can be // node_invoke($node, 'insert') or // node_invoke($node, 'update'). node_invoke($node, $op); // Save fields. $function = "field_attach_$op"; $function('node', $node); module_invoke_all('node_' . $op, $node); module_invoke_all('entity_' . $op, $node, 'node'); // Update the node access table for this node. node_access_acquire_grants($node); // Clear internal properties. unset($node->is_new); unset($node->original); // Clear the static loading cache. entity_get_controller('node')->resetCache(array($node->nid)); // Ignore slave server temporarily to give time for the // saved node to be propagated to the slave. db_ignore_slave(); } catch (Exception $e) { $transaction->rollback(); watchdog_exception('node', $e); throw $e; } } /** * Helper function to save a revision with the uid of the current user. * * The resulting revision ID is available afterward in $node->vid. * * @param $node * A node object. * @param $uid * The current user's UID. * @param $update * (optional) An array of primary keys' field names to update. */ function _node_save_revision($node, $uid, $update = NULL) { $temp_uid = $node->uid; $node->uid = $uid; if (isset($update)) { drupal_write_record('node_revision', $node, $update); } else { drupal_write_record('node_revision', $node); } // Have node object still show node owner's uid, not revision author's. $node->uid = $temp_uid; } /** * Deletes a node. * * @param $nid * A node ID. */ function node_delete($nid) { node_delete_multiple(array($nid)); } /** * Deletes multiple nodes. * * @param $nids * An array of node IDs. */ function node_delete_multiple($nids) { $transaction = db_transaction(); if (!empty($nids)) { $nodes = node_load_multiple($nids, array()); try { foreach ($nodes as $nid => $node) { // Call the node-specific callback (if any): node_invoke($node, 'delete'); module_invoke_all('node_delete', $node); module_invoke_all('entity_delete', $node, 'node'); field_attach_delete('node', $node); // Remove this node from the search index if needed. // This code is implemented in node module rather than in search module, // because node module is implementing search module's API, not the other // way around. if (module_exists('search')) { search_reindex($nid, 'node'); } } // Delete after calling hooks so that they can query node tables as needed. db_delete('node') ->condition('nid', $nids, 'IN') ->execute(); db_delete('node_revision') ->condition('nid', $nids, 'IN') ->execute(); db_delete('history') ->condition('nid', $nids, 'IN') ->execute(); db_delete('node_access') ->condition('nid', $nids, 'IN') ->execute(); } catch (Exception $e) { $transaction->rollback(); watchdog_exception('node', $e); throw $e; } // Clear the page and block and node_load_multiple caches. entity_get_controller('node')->resetCache(); } } /** * Deletes a node revision. * * @param $revision_id * The revision ID to delete. */ function node_revision_delete($revision_id) { if ($revision = node_load(NULL, $revision_id)) { // Prevent deleting the current revision. $node = node_load($revision->nid); if ($revision_id == $node->vid) { return FALSE; } db_delete('node_revision') ->condition('nid', $revision->nid) ->condition('vid', $revision->vid) ->execute(); module_invoke_all('node_revision_delete', $revision); field_attach_delete_revision('node', $revision); return TRUE; } return FALSE; } /** * Generates an array for rendering the given node. * * @param $node * A node object. * @param $view_mode * View mode, e.g. 'full', 'teaser'... * @param $langcode * (optional) A language code to use for rendering. Defaults to the global * content language of the current request. * * @return * An array as expected by drupal_render(). */ function node_view($node, $view_mode = 'full', $langcode = NULL) { if (!isset($langcode)) { $langcode = $GLOBALS['language_content']->language; } // Populate $node->content with a render() array. node_build_content($node, $view_mode, $langcode); $build = $node->content; // We don't need duplicate rendering info in node->content. unset($node->content); $build += array( '#theme' => 'node', '#node' => $node, '#view_mode' => $view_mode, '#language' => $langcode, ); // Add contextual links for this node, except when the node is already being // displayed on its own page. Modules may alter this behavior (for example, // to restrict contextual links to certain view modes) by implementing // hook_node_view_alter(). if (!empty($node->nid) && !($view_mode == 'full' && node_is_page($node))) { $build['#contextual_links']['node'] = array('node', array($node->nid)); } // Allow modules to modify the structured node. $type = 'node'; drupal_alter(array('node_view', 'entity_view'), $build, $type); return $build; } /** * Builds a structured array representing the node's content. * * The content built for the node (field values, comments, file attachments or * other node components) will vary depending on the $view_mode parameter. * * Drupal core defines the following view modes for nodes, with the following * default use cases: * - full (default): node is being displayed on its own page (node/123) * - teaser: node is being displayed on the default home page listing, on * taxonomy listing pages, or on blog listing pages. * - rss: node displayed in an RSS feed. * If search.module is enabled: * - search_index: node is being indexed for search. * - search_result: node is being displayed as a search result. * If book.module is enabled: * - print: node is being displayed in print-friendly mode. * Contributed modules might define additional view modes, or use existing * view modes in additional contexts. * * @param $node * A node object. * @param $view_mode * View mode, e.g. 'full', 'teaser'... * @param $langcode * (optional) A language code to use for rendering. Defaults to the global * content language of the current request. */ function node_build_content($node, $view_mode = 'full', $langcode = NULL) { if (!isset($langcode)) { $langcode = $GLOBALS['language_content']->language; } // Remove previously built content, if exists. $node->content = array(); // Allow modules to change the view mode. $view_mode = key(entity_view_mode_prepare('node', array($node->nid => $node), $view_mode, $langcode)); // The 'view' hook can be implemented to overwrite the default function // to display nodes. if (node_hook($node, 'view')) { $node = node_invoke($node, 'view', $view_mode, $langcode); } // Build fields content. // In case of a multiple view, node_view_multiple() already ran the // 'prepare_view' step. An internal flag prevents the operation from running // twice. field_attach_prepare_view('node', array($node->nid => $node), $view_mode, $langcode); entity_prepare_view('node', array($node->nid => $node), $langcode); $node->content += field_attach_view('node', $node, $view_mode, $langcode); // Always display a read more link on teasers because we have no way to know // when a teaser view is different than a full view. $links = array(); $node->content['links'] = array( '#theme' => 'links__node', '#pre_render' => array('drupal_pre_render_links'), '#attributes' => array('class' => array('links', 'inline')), ); if ($view_mode == 'teaser') { $node_title_stripped = strip_tags($node->title); $links['node-readmore'] = array( 'title' => t('Read more about @title', array('@title' => $node_title_stripped)), 'href' => 'node/' . $node->nid, 'html' => TRUE, 'attributes' => array('rel' => 'tag', 'title' => $node_title_stripped), ); } $node->content['links']['node'] = array( '#theme' => 'links__node__node', '#links' => $links, '#attributes' => array('class' => array('links', 'inline')), ); // Allow modules to make their own additions to the node. module_invoke_all('node_view', $node, $view_mode, $langcode); module_invoke_all('entity_view', $node, 'node', $view_mode, $langcode); // Make sure the current view mode is stored if no module has already // populated the related key. $node->content += array('#view_mode' => $view_mode); } /** * Generates an array which displays a node detail page. * * @param $node * A node object. * @param $message * A flag which sets a page title relevant to the revision being viewed. * * @return * A $page element suitable for use by drupal_render(). */ function node_show($node, $message = FALSE) { if ($message) { drupal_set_title(t('Revision of %title from %date', array('%title' => $node->title, '%date' => format_date($node->revision_timestamp))), PASS_THROUGH); } // For markup consistency with other pages, use node_view_multiple() rather than node_view(). $nodes = node_view_multiple(array($node->nid => $node), 'full'); // Update the history table, stating that this user viewed this node. node_tag_new($node); return $nodes; } /** * Returns whether the current page is the full page view of the passed-in node. * * @param $node * A node object. * * @return * The ID of the node if this is a full page view, otherwise FALSE. */ function node_is_page($node) { $page_node = menu_get_object(); return (!empty($page_node) ? $page_node->nid == $node->nid : FALSE); } /** * Processes variables for node.tpl.php * * Most themes utilize their own copy of node.tpl.php. The default is located * inside "modules/node/node.tpl.php". Look in there for the full list of * variables. * * The $variables array contains the following arguments: * - $node * - $view_mode * - $page * * @see node.tpl.php */ function template_preprocess_node(&$variables) { $variables['view_mode'] = $variables['elements']['#view_mode']; // Provide a distinct $teaser boolean. $variables['teaser'] = $variables['view_mode'] == 'teaser'; $variables['node'] = $variables['elements']['#node']; $node = $variables['node']; $variables['date'] = format_date($node->created); $variables['name'] = theme('username', array('account' => $node)); $uri = entity_uri('node', $node); $variables['node_url'] = url($uri['path'], $uri['options']); $variables['title'] = check_plain($node->title); $variables['page'] = $variables['view_mode'] == 'full' && node_is_page($node); // Flatten the node object's member fields. $variables = array_merge((array) $node, $variables); // Helpful $content variable for templates. $variables += array('content' => array()); foreach (element_children($variables['elements']) as $key) { $variables['content'][$key] = $variables['elements'][$key]; } // Make the field variables available with the appropriate language. field_attach_preprocess('node', $node, $variables['content'], $variables); // Display post information only on certain node types. if (variable_get('node_submitted_' . $node->type, TRUE)) { $variables['display_submitted'] = TRUE; $variables['submitted'] = t('Submitted by !username on !datetime', array('!username' => $variables['name'], '!datetime' => $variables['date'])); $variables['user_picture'] = theme_get_setting('toggle_node_user_picture') ? theme('user_picture', array('account' => $node)) : ''; } else { $variables['display_submitted'] = FALSE; $variables['submitted'] = ''; $variables['user_picture'] = ''; } // Gather node classes. $variables['classes_array'][] = drupal_html_class('node-' . $node->type); if ($variables['promote']) { $variables['classes_array'][] = 'node-promoted'; } if ($variables['sticky']) { $variables['classes_array'][] = 'node-sticky'; } if (!$variables['status']) { $variables['classes_array'][] = 'node-unpublished'; } if ($variables['teaser']) { $variables['classes_array'][] = 'node-teaser'; } if (isset($variables['preview'])) { $variables['classes_array'][] = 'node-preview'; } // Clean up name so there are no underscores. $variables['theme_hook_suggestions'][] = 'node__' . $node->type; $variables['theme_hook_suggestions'][] = 'node__' . $node->nid; } /** * Implements hook_permission(). */ function node_permission() { $perms = array( 'bypass node access' => array( 'title' => t('Bypass content access control'), 'description' => t('View, edit and delete all content regardless of permission restrictions.'), 'restrict access' => TRUE, ), 'administer content types' => array( 'title' => t('Administer content types'), 'restrict access' => TRUE, ), 'administer nodes' => array( 'title' => t('Administer content'), 'restrict access' => TRUE, ), 'access content overview' => array( 'title' => t('Access the content overview page'), 'description' => user_access('access content overview') ? t('Get an overview of all content.', array('@url' => url('admin/content'))) : t('Get an overview of all content.'), ), 'access content' => array( 'title' => t('View published content'), ), 'view own unpublished content' => array( 'title' => t('View own unpublished content'), ), 'view revisions' => array( 'title' => t('View content revisions'), ), 'revert revisions' => array( 'title' => t('Revert content revisions'), ), 'delete revisions' => array( 'title' => t('Delete content revisions'), ), ); // Generate standard node permissions for all applicable node types. foreach (node_permissions_get_configured_types() as $type) { $perms += node_list_permissions($type); } return $perms; } /** * Gathers the rankings from the the hook_ranking() implementations. * * @param $query * A query object that has been extended with the Search DB Extender. */ function _node_rankings(SelectQueryExtender $query) { if ($ranking = module_invoke_all('ranking')) { $tables = &$query->getTables(); foreach ($ranking as $rank => $values) { if ($node_rank = variable_get('node_rank_' . $rank, 0)) { // If the table defined in the ranking isn't already joined, then add it. if (isset($values['join']) && !isset($tables[$values['join']['alias']])) { $query->addJoin($values['join']['type'], $values['join']['table'], $values['join']['alias'], $values['join']['on']); } $arguments = isset($values['arguments']) ? $values['arguments'] : array(); $query->addScore($values['score'], $arguments, $node_rank); } } } } /** * Implements hook_search_info(). */ function node_search_info() { return array( 'title' => 'Content', 'path' => 'node', ); } /** * Implements hook_search_access(). */ function node_search_access() { return user_access('access content'); } /** * Implements hook_search_reset(). */ function node_search_reset() { db_update('search_dataset') ->fields(array('reindex' => REQUEST_TIME)) ->condition('type', 'node') ->execute(); } /** * Implements hook_search_status(). */ function node_search_status() { $total = db_query('SELECT COUNT(*) FROM {node}')->fetchField(); $remaining = db_query("SELECT COUNT(*) FROM {node} n LEFT JOIN {search_dataset} d ON d.type = 'node' AND d.sid = n.nid WHERE d.sid IS NULL OR d.reindex <> 0")->fetchField(); return array('remaining' => $remaining, 'total' => $total); } /** * Implements hook_search_admin(). */ function node_search_admin() { // Output form for defining rank factor weights. $form['content_ranking'] = array( '#type' => 'fieldset', '#title' => t('Content ranking'), ); $form['content_ranking']['#theme'] = 'node_search_admin'; $form['content_ranking']['info'] = array( '#markup' => '' . t('Influence is a numeric multiplier used in ordering search results. A higher number means the corresponding factor has more influence on search results; zero means the factor is ignored. Changing these numbers does not require the search index to be rebuilt. Changes take effect immediately.') . '
' ); // Note: reversed to reflect that higher number = higher ranking. $options = drupal_map_assoc(range(0, 10)); foreach (module_invoke_all('ranking') as $var => $values) { $form['content_ranking']['factors']['node_rank_' . $var] = array( '#title' => $values['title'], '#type' => 'select', '#options' => $options, '#default_value' => variable_get('node_rank_' . $var, 0), ); } return $form; } /** * Implements hook_search_execute(). */ function node_search_execute($keys = NULL, $conditions = NULL) { // Build matching conditions $query = db_select('search_index', 'i', array('target' => 'slave'))->extend('SearchQuery')->extend('PagerDefault'); $query->join('node', 'n', 'n.nid = i.sid'); $query ->condition('n.status', 1) ->addTag('node_access') ->searchExpression($keys, 'node'); // Insert special keywords. $query->setOption('type', 'n.type'); $query->setOption('language', 'n.language'); if ($query->setOption('term', 'ti.tid')) { $query->join('taxonomy_index', 'ti', 'n.nid = ti.nid'); } // Only continue if the first pass query matches. if (!$query->executeFirstPass()) { return array(); } // Add the ranking expressions. _node_rankings($query); // Load results. $find = $query ->limit(10) ->execute(); $results = array(); foreach ($find as $item) { // Render the node. $node = node_load($item->sid); $build = node_view($node, 'search_result'); unset($build['#theme']); $node->rendered = drupal_render($build); // Fetch comments for snippet. $node->rendered .= ' ' . module_invoke('comment', 'node_update_index', $node); $extra = module_invoke_all('node_search_result', $node); $uri = entity_uri('node', $node); $results[] = array( 'link' => url($uri['path'], array_merge($uri['options'], array('absolute' => TRUE))), 'type' => check_plain(node_type_get_name($node)), 'title' => $node->title, 'user' => theme('username', array('account' => $node)), 'date' => $node->changed, 'node' => $node, 'extra' => $extra, 'score' => $item->calculated_score, 'snippet' => search_excerpt($keys, $node->rendered), 'language' => entity_language('node', $node), ); } return $results; } /** * Implements hook_ranking(). */ function node_ranking() { // Create the ranking array and add the basic ranking options. $ranking = array( 'relevance' => array( 'title' => t('Keyword relevance'), // Average relevance values hover around 0.15 'score' => 'i.relevance', ), 'sticky' => array( 'title' => t('Content is sticky at top of lists'), // The sticky flag is either 0 or 1, which is automatically normalized. 'score' => 'n.sticky', ), 'promote' => array( 'title' => t('Content is promoted to the front page'), // The promote flag is either 0 or 1, which is automatically normalized. 'score' => 'n.promote', ), ); // Add relevance based on creation or changed date. if ($node_cron_last = variable_get('node_cron_last', 0)) { $ranking['recent'] = array( 'title' => t('Recently posted'), // Exponential decay with half-life of 6 months, starting at last indexed node 'score' => 'POW(2.0, (GREATEST(n.created, n.changed) - :node_cron_last) * 6.43e-8)', 'arguments' => array(':node_cron_last' => $node_cron_last), ); } return $ranking; } /** * Implements hook_user_cancel(). */ function node_user_cancel($edit, $account, $method) { switch ($method) { case 'user_cancel_block_unpublish': // Unpublish nodes (current revisions). module_load_include('inc', 'node', 'node.admin'); $nodes = db_select('node', 'n') ->fields('n', array('nid')) ->condition('uid', $account->uid) ->execute() ->fetchCol(); node_mass_update($nodes, array('status' => 0)); break; case 'user_cancel_reassign': // Anonymize nodes (current revisions). module_load_include('inc', 'node', 'node.admin'); $nodes = db_select('node', 'n') ->fields('n', array('nid')) ->condition('uid', $account->uid) ->execute() ->fetchCol(); node_mass_update($nodes, array('uid' => 0)); // Anonymize old revisions. db_update('node_revision') ->fields(array('uid' => 0)) ->condition('uid', $account->uid) ->execute(); // Clean history. db_delete('history') ->condition('uid', $account->uid) ->execute(); break; } } /** * Implements hook_user_delete(). */ function node_user_delete($account) { // Delete nodes (current revisions). // @todo Introduce node_mass_delete() or make node_mass_update() more flexible. $nodes = db_select('node', 'n') ->fields('n', array('nid')) ->condition('uid', $account->uid) ->execute() ->fetchCol(); node_delete_multiple($nodes); // Delete old revisions. $revisions = db_query('SELECT vid FROM {node_revision} WHERE uid = :uid', array(':uid' => $account->uid))->fetchCol(); foreach ($revisions as $revision) { node_revision_delete($revision); } // Clean history. db_delete('history') ->condition('uid', $account->uid) ->execute(); } /** * Returns HTML for the content ranking part of the search settings admin page. * * @param $variables * An associative array containing: * - form: A render element representing the form. * * @see node_search_admin() * @ingroup themeable */ function theme_node_search_admin($variables) { $form = $variables['form']; $output = drupal_render($form['info']); $header = array(t('Factor'), t('Influence')); foreach (element_children($form['factors']) as $key) { $row = array(); $row[] = $form['factors'][$key]['#title']; $form['factors'][$key]['#title_display'] = 'invisible'; $row[] = drupal_render($form['factors'][$key]); $rows[] = $row; } $output .= theme('table', array('header' => $header, 'rows' => $rows)); $output .= drupal_render_children($form); return $output; } /** * Access callback: Checks node revision access. * * @param $node * The node to check. * @param $op * (optional) The specific operation being checked. Defaults to 'view.' * @param object $account * (optional) A user object representing the user for whom the operation is * to be performed. Determines access for a user other than the current user. * * @return * TRUE if the operation may be performed, FALSE otherwise. * * @see node_menu() */ function _node_revision_access($node, $op = 'view', $account = NULL) { $access = &drupal_static(__FUNCTION__, array()); $map = array( 'view' => 'view revisions', 'update' => 'revert revisions', 'delete' => 'delete revisions', ); if (!$node || !isset($map[$op])) { // If there was no node to check against, or the $op was not one of the // supported ones, we return access denied. return FALSE; } if (!isset($account)) { $account = $GLOBALS['user']; } // Statically cache access by revision ID, user account ID, and operation. $cid = $node->vid . ':' . $account->uid . ':' . $op; if (!isset($access[$cid])) { // Perform basic permission checks first. if (!user_access($map[$op], $account) && !user_access('administer nodes', $account)) { return $access[$cid] = FALSE; } $node_current_revision = node_load($node->nid); $is_current_revision = $node_current_revision->vid == $node->vid; // There should be at least two revisions. If the vid of the given node and // the vid of the current revision differ, then we already have two // different revisions so there is no need for a separate database check. // Also, if you try to revert to or delete the current revision, that's not // good. if ($is_current_revision && (db_query('SELECT COUNT(vid) FROM {node_revision} WHERE nid = :nid', array(':nid' => $node->nid))->fetchField() == 1 || $op == 'update' || $op == 'delete')) { $access[$cid] = FALSE; } elseif (user_access('administer nodes', $account)) { $access[$cid] = TRUE; } else { // First check the access to the current revision and finally, if the node // passed in is not the current revision then access to that, too. $access[$cid] = node_access($op, $node_current_revision, $account) && ($is_current_revision || node_access($op, $node, $account)); } } return $access[$cid]; } /** * Access callback: Checks whether the user has permission to add a node. * * @return * TRUE if the user has add permission, otherwise FALSE. * * @see node_menu() */ function _node_add_access() { $types = node_type_get_types(); foreach ($types as $type) { if (node_hook($type->type, 'form') && node_access('create', $type->type)) { return TRUE; } } if (user_access('administer content types')) { // There are no content types defined that the user has permission to create, // but the user does have the permission to administer the content types, so // grant them access to the page anyway. return TRUE; } return FALSE; } /** * Implements hook_menu(). */ function node_menu() { $items['admin/content'] = array( 'title' => 'Content', 'description' => 'Find and manage content.', 'page callback' => 'drupal_get_form', 'page arguments' => array('node_admin_content'), 'access arguments' => array('access content overview'), 'weight' => -10, 'file' => 'node.admin.inc', ); $items['admin/content/node'] = array( 'title' => 'Content', 'type' => MENU_DEFAULT_LOCAL_TASK, 'weight' => -10, ); $items['admin/reports/status/rebuild'] = array( 'title' => 'Rebuild permissions', 'page callback' => 'drupal_get_form', 'page arguments' => array('node_configure_rebuild_confirm'), // Any user than can potentially trigger a node_access_needs_rebuild(TRUE) // has to be allowed access to the 'node access rebuild' confirm form. 'access arguments' => array('access administration pages'), 'type' => MENU_CALLBACK, 'file' => 'node.admin.inc', ); $items['admin/structure/types'] = array( 'title' => 'Content types', 'description' => 'Manage content types, including default status, front page promotion, comment settings, etc.', 'page callback' => 'node_overview_types', 'access arguments' => array('administer content types'), 'file' => 'content_types.inc', ); $items['admin/structure/types/list'] = array( 'title' => 'List', 'type' => MENU_DEFAULT_LOCAL_TASK, 'weight' => -10, ); $items['admin/structure/types/add'] = array( 'title' => 'Add content type', 'page callback' => 'drupal_get_form', 'page arguments' => array('node_type_form'), 'access arguments' => array('administer content types'), 'type' => MENU_LOCAL_ACTION, 'file' => 'content_types.inc', ); $items['admin/structure/types/manage/%node_type'] = array( 'title' => 'Edit content type', 'title callback' => 'node_type_page_title', 'title arguments' => array(4), 'page callback' => 'drupal_get_form', 'page arguments' => array('node_type_form', 4), 'access arguments' => array('administer content types'), 'file' => 'content_types.inc', ); $items['admin/structure/types/manage/%node_type/edit'] = array( 'title' => 'Edit', 'type' => MENU_DEFAULT_LOCAL_TASK, ); $items['admin/structure/types/manage/%node_type/delete'] = array( 'title' => 'Delete', 'page arguments' => array('node_type_delete_confirm', 4), 'access arguments' => array('administer content types'), 'file' => 'content_types.inc', ); $items['node'] = array( 'page callback' => 'node_page_default', 'access arguments' => array('access content'), 'menu_name' => 'navigation', 'type' => MENU_CALLBACK, ); $items['node/add'] = array( 'title' => 'Add content', 'page callback' => 'node_add_page', 'access callback' => '_node_add_access', 'file' => 'node.pages.inc', ); $items['rss.xml'] = array( 'title' => 'RSS feed', 'page callback' => 'node_feed', 'access arguments' => array('access content'), 'type' => MENU_CALLBACK, // Pass a FALSE and array argument to ensure that additional path components // are not passed to node_feed(). 'page arguments' => array(FALSE, array()), ); // @todo Remove this loop when we have a 'description callback' property. // Reset internal static cache of _node_types_build(), forces to rebuild the // node type information. node_type_cache_reset(); foreach (node_type_get_types() as $type) { $type_url_str = str_replace('_', '-', $type->type); $items['node/add/' . $type_url_str] = array( 'title' => $type->name, 'title callback' => 'check_plain', 'page callback' => 'node_add', 'page arguments' => array($type->type), 'access callback' => 'node_access', 'access arguments' => array('create', $type->type), 'description' => $type->description, 'file' => 'node.pages.inc', ); } $items['node/%node'] = array( 'title callback' => 'node_page_title', 'title arguments' => array(1), // The page callback also invokes drupal_set_title() in case // the menu router's title is overridden by a menu link. 'page callback' => 'node_page_view', 'page arguments' => array(1), 'access callback' => 'node_access', 'access arguments' => array('view', 1), ); $items['node/%node/view'] = array( 'title' => 'View', 'type' => MENU_DEFAULT_LOCAL_TASK, 'weight' => -10, ); $items['node/%node/edit'] = array( 'title' => 'Edit', 'page callback' => 'node_page_edit', 'page arguments' => array(1), 'access callback' => 'node_access', 'access arguments' => array('update', 1), 'weight' => 0, 'type' => MENU_LOCAL_TASK, 'context' => MENU_CONTEXT_PAGE | MENU_CONTEXT_INLINE, 'file' => 'node.pages.inc', ); $items['node/%node/delete'] = array( 'title' => 'Delete', 'page callback' => 'drupal_get_form', 'page arguments' => array('node_delete_confirm', 1), 'access callback' => 'node_access', 'access arguments' => array('delete', 1), 'weight' => 1, 'type' => MENU_LOCAL_TASK, 'context' => MENU_CONTEXT_INLINE, 'file' => 'node.pages.inc', ); $items['node/%node/revisions'] = array( 'title' => 'Revisions', 'page callback' => 'node_revision_overview', 'page arguments' => array(1), 'access callback' => '_node_revision_access', 'access arguments' => array(1), 'weight' => 2, 'type' => MENU_LOCAL_TASK, 'file' => 'node.pages.inc', ); $items['node/%node/revisions/%/view'] = array( 'title' => 'Revisions', 'load arguments' => array(3), 'page callback' => 'node_show', 'page arguments' => array(1, TRUE), 'access callback' => '_node_revision_access', 'access arguments' => array(1), ); $items['node/%node/revisions/%/revert'] = array( 'title' => 'Revert to earlier revision', 'load arguments' => array(3), 'page callback' => 'drupal_get_form', 'page arguments' => array('node_revision_revert_confirm', 1), 'access callback' => '_node_revision_access', 'access arguments' => array(1, 'update'), 'file' => 'node.pages.inc', ); $items['node/%node/revisions/%/delete'] = array( 'title' => 'Delete earlier revision', 'load arguments' => array(3), 'page callback' => 'drupal_get_form', 'page arguments' => array('node_revision_delete_confirm', 1), 'access callback' => '_node_revision_access', 'access arguments' => array(1, 'delete'), 'file' => 'node.pages.inc', ); return $items; } /** * Implements hook_menu_local_tasks_alter(). */ function node_menu_local_tasks_alter(&$data, $router_item, $root_path) { // Add action link to 'node/add' on 'admin/content' page. if ($root_path == 'admin/content') { $item = menu_get_item('node/add'); if ($item['access']) { $data['actions']['output'][] = array( '#theme' => 'menu_local_action', '#link' => $item, ); } } } /** * Title callback: Returns the unsanitized title of the node type edit form. * * @param $type * The node type object. * * @return string * An unsanitized string that is the title of the node type edit form. * * @see node_menu() */ function node_type_page_title($type) { return $type->name; } /** * Title callback: Returns the title of the node. * * @param $node * The node object. * * @return * An unsanitized string that is the title of the node. * * @see node_menu() */ function node_page_title($node) { return $node->title; } /** * Finds the last time a node was changed. * * @param $nid * The ID of a node. * * @return * A unix timestamp indicating the last time the node was changed. */ function node_last_changed($nid) { return db_query('SELECT changed FROM {node} WHERE nid = :nid', array(':nid' => $nid))->fetch()->changed; } /** * Returns a list of all the existing revision numbers. * * @param $node * The node object. * * @return * An associative array keyed by node revision number. */ function node_revision_list($node) { $revisions = array(); $result = db_query('SELECT r.vid, r.title, r.log, r.uid, n.vid AS current_vid, r.timestamp, u.name FROM {node_revision} r LEFT JOIN {node} n ON n.vid = r.vid INNER JOIN {users} u ON u.uid = r.uid WHERE r.nid = :nid ORDER BY r.vid DESC', array(':nid' => $node->nid)); foreach ($result as $revision) { $revisions[$revision->vid] = $revision; } return $revisions; } /** * Implements hook_block_info(). */ function node_block_info() { $blocks['syndicate']['info'] = t('Syndicate'); // Not worth caching. $blocks['syndicate']['cache'] = DRUPAL_NO_CACHE; $blocks['recent']['info'] = t('Recent content'); $blocks['recent']['properties']['administrative'] = TRUE; return $blocks; } /** * Implements hook_block_view(). */ function node_block_view($delta = '') { $block = array(); switch ($delta) { case 'syndicate': $block['subject'] = t('Syndicate'); $block['content'] = theme('feed_icon', array('url' => 'rss.xml', 'title' => t('Syndicate'))); break; case 'recent': if (user_access('access content')) { $block['subject'] = t('Recent content'); if ($nodes = node_get_recent(variable_get('node_recent_block_count', 10))) { $block['content'] = theme('node_recent_block', array( 'nodes' => $nodes, )); } else { $block['content'] = t('No content available.'); } } break; } return $block; } /** * Implements hook_block_configure(). */ function node_block_configure($delta = '') { $form = array(); if ($delta == 'recent') { $form['node_recent_block_count'] = array( '#type' => 'select', '#title' => t('Number of recent content items to display'), '#default_value' => variable_get('node_recent_block_count', 10), '#options' => drupal_map_assoc(array(2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 25, 30)), ); } return $form; } /** * Implements hook_block_save(). */ function node_block_save($delta = '', $edit = array()) { if ($delta == 'recent') { variable_set('node_recent_block_count', $edit['node_recent_block_count']); } } /** * Finds the most recently changed nodes that are available to the current user. * * @param $number * (optional) The maximum number of nodes to find. Defaults to 10. * * @return * An array of node entities or an empty array if there are no recent nodes * visible to the current user. */ function node_get_recent($number = 10) { $query = db_select('node', 'n'); if (!user_access('bypass node access')) { // If the user is able to view their own unpublished nodes, allow them to // see these in addition to published nodes. Check that they actually have // some unpublished nodes to view before adding the condition. if (user_access('view own unpublished content') && $own_unpublished = db_query('SELECT nid FROM {node} WHERE uid = :uid AND status = :status', array(':uid' => $GLOBALS['user']->uid, ':status' => NODE_NOT_PUBLISHED))->fetchCol()) { $query->condition(db_or() ->condition('n.status', NODE_PUBLISHED) ->condition('n.nid', $own_unpublished, 'IN') ); } else { // If not, restrict the query to published nodes. $query->condition('n.status', NODE_PUBLISHED); } } $nids = $query ->fields('n', array('nid')) ->orderBy('n.changed', 'DESC') ->range(0, $number) ->addTag('node_access') ->execute() ->fetchCol(); $nodes = node_load_multiple($nids); return $nodes ? $nodes : array(); } /** * Returns HTML for a list of recent content. * * @param $variables * An associative array containing: * - nodes: An array of recent node objects. * * @ingroup themeable */ function theme_node_recent_block($variables) { $rows = array(); $output = ''; $l_options = array('query' => drupal_get_destination()); foreach ($variables['nodes'] as $node) { $row = array(); $row[] = array( 'data' => theme('node_recent_content', array('node' => $node)), 'class' => 'title-author', ); $row[] = array( 'data' => node_access('update', $node) ? l(t('edit'), 'node/' . $node->nid . '/edit', $l_options) : '', 'class' => 'edit', ); $row[] = array( 'data' => node_access('delete', $node) ? l(t('delete'), 'node/' . $node->nid . '/delete', $l_options) : '', 'class' => 'delete', ); $rows[] = $row; } if ($rows) { $output = theme('table', array('rows' => $rows)); if (user_access('access content overview')) { $output .= theme('more_link', array('url' => 'admin/content', 'title' => t('Show more content'))); } } return $output; } /** * Returns HTML for a recent node to be displayed in the recent content block. * * @param $variables * An associative array containing: * - node: A node object. * * @ingroup themeable */ function theme_node_recent_content($variables) { $node = $variables['node']; $output = '' . t('No front page content has been created yet.') . '
'; $default_links = array(); if (_node_add_access()) { $default_links[] = l(t('Add new content'), 'node/add'); } if (!empty($default_links)) { $default_message .= theme('item_list', array('items' => $default_links)); } $build['default_message'] = array( '#markup' => $default_message, '#prefix' => '