3176 lines
109 KiB
Plaintext
3176 lines
109 KiB
Plaintext
<?php
|
|
// $Id$
|
|
|
|
/**
|
|
* @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);
|
|
|
|
/**
|
|
* Implementation of hook_help().
|
|
*/
|
|
function node_help($section) {
|
|
switch ($section) {
|
|
case 'admin/help#node':
|
|
$output = '<p>'. t('All content in a website is stored and treated as <b>nodes</b>. Therefore nodes are any postings such as blogs, stories, polls and forums. The node module manages these content types and is one of the strengths of Drupal over other content management systems.') .'</p>';
|
|
$output .= '<p>'. t('Treating all content as nodes allows the flexibility of creating new types of content. It also allows you to painlessly apply new features or changes to all content. Comments are not stored as nodes but are always associated with a node.') .'</p>';
|
|
$output .= t('<p>Node module features</p>
|
|
<ul>
|
|
<li>The list tab provides an interface to search and sort all content on your site.</li>
|
|
<li>The configure settings tab has basic settings for content on your site.</li>
|
|
<li>The configure content types tab lists all content types for your site and lets you configure their default workflow.</li>
|
|
<li>The search tab lets you search all content on your site</li>
|
|
</ul>
|
|
');
|
|
$output .= '<p>'. t('For more information please read the configuration and customization handbook <a href="@node">Node page</a>.', array('@node' => 'http://drupal.org/handbook/modules/node/')) .'</p>';
|
|
return $output;
|
|
case 'admin/content/search':
|
|
return '<p>'. t('Enter a simple pattern to search for a post. Words are matched exactly. Phrases can be surrounded by quotes to do an exact search.') .'</p>';
|
|
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>';
|
|
}
|
|
|
|
if (arg(0) == 'node' && is_numeric(arg(1)) && arg(2) == 'revisions') {
|
|
return '<p>'. t('The revisions let you track differences between multiple versions of a post.') .'</p>';
|
|
}
|
|
|
|
if (arg(0) == 'node' && arg(1) == 'add' && $type = arg(2)) {
|
|
$type = node_get_types('type', str_replace('-', '_', arg(2)));
|
|
return '<p>'. (isset($type->help) ? filter_xss_admin($type->help) : '') .'</p>';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_theme()
|
|
*/
|
|
function node_theme() {
|
|
return array(
|
|
'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),
|
|
),
|
|
'node_filters' => array(
|
|
'arguments' => array('form' => NULL),
|
|
),
|
|
'node_admin_nodes' => array(
|
|
'arguments' => array('form' => NULL),
|
|
),
|
|
'node_form' => array(
|
|
'arguments' => array('form' => NULL),
|
|
),
|
|
'node_preview' => array(
|
|
'arguments' => array('node' => NULL),
|
|
),
|
|
'node_log_message' => array(
|
|
'arguments' => array('log' => 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.
|
|
*/
|
|
function node_title_list($result, $title = NULL) {
|
|
while ($node = db_fetch_object($result)) {
|
|
$items[] = l($node->title, 'node/'. $node->nid, !empty($node->comment_count) ? array('title' => format_plural($node->comment_count, '1 comment', '@count comments')) : array());
|
|
}
|
|
|
|
return theme('node_list', $items, $title);
|
|
}
|
|
|
|
/**
|
|
* Format a listing of links to nodes.
|
|
*/
|
|
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) {
|
|
// Glue the teaser to the body.
|
|
if (isset($form['#post']['teaser_js'])) {
|
|
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 value onto preview/submit
|
|
form_set_value($form['body'], $body, $form_state);
|
|
// Pass value back onto form
|
|
$form['body']['#value'] = $body;
|
|
}
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* Automatically generate a teaser for a node body in a given format.
|
|
*/
|
|
function node_teaser($body, $format = NULL) {
|
|
|
|
$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['filter/1']) && strpos($body, '<?') !== FALSE) {
|
|
return $body;
|
|
}
|
|
}
|
|
|
|
// If we have a short body, the entire body is the teaser.
|
|
if (strlen($body) < $size) {
|
|
return $body;
|
|
}
|
|
|
|
// The teaser may not be longer than maximum length specified. Initial slice.
|
|
$teaser = truncate_utf8($body, $size);
|
|
$position = 0;
|
|
// Cache the reverse of the teaser.
|
|
$reversed = strrev($teaser);
|
|
|
|
// In some cases, no delimiter has been specified. In this case, we try to
|
|
// split at paragraph boundaries.
|
|
$breakpoints = array('</p>' => 0, '<br />' => 6, '<br>' => 4, "\n" => 1);
|
|
// We use strpos on the reversed needle and haystack for speed.
|
|
foreach ($breakpoints as $point => $offset) {
|
|
$length = strpos($reversed, strrev($point));
|
|
if ($length !== FALSE) {
|
|
$position = - $length - $offset;
|
|
return ($position == 0) ? $teaser : substr($teaser, 0, $position);
|
|
}
|
|
}
|
|
|
|
// When even the first paragraph is too long, we try to split at the end of
|
|
// the last full sentence.
|
|
$breakpoints = array('. ' => 1, '! ' => 1, '? ' => 1, '。' => 0, '؟ ' => 1);
|
|
$min_length = strlen($reversed);
|
|
foreach ($breakpoints as $point => $offset) {
|
|
$length = strpos($reversed, strrev($point));
|
|
if ($length !== FALSE) {
|
|
$min_length = min($length, $min_length);
|
|
$position = 0 - $length - $offset;
|
|
}
|
|
}
|
|
return ($position == 0) ? $teaser : substr($teaser, 0, $position);
|
|
}
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
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 $_node_types[$type];
|
|
case 'module':
|
|
return $_node_types[$type]->module;
|
|
case 'names':
|
|
return $_node_names;
|
|
case 'name':
|
|
return $_node_names[$type];
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
}
|
|
|
|
_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_num_rows(db_query("SELECT * 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) {
|
|
db_query("DELETE FROM {node_type} WHERE type = '%s'", $type);
|
|
|
|
$info = node_get_types('type', $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) {
|
|
db_query("UPDATE {node} SET type = '%s' WHERE type = '%s'", $type, $old_type);
|
|
return db_affected_rows();
|
|
}
|
|
|
|
/**
|
|
* Builds the list of available node types, by querying hook_node_info() in all
|
|
* modules, and by looking for node types in the database.
|
|
*
|
|
*/
|
|
function _node_types_build() {
|
|
$_node_types = array();
|
|
$_node_names = array();
|
|
|
|
$info_array = module_invoke_all('node_info');
|
|
foreach ($info_array as $type => $info) {
|
|
$info['type'] = $type;
|
|
$_node_types[$type] = (object) _node_type_set_defaults($info);
|
|
$_node_names[$type] = $info['name'];
|
|
}
|
|
|
|
$type_result = db_query(db_rewrite_sql('SELECT nt.type, nt.* FROM {node_type} nt ORDER BY nt.type ASC', 'nt', 'type'));
|
|
while ($type_object = db_fetch_object($type_result)) {
|
|
if (!isset($_node_types[$type_object->type]) || $type_object->modified) {
|
|
$_node_types[$type_object->type] = $type_object;
|
|
$_node_names[$type_object->type] = $type_object->name;
|
|
|
|
if ($type_object->type != $type_object->orig_type) {
|
|
unset($_node_types[$type_object->orig_type]);
|
|
unset($_node_names[$type_object->orig_type]);
|
|
}
|
|
}
|
|
}
|
|
|
|
asort($_node_names);
|
|
|
|
return array($_node_types, $_node_names);
|
|
}
|
|
|
|
/**
|
|
* Set default values for a node type defined through hook_node_info().
|
|
*/
|
|
function _node_type_set_defaults($info) {
|
|
if (!isset($info['has_title'])) {
|
|
$info['has_title'] = TRUE;
|
|
}
|
|
if ($info['has_title'] && !isset($info['title_label'])) {
|
|
$info['title_label'] = t('Title');
|
|
}
|
|
|
|
if (!isset($info['has_body'])) {
|
|
$info['has_body'] = TRUE;
|
|
}
|
|
if ($info['has_body'] && !isset($info['body_label'])) {
|
|
$info['body_label'] = t('Body');
|
|
}
|
|
|
|
if (!isset($info['help'])) {
|
|
$info['help'] = '';
|
|
}
|
|
if (!isset($info['min_word_count'])) {
|
|
$info['min_word_count'] = 0;
|
|
}
|
|
if (!isset($info['custom'])) {
|
|
$info['custom'] = FALSE;
|
|
}
|
|
if (!isset($info['modified'])) {
|
|
$info['modified'] = FALSE;
|
|
}
|
|
if (!isset($info['locked'])) {
|
|
$info['locked'] = TRUE;
|
|
}
|
|
|
|
$info['orig_type'] = $info['type'];
|
|
$info['is_new'] = TRUE;
|
|
|
|
return $info;
|
|
}
|
|
|
|
/**
|
|
* Determine whether a node hook exists.
|
|
*
|
|
* @param &$node
|
|
* Either a node object, node array, or a string containing the node type.
|
|
* @param $hook
|
|
* A string containing the name of the hook.
|
|
* @return
|
|
* TRUE iff the $hook exists in the node type of $node.
|
|
*/
|
|
function node_hook(&$node, $hook) {
|
|
$module = node_get_types('module', $node);
|
|
if ($module == 'node') {
|
|
$module = 'node_content'; // Avoid function name collisions.
|
|
}
|
|
return module_hook($module, $hook);
|
|
}
|
|
|
|
/**
|
|
* Invoke a node hook.
|
|
*
|
|
* @param &$node
|
|
* Either a node object, node array, 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)) {
|
|
$module = node_get_types('module', $node);
|
|
if ($module == 'node') {
|
|
$module = 'node_content'; // Avoid function name collisions.
|
|
}
|
|
$function = $module .'_'. $hook;
|
|
return ($function($node, $a2, $a3, $a4));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Invoke a hook_nodeapi() operation in all modules.
|
|
*
|
|
* @param &$node
|
|
* A node object.
|
|
* @param $op
|
|
* A string containing the name of the nodeapi operation.
|
|
* @param $a3, $a4
|
|
* Arguments to pass on to the hook, after the $node and $op arguments.
|
|
* @return
|
|
* The returned value of the invoked hooks.
|
|
*/
|
|
function node_invoke_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) {
|
|
$return = array();
|
|
foreach (module_implements('nodeapi') as $name) {
|
|
$function = $name .'_nodeapi';
|
|
$result = $function($node, $op, $a3, $a4);
|
|
if (isset($result) && is_array($result)) {
|
|
$return = array_merge($return, $result);
|
|
}
|
|
else if (isset($result)) {
|
|
$return[] = $result;
|
|
}
|
|
}
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Load a node object from the database.
|
|
*
|
|
* @param $param
|
|
* Either the nid of the node or an array of conditions to match against in the database query
|
|
* @param $revision
|
|
* Which numbered revision to load. Defaults to the current version.
|
|
* @param $reset
|
|
* Whether to reset the internal node_load cache.
|
|
*
|
|
* @return
|
|
* A fully-populated node object.
|
|
*/
|
|
function node_load($param = array(), $revision = NULL, $reset = NULL) {
|
|
static $nodes = array();
|
|
|
|
if ($reset) {
|
|
$nodes = array();
|
|
}
|
|
|
|
$cachable = ($revision == NULL);
|
|
$arguments = array();
|
|
if (is_numeric($param)) {
|
|
if ($cachable && isset($nodes[$param])) {
|
|
return is_object($nodes[$param]) ? drupal_clone($nodes[$param]) : $nodes[$param];
|
|
}
|
|
$cond = 'n.nid = %d';
|
|
$arguments[] = $param;
|
|
}
|
|
elseif (is_array($param)) {
|
|
// Turn the conditions into a query.
|
|
foreach ($param as $key => $value) {
|
|
$cond[] = 'n.'. db_escape_string($key) ." = '%s'";
|
|
$arguments[] = $value;
|
|
}
|
|
$cond = implode(' AND ', $cond);
|
|
}
|
|
else {
|
|
return FALSE;
|
|
}
|
|
|
|
// Retrieve the node.
|
|
// No db_rewrite_sql is applied so as to get complete indexing for search.
|
|
if ($revision) {
|
|
array_unshift($arguments, $revision);
|
|
$node = db_fetch_object(db_query('SELECT n.nid, r.vid, n.type, n.status, n.language, n.created, n.changed, n.comment, n.promote, n.sticky, n.tnid, n.translate, r.timestamp AS revision_timestamp, r.title, r.body, r.teaser, r.log, r.format, u.uid, u.name, u.picture, u.data FROM {node} n INNER JOIN {users} u ON u.uid = n.uid INNER JOIN {node_revisions} r ON r.nid = n.nid AND r.vid = %d WHERE '. $cond, $arguments));
|
|
}
|
|
else {
|
|
$node = db_fetch_object(db_query('SELECT n.nid, n.vid, n.type, n.status, n.language, n.created, n.changed, n.comment, n.promote, n.sticky, n.tnid, n.translate, r.timestamp AS revision_timestamp, r.title, r.body, r.teaser, r.log, r.format, u.uid, u.name, u.picture, u.data FROM {node} n INNER JOIN {users} u ON u.uid = n.uid INNER JOIN {node_revisions} r ON r.vid = n.vid WHERE '. $cond, $arguments));
|
|
}
|
|
|
|
if ($node && $node->nid) {
|
|
// Call the node specific callback (if any) and piggy-back the
|
|
// results to the node or overwrite some values.
|
|
if ($extra = node_invoke($node, 'load')) {
|
|
foreach ($extra as $key => $value) {
|
|
$node->$key = $value;
|
|
}
|
|
}
|
|
|
|
if ($extra = node_invoke_nodeapi($node, 'load')) {
|
|
foreach ($extra as $key => $value) {
|
|
$node->$key = $value;
|
|
}
|
|
}
|
|
if ($cachable) {
|
|
$nodes[$node->nid] = is_object($node) ? drupal_clone($node) : $node;
|
|
}
|
|
}
|
|
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Save a node object into the database.
|
|
*/
|
|
function node_save(&$node) {
|
|
global $user;
|
|
|
|
$node->is_new = FALSE;
|
|
|
|
// Apply filters to some default node fields:
|
|
if (empty($node->nid)) {
|
|
// Insert a new node.
|
|
$node->is_new = TRUE;
|
|
}
|
|
else {
|
|
// We need to ensure that all node fields are filled.
|
|
$node_current = node_load($node->nid);
|
|
foreach ($node as $field => $data) {
|
|
$node_current->$field = $data;
|
|
}
|
|
$node = $node_current;
|
|
|
|
if (!empty($node->revision)) {
|
|
$node->old_vid = $node->vid;
|
|
}
|
|
}
|
|
|
|
// Set some required fields:
|
|
if (empty($node->created)) {
|
|
$node->created = time();
|
|
}
|
|
// The changed timestamp is always updated for bookkeeping purposes (revisions, searching, ...)
|
|
$node->changed = time();
|
|
|
|
// Split off revisions data to another structure
|
|
$revisions_table_values = array('nid' => &$node->nid,
|
|
'title' => $node->title, 'body' => $node->body,
|
|
'teaser' => $node->teaser, 'timestamp' => $node->changed,
|
|
'uid' => $user->uid, 'format' => $node->format);
|
|
$revisions_table_types = array('nid' => '%d',
|
|
'title' => "'%s'", 'body' => "'%s'",
|
|
'teaser' => "'%s'", 'timestamp' => '%d',
|
|
'uid' => '%d', 'format' => '%d');
|
|
if (!empty($node->log) || $node->is_new || $node->revision) {
|
|
// Only store the log message if there's something to store; this prevents
|
|
// existing log messages from being unintentionally overwritten by a blank
|
|
// message. A new revision will have an empty log message (or $node->log).
|
|
$revisions_table_values['log'] = $node->log;
|
|
$revisions_table_types['log'] = "'%s'";
|
|
}
|
|
$node_table_values = array(
|
|
'title' => $node->title, 'type' => $node->type, 'uid' => $node->uid,
|
|
'status' => $node->status, 'language' => $node->language, 'created' => $node->created,
|
|
'changed' => $node->changed, 'comment' => $node->comment,
|
|
'promote' => $node->promote, 'sticky' => $node->sticky);
|
|
$node_table_types = array(
|
|
'title' => "'%s'", 'type' => "'%s'", 'uid' => '%d',
|
|
'status' => '%d', 'language' => "'%s'",'created' => '%d',
|
|
'changed' => '%d', 'comment' => '%d',
|
|
'promote' => '%d', 'sticky' => '%d');
|
|
$update_node = TRUE;
|
|
//Generate the node table query and the
|
|
//the node_revisions table query
|
|
if ($node->is_new) {
|
|
$node_query = 'INSERT INTO {node} (vid, '. implode(', ', array_keys($node_table_types)) .') VALUES (NULL, '. implode(', ', $node_table_types) .')';
|
|
db_query($node_query, $node_table_values);
|
|
$node->nid = db_last_insert_id('node', 'nid');
|
|
$revisions_query = 'INSERT INTO {node_revisions} ('. implode(', ', array_keys($revisions_table_types)) .') VALUES ('. implode(', ', $revisions_table_types) .')';
|
|
db_query($revisions_query, $revisions_table_values);
|
|
$node->vid = db_last_insert_id('node_revisions', 'vid');
|
|
$op = 'insert';
|
|
}
|
|
else {
|
|
$arr = array();
|
|
foreach ($node_table_types as $key => $value) {
|
|
$arr[] = $key .' = '. $value;
|
|
}
|
|
$node_table_values[] = $node->nid;
|
|
$node_query = 'UPDATE {node} SET '. implode(', ', $arr) .' WHERE nid = %d';
|
|
db_query($node_query, $node_table_values);
|
|
if (!empty($node->revision)) {
|
|
$revisions_query = 'INSERT INTO {node_revisions} ('. implode(', ', array_keys($revisions_table_types)) .') VALUES ('. implode(', ', $revisions_table_types) .')';
|
|
db_query($revisions_query, $revisions_table_values);
|
|
$node->vid = db_last_insert_id('node_revisions', 'vid');
|
|
}
|
|
else {
|
|
$arr = array();
|
|
foreach ($revisions_table_types as $key => $value) {
|
|
$arr[] = $key .' = '. $value;
|
|
}
|
|
$revisions_table_values[] = $node->vid;
|
|
$revisions_query = 'UPDATE {node_revisions} SET '. implode(', ', $arr) .' WHERE vid = %d';
|
|
db_query($revisions_query, $revisions_table_values);
|
|
$update_node = FALSE;
|
|
}
|
|
$op = 'update';
|
|
}
|
|
if ($update_node) {
|
|
db_query('UPDATE {node} SET vid = %d WHERE nid = %d', $node->vid, $node->nid);
|
|
}
|
|
|
|
// Call the node specific callback (if any):
|
|
node_invoke($node, $op);
|
|
node_invoke_nodeapi($node, $op);
|
|
|
|
// Update the node access table for this node.
|
|
node_access_acquire_grants($node);
|
|
|
|
// Clear the cache so an anonymous poster can see the node being added or updated.
|
|
cache_clear_all();
|
|
}
|
|
|
|
/**
|
|
* Generate a display of the given node.
|
|
*
|
|
* @param $node
|
|
* A node array or node object.
|
|
* @param $teaser
|
|
* Whether to display the teaser only, as on the main page.
|
|
* @param $page
|
|
* Whether the node is being displayed by itself as a page.
|
|
* @param $links
|
|
* Whether or not to display node links. Links are omitted for node previews.
|
|
*
|
|
* @return
|
|
* An HTML representation of the themed node.
|
|
*/
|
|
function node_view($node, $teaser = FALSE, $page = FALSE, $links = TRUE) {
|
|
$node = (object)$node;
|
|
|
|
$node = node_build_content($node, $teaser, $page);
|
|
|
|
if ($links) {
|
|
$node->links = module_invoke_all('link', 'node', $node, !$page);
|
|
drupal_alter('link', $node->links, $node);
|
|
}
|
|
|
|
// Set the proper node part, then unset unused $node part so that a bad
|
|
// theme can not open a security hole.
|
|
$content = drupal_render($node->content);
|
|
if ($teaser) {
|
|
$node->teaser = $content;
|
|
unset($node->body);
|
|
}
|
|
else {
|
|
$node->body = $content;
|
|
unset($node->teaser);
|
|
}
|
|
|
|
// Allow modules to modify the fully-built node.
|
|
node_invoke_nodeapi($node, 'alter', $teaser, $page);
|
|
|
|
return theme('node', $node, $teaser, $page);
|
|
}
|
|
|
|
/**
|
|
* Apply filters and build the node's standard elements.
|
|
*/
|
|
function node_prepare($node, $teaser = FALSE) {
|
|
// First we'll overwrite the existing node teaser and body with
|
|
// the filtered copies! Then, we'll stick those into the content
|
|
// array and set the read more flag if appropriate.
|
|
$node->readmore = (strlen($node->teaser) < strlen($node->body));
|
|
|
|
if ($teaser == FALSE) {
|
|
$node->body = check_markup($node->body, $node->format, FALSE);
|
|
}
|
|
else {
|
|
$node->teaser = check_markup($node->teaser, $node->format, FALSE);
|
|
}
|
|
|
|
$node->content['body'] = array(
|
|
'#value' => $teaser ? $node->teaser : $node->body,
|
|
'#weight' => 0,
|
|
);
|
|
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Builds a structured array representing the node's content.
|
|
*
|
|
* @param $node
|
|
* A node object.
|
|
* @param $teaser
|
|
* Whether to display the teaser only, as on the main page.
|
|
* @param $page
|
|
* Whether the node is being displayed by itself as a page.
|
|
*
|
|
* @return
|
|
* An structured array containing the individual elements
|
|
* of the node's body.
|
|
*/
|
|
function node_build_content($node, $teaser = FALSE, $page = FALSE) {
|
|
// Remove the delimiter (if any) that separates the teaser from the body.
|
|
$node->body = isset($node->body) ? str_replace('<!--break-->', '', $node->body) : '';
|
|
|
|
// The 'view' hook can be implemented to overwrite the default function
|
|
// to display nodes.
|
|
if (node_hook($node, 'view')) {
|
|
$node = node_invoke($node, 'view', $teaser, $page);
|
|
}
|
|
else {
|
|
$node = node_prepare($node, $teaser);
|
|
}
|
|
|
|
// Allow modules to make their own additions to the node.
|
|
node_invoke_nodeapi($node, 'view', $teaser, $page);
|
|
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Generate a page displaying a single node, along with its comments.
|
|
*/
|
|
function node_show($node, $cid) {
|
|
$output = node_view($node, FALSE, TRUE);
|
|
|
|
if (function_exists('comment_render') && $node->comment) {
|
|
$output .= comment_render($node, $cid);
|
|
}
|
|
|
|
// Update the history table, stating that this user viewed this node.
|
|
node_tag_new($node->nid);
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_perm().
|
|
*/
|
|
function node_perm() {
|
|
$perms = array('administer content types', 'administer nodes', 'access content', 'view revisions', 'revert revisions');
|
|
|
|
foreach (node_get_types() as $type) {
|
|
if ($type->module == 'node') {
|
|
$name = check_plain($type->type);
|
|
$perms[] = 'create '. $name .' content';
|
|
$perms[] = 'delete own '. $name .' content';
|
|
$perms[] = 'delete '. $name .' content';
|
|
$perms[] = 'edit own '. $name .' content';
|
|
$perms[] = 'edit '. $name .' content';
|
|
}
|
|
}
|
|
|
|
return $perms;
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_search().
|
|
*/
|
|
function node_search($op = 'search', $keys = NULL) {
|
|
switch ($op) {
|
|
case 'name':
|
|
return t('Content');
|
|
|
|
case 'reset':
|
|
variable_del('node_cron_last');
|
|
variable_del('node_cron_last_nid');
|
|
return;
|
|
|
|
case 'status':
|
|
$last = variable_get('node_cron_last', 0);
|
|
$last_nid = variable_get('node_cron_last_nid', 0);
|
|
$total = db_result(db_query('SELECT COUNT(*) FROM {node} WHERE status = 1'));
|
|
$remaining = db_result(db_query('SELECT COUNT(*) FROM {node} n LEFT JOIN {node_comment_statistics} c ON n.nid = c.nid WHERE n.status = 1 AND ((GREATEST(n.created, n.changed, c.last_comment_timestamp) = %d AND n.nid > %d ) OR (n.created > %d OR n.changed > %d OR c.last_comment_timestamp > %d))', $last, $last_nid, $last, $last, $last));
|
|
return array('remaining' => $remaining, 'total' => $total);
|
|
|
|
case 'admin':
|
|
$form = array();
|
|
// 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('#value' => '<em>'. t('The following numbers control which properties the content search should favor when ordering the results. Higher numbers mean more influence, zero means the property is ignored. Changing these numbers does not require the search index to be rebuilt. Changes take effect immediately.') .'</em>');
|
|
|
|
$ranking = array('node_rank_relevance' => t('Keyword relevance'),
|
|
'node_rank_recent' => t('Recently posted'));
|
|
if (module_exists('comment')) {
|
|
$ranking['node_rank_comments'] = t('Number of comments');
|
|
}
|
|
if (module_exists('statistics') && variable_get('statistics_count_content_views', 0)) {
|
|
$ranking['node_rank_views'] = t('Number of views');
|
|
}
|
|
|
|
// Note: reversed to reflect that higher number = higher ranking.
|
|
$options = drupal_map_assoc(range(0, 10));
|
|
foreach ($ranking as $var => $title) {
|
|
$form['content_ranking']['factors'][$var] = array('#title' => $title, '#type' => 'select', '#options' => $options, '#default_value' => variable_get($var, 5));
|
|
}
|
|
return $form;
|
|
|
|
case 'search':
|
|
// Build matching conditions
|
|
list($join1, $where1) = _db_rewrite_sql();
|
|
$arguments1 = array();
|
|
$conditions1 = 'n.status = 1';
|
|
|
|
if ($type = search_query_extract($keys, 'type')) {
|
|
$types = array();
|
|
foreach (explode(',', $type) as $t) {
|
|
$types[] = "n.type = '%s'";
|
|
$arguments1[] = $t;
|
|
}
|
|
$conditions1 .= ' AND ('. implode(' OR ', $types) .')';
|
|
$keys = search_query_insert($keys, 'type');
|
|
}
|
|
|
|
if ($category = search_query_extract($keys, 'category')) {
|
|
$categories = array();
|
|
foreach (explode(',', $category) as $c) {
|
|
$categories[] = "tn.tid = %d";
|
|
$arguments1[] = $c;
|
|
}
|
|
$conditions1 .= ' AND ('. implode(' OR ', $categories) .')';
|
|
$join1 .= ' INNER JOIN {term_node} tn ON n.nid = tn.nid';
|
|
$keys = search_query_insert($keys, 'category');
|
|
}
|
|
|
|
// Build ranking expression (we try to map each parameter to a
|
|
// uniform distribution in the range 0..1).
|
|
$ranking = array();
|
|
$arguments2 = array();
|
|
$join2 = '';
|
|
// Used to avoid joining on node_comment_statistics twice
|
|
$stats_join = FALSE;
|
|
$total = 0;
|
|
if ($weight = (int)variable_get('node_rank_relevance', 5)) {
|
|
// Average relevance values hover around 0.15
|
|
$ranking[] = '%d * i.relevance';
|
|
$arguments2[] = $weight;
|
|
$total += $weight;
|
|
}
|
|
if ($weight = (int)variable_get('node_rank_recent', 5)) {
|
|
// Exponential decay with half-life of 6 months, starting at last indexed node
|
|
$ranking[] = '%d * POW(2, (GREATEST(n.created, n.changed, c.last_comment_timestamp) - %d) * 6.43e-8)';
|
|
$arguments2[] = $weight;
|
|
$arguments2[] = (int)variable_get('node_cron_last', 0);
|
|
$join2 .= ' INNER JOIN {node} n ON n.nid = i.sid LEFT JOIN {node_comment_statistics} c ON c.nid = i.sid';
|
|
$stats_join = TRUE;
|
|
$total += $weight;
|
|
}
|
|
if (module_exists('comment') && $weight = (int)variable_get('node_rank_comments', 5)) {
|
|
// Inverse law that maps the highest reply count on the site to 1 and 0 to 0.
|
|
$scale = variable_get('node_cron_comments_scale', 0.0);
|
|
$ranking[] = '%d * (2.0 - 2.0 / (1.0 + c.comment_count * %f))';
|
|
$arguments2[] = $weight;
|
|
$arguments2[] = $scale;
|
|
if (!$stats_join) {
|
|
$join2 .= ' LEFT JOIN {node_comment_statistics} c ON c.nid = i.sid';
|
|
}
|
|
$total += $weight;
|
|
}
|
|
if (module_exists('statistics') && variable_get('statistics_count_content_views', 0) &&
|
|
$weight = (int)variable_get('node_rank_views', 5)) {
|
|
// Inverse law that maps the highest view count on the site to 1 and 0 to 0.
|
|
$scale = variable_get('node_cron_views_scale', 0.0);
|
|
$ranking[] = '%d * (2.0 - 2.0 / (1.0 + nc.totalcount * %f))';
|
|
$arguments2[] = $weight;
|
|
$arguments2[] = $scale;
|
|
$join2 .= ' LEFT JOIN {node_counter} nc ON nc.nid = i.sid';
|
|
$total += $weight;
|
|
}
|
|
$select2 = (count($ranking) ? implode(' + ', $ranking) : 'i.relevance') .' AS score';
|
|
|
|
// Do search
|
|
$find = do_search($keys, 'node', 'INNER JOIN {node} n ON n.nid = i.sid '. $join1 .' INNER JOIN {users} u ON n.uid = u.uid', $conditions1 . (empty($where1) ? '' : ' AND '. $where1), $arguments1, $select2, $join2, $arguments2);
|
|
|
|
// Load results
|
|
$results = array();
|
|
foreach ($find as $item) {
|
|
// Build the node body.
|
|
$node = node_load($item->sid);
|
|
$node = node_build_content($node, FALSE, FALSE);
|
|
$node->body = drupal_render($node->content);
|
|
|
|
// Fetch comments for snippet
|
|
$node->body .= module_invoke('comment', 'nodeapi', $node, 'update index');
|
|
// Fetch terms for snippet
|
|
$node->body .= module_invoke('taxonomy', 'nodeapi', $node, 'update index');
|
|
|
|
$extra = node_invoke_nodeapi($node, 'search result');
|
|
$results[] = array('link' => url('node/'. $item->sid, array('absolute' => TRUE)),
|
|
'type' => node_get_types('name', $node),
|
|
'title' => $node->title,
|
|
'user' => theme('username', $node),
|
|
'date' => $node->changed,
|
|
'node' => $node,
|
|
'extra' => $extra,
|
|
'score' => $item->score / $total,
|
|
'snippet' => search_excerpt($keys, $node->body));
|
|
}
|
|
return $results;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_user().
|
|
*/
|
|
function node_user($op, &$edit, &$user) {
|
|
if ($op == 'delete') {
|
|
db_query('UPDATE {node} SET uid = 0 WHERE uid = %d', $user->uid);
|
|
db_query('UPDATE {node_revisions} SET uid = 0 WHERE uid = %d', $user->uid);
|
|
}
|
|
}
|
|
|
|
function theme_node_search_admin($form) {
|
|
$output = drupal_render($form['info']);
|
|
|
|
$header = array(t('Factor'), t('Weight'));
|
|
foreach (element_children($form['factors']) as $key) {
|
|
$row = array();
|
|
$row[] = $form['factors'][$key]['#title'];
|
|
unset($form['factors'][$key]['#title']);
|
|
$row[] = drupal_render($form['factors'][$key]);
|
|
$rows[] = $row;
|
|
}
|
|
$output .= theme('table', $header, $rows);
|
|
|
|
$output .= drupal_render($form);
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Menu callback; presents general node configuration options.
|
|
*/
|
|
function node_configure() {
|
|
// Only show rebuild button if there is 0 or more than 2 rows in node_access table, or if there are modules that implement node_grant.
|
|
if (db_result(db_query('SELECT COUNT(*) FROM {node_access}')) != 1 || count(module_implements('node_grants')) > 0) {
|
|
$status = '<p>'. t('If the site is experiencing problems with permissions to content, you may have to rebuild the permissions cache. Possible causes for permission problems are disabling modules or configuration changes to permissions. Rebuilding will remove all privileges to posts, and replace them with permissions based on the current modules and settings.') .'</p>';
|
|
$status .= '<p>'. t('Rebuilding may take some time if there is a lot of content or complex permission settings. After rebuilding has completed posts will automatically use the new permissions.') .'</p>';
|
|
|
|
$form['access'] = array('#type' => 'fieldset', '#title' => t('Node access status'));
|
|
$form['access']['status'] = array('#value' => $status);
|
|
$form['access']['rebuild'] = array('#type' => 'submit', '#value' => t('Rebuild permissions'));
|
|
}
|
|
|
|
$form['default_nodes_main'] = array(
|
|
'#type' => 'select', '#title' => t('Number of posts on main page'), '#default_value' => variable_get('default_nodes_main', 10),
|
|
'#options' => drupal_map_assoc(array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30)),
|
|
'#description' => t('The default maximum number of posts to display per page on overview pages such as the main page.')
|
|
);
|
|
$form['teaser_length'] = array(
|
|
'#type' => 'select', '#title' => t('Length of trimmed posts'), '#default_value' => variable_get('teaser_length', 600),
|
|
'#options' => array(0 => t('Unlimited'), 200 => t('200 characters'), 400 => t('400 characters'), 600 => t('600 characters'),
|
|
800 => t('800 characters'), 1000 => t('1000 characters'), 1200 => t('1200 characters'), 1400 => t('1400 characters'),
|
|
1600 => t('1600 characters'), 1800 => t('1800 characters'), 2000 => t('2000 characters')),
|
|
'#description' => t("The maximum number of characters used in the trimmed version of a post. Drupal will use this setting to determine at which offset long posts should be trimmed. The trimmed version of a post is typically used as a teaser when displaying the post on the main page, in XML feeds, etc. To disable teasers, set to 'Unlimited'. Note that this setting will only affect new or updated content and will not affect existing teasers.")
|
|
);
|
|
|
|
$form['node_preview'] = array(
|
|
'#type' => 'radios', '#title' => t('Preview post'), '#default_value' => variable_get('node_preview', 0),
|
|
'#options' => array(t('Optional'), t('Required')), '#description' => t('Must users preview posts before submitting?')
|
|
);
|
|
|
|
$form['#validate'] = array('node_configure_validate');
|
|
|
|
return system_settings_form($form);
|
|
}
|
|
|
|
/**
|
|
* Form validate callback.
|
|
*/
|
|
function node_configure_validate($form, &$form_state) {
|
|
if ($form_state['values']['op'] == t('Rebuild permissions')) {
|
|
drupal_goto('admin/content/node-settings/rebuild');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Menu callback: confirm rebuilding of permissions.
|
|
*/
|
|
function node_configure_rebuild_confirm() {
|
|
$options = array(
|
|
'description' => t('This will wipe all current node permissions and rebuild them based on current settings. Rebuilding the permissions may take a while so please be patient. This action cannot be undone.'),
|
|
'yes' => t('Rebuild permissions')
|
|
);
|
|
|
|
return confirm_form(array(), t('Are you sure you want to rebuild node permissions on the site?'),
|
|
'admin/content/node-settings', $options);
|
|
}
|
|
|
|
/**
|
|
* Handler for wipe confirmation
|
|
*/
|
|
function node_configure_rebuild_confirm_submit(&$form, $form, &$form_state) {
|
|
node_access_rebuild();
|
|
drupal_set_message(t('The node access table has been rebuilt.'));
|
|
$form_state['redirect'] = 'admin/content/node-settings';
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* Retrieve the comment mode for the given node ID (none, read, or read/write).
|
|
*/
|
|
function node_comment_mode($nid) {
|
|
static $comment_mode;
|
|
if (!isset($comment_mode[$nid])) {
|
|
$comment_mode[$nid] = db_result(db_query('SELECT comment FROM {node} WHERE nid = %d', $nid));
|
|
}
|
|
return $comment_mode[$nid];
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_link().
|
|
*/
|
|
function node_link($type, $node = NULL, $teaser = FALSE) {
|
|
$links = array();
|
|
|
|
if ($type == 'node') {
|
|
if ($teaser == 1 && $node->teaser && $node->readmore) {
|
|
$links['node_read_more'] = array(
|
|
'title' => t('Read more'),
|
|
'href' => "node/$node->nid",
|
|
'attributes' => array('title' => t('Read the rest of this posting.'))
|
|
);
|
|
}
|
|
}
|
|
|
|
return $links;
|
|
}
|
|
|
|
function _node_revision_access($node) {
|
|
return (user_access('view revisions') || user_access('administer nodes')) && node_access('view', $node) && db_result(db_query('SELECT COUNT(vid) FROM {node_revisions} WHERE nid = %d', $node->nid)) > 1;
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_menu().
|
|
*/
|
|
function node_menu() {
|
|
$items['admin/content'] = array(
|
|
'title' => 'Content management',
|
|
'description' => "Manage your site's content.",
|
|
'position' => 'left',
|
|
'weight' => -10,
|
|
'page callback' => 'system_admin_menu_block_page',
|
|
'access arguments' => array('administer nodes'),
|
|
'file' => 'system.admin.inc',
|
|
'file path' => drupal_get_path('module', 'system'),
|
|
);
|
|
|
|
$items['admin/content/node'] = array(
|
|
'title' => 'Content',
|
|
'description' => "View, edit, and delete your site's content.",
|
|
'page callback' => 'node_admin_content',
|
|
'access arguments' => array('administer nodes'),
|
|
);
|
|
|
|
$items['admin/content/node/overview'] = array(
|
|
'title' => 'List',
|
|
'type' => MENU_DEFAULT_LOCAL_TASK,
|
|
'weight' => -10,
|
|
);
|
|
|
|
if (module_exists('search')) {
|
|
$items['admin/content/search'] = array(
|
|
'title' => 'Search content',
|
|
'description' => 'Search content by keyword.',
|
|
'page callback' => 'node_admin_search',
|
|
'access arguments' => array('administer nodes'),
|
|
);
|
|
}
|
|
|
|
$items['admin/content/node-settings'] = array(
|
|
'title' => 'Post settings',
|
|
'description' => 'Control posting behavior, such as teaser length, requiring previews before posting, and the number of posts on the front page.',
|
|
'page callback' => 'drupal_get_form',
|
|
'page arguments' => array('node_configure'),
|
|
'access arguments' => array('administer nodes'),
|
|
);
|
|
$items['admin/content/node-settings/rebuild'] = array(
|
|
'title' => 'Rebuild permissions',
|
|
'page arguments' => array('node_configure_rebuild_confirm'),
|
|
'type' => MENU_CALLBACK,
|
|
);
|
|
|
|
$items['admin/content/types'] = array(
|
|
'title' => 'Content types',
|
|
'description' => 'Manage posts by content type, including default status, front page promotion, etc.',
|
|
'page callback' => 'node_overview_types',
|
|
'access arguments' => array('administer content types'),
|
|
);
|
|
$items['admin/content/types/list'] = array(
|
|
'title' => 'List',
|
|
'type' => MENU_DEFAULT_LOCAL_TASK,
|
|
'weight' => -10,
|
|
);
|
|
$items['admin/content/types/add'] = array(
|
|
'title' => 'Add content type',
|
|
'page callback' => 'drupal_get_form',
|
|
'page arguments' => array('node_type_form'),
|
|
'type' => MENU_LOCAL_TASK,
|
|
);
|
|
$items['node'] = array(
|
|
'title' => 'Content',
|
|
'page callback' => 'node_page_default',
|
|
'access arguments' => array('access content'),
|
|
'type' => MENU_MODIFIABLE_BY_ADMIN,
|
|
);
|
|
$items['node/add'] = array(
|
|
'title' => 'Create content',
|
|
'page callback' => 'system_admin_menu_block_page',
|
|
'access callback' => '_node_add_access',
|
|
'weight' => 1,
|
|
'file' => 'system.admin.inc',
|
|
'file path' => drupal_get_path('module', 'system'),
|
|
);
|
|
$items['rss.xml'] = array(
|
|
'title' => 'RSS feed',
|
|
'page callback' => 'node_feed',
|
|
'access arguments' => array('access content'),
|
|
'type' => MENU_CALLBACK,
|
|
);
|
|
foreach (node_get_types() as $type) {
|
|
if (function_exists($type->module .'_form')) {
|
|
$name = check_plain($type->name);
|
|
$type_url_str = str_replace('_', '-', $type->type);
|
|
$items['node/add/'. $type_url_str] = array(
|
|
'title' => drupal_ucfirst($name),
|
|
'page callback' => 'node_add',
|
|
'page arguments' => array(2),
|
|
'access callback' => 'node_access',
|
|
'access arguments' => array('create', $type->type),
|
|
'description' => $type->description,
|
|
);
|
|
$items['admin/content/types/'. $type_url_str] = array(
|
|
'title' => $type->name,
|
|
'page callback' => 'drupal_get_form',
|
|
'page arguments' => array('node_type_form', $type),
|
|
'type' => MENU_CALLBACK,
|
|
);
|
|
$items['admin/content/types/'. $type_url_str .'/delete'] = array(
|
|
'title' => 'Delete',
|
|
'page arguments' => array('node_type_delete_confirm', $type),
|
|
'type' => MENU_CALLBACK,
|
|
);
|
|
|
|
}
|
|
}
|
|
$items['node/%node'] = array(
|
|
'title' => 'View',
|
|
'page callback' => 'node_page_view',
|
|
'page arguments' => array(1),
|
|
'access callback' => 'node_access',
|
|
'access arguments' => array('view', 1),
|
|
'type' => MENU_CALLBACK);
|
|
$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' => 1,
|
|
'type' => MENU_LOCAL_TASK);
|
|
$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_CALLBACK);
|
|
$items['node/%node/revisions'] = array(
|
|
'title' => 'Revisions',
|
|
'page callback' => 'node_revisions',
|
|
'access callback' => '_node_revision_access',
|
|
'access arguments' => array(1),
|
|
'weight' => 2,
|
|
'type' => MENU_LOCAL_TASK,
|
|
);
|
|
return $items;
|
|
}
|
|
|
|
function node_init() {
|
|
if (arg(0) == 'admin' && arg(1) == 'content' && arg(2) == 'types') {
|
|
include_once './'. drupal_get_path('module', 'node') .'/content_types.inc';
|
|
}
|
|
drupal_add_css(drupal_get_path('module', 'node') .'/node.css');
|
|
}
|
|
|
|
function node_last_changed($nid) {
|
|
$node = db_fetch_object(db_query('SELECT changed FROM {node} WHERE nid = %d', $nid));
|
|
return ($node->changed);
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_node_operations().
|
|
*/
|
|
function node_node_operations() {
|
|
$operations = array(
|
|
'publish' => array(
|
|
'label' => t('Publish'),
|
|
'callback' => 'node_operations_publish',
|
|
),
|
|
'unpublish' => array(
|
|
'label' => t('Unpublish'),
|
|
'callback' => 'node_operations_unpublish',
|
|
),
|
|
'promote' => array(
|
|
'label' => t('Promote to front page'),
|
|
'callback' => 'node_operations_promote',
|
|
),
|
|
'demote' => array(
|
|
'label' => t('Demote from front page'),
|
|
'callback' => 'node_operations_demote',
|
|
),
|
|
'sticky' => array(
|
|
'label' => t('Make sticky'),
|
|
'callback' => 'node_operations_sticky',
|
|
),
|
|
'unsticky' => array(
|
|
'label' => t('Remove stickiness'),
|
|
'callback' => 'node_operations_unsticky',
|
|
),
|
|
'delete' => array(
|
|
'label' => t('Delete'),
|
|
),
|
|
);
|
|
return $operations;
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass publishing nodes.
|
|
*/
|
|
function node_operations_publish($nodes) {
|
|
db_query('UPDATE {node} SET status = 1 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass unpublishing nodes.
|
|
*/
|
|
function node_operations_unpublish($nodes) {
|
|
db_query('UPDATE {node} SET status = 0 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass promoting nodes.
|
|
*/
|
|
function node_operations_promote($nodes) {
|
|
db_query('UPDATE {node} SET status = 1, promote = 1 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass demoting nodes.
|
|
*/
|
|
function node_operations_demote($nodes) {
|
|
db_query('UPDATE {node} SET promote = 0 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass editing nodes to be sticky.
|
|
*/
|
|
function node_operations_sticky($nodes) {
|
|
db_query('UPDATE {node} SET status = 1, sticky = 1 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* Callback function for admin mass editing nodes to remove stickiness.
|
|
*/
|
|
function node_operations_unsticky($nodes) {
|
|
db_query('UPDATE {node} SET sticky = 0 WHERE nid IN(%s)', implode(',', $nodes));
|
|
}
|
|
|
|
/**
|
|
* List node administration filters that can be applied.
|
|
*/
|
|
function node_filters() {
|
|
// Regular filters
|
|
$filters['status'] = array('title' => t('status'),
|
|
'options' => array('status-1' => t('published'), 'status-0' => t('not published'),
|
|
'promote-1' => t('promoted'), 'promote-0' => t('not promoted'),
|
|
'sticky-1' => t('sticky'), 'sticky-0' => t('not sticky'))
|
|
);
|
|
// Include translation states if we have this module enabled
|
|
if (module_exists('translation')) {
|
|
$filters['status']['options'] += array('translate-0' => t('up to date translation'), 'translate-1' => t('outdated translation'));
|
|
}
|
|
|
|
$filters['type'] = array('title' => t('type'), 'options' => node_get_types('names'));
|
|
|
|
// The taxonomy filter
|
|
if ($taxonomy = module_invoke('taxonomy', 'form_all', 1)) {
|
|
$filters['category'] = array('title' => t('category'), 'options' => $taxonomy);
|
|
}
|
|
// Language filter if there is a list of languages
|
|
if ($languages = module_invoke('locale', 'language_list')) {
|
|
$languages = array('' => t('Language neutral')) + $languages;
|
|
$filters['language'] = array('title' => t('language'), 'options' => $languages);
|
|
}
|
|
return $filters;
|
|
}
|
|
|
|
/**
|
|
* Build query for node administration filters based on session.
|
|
*/
|
|
function node_build_filter_query() {
|
|
$filters = node_filters();
|
|
|
|
// Build query
|
|
$where = $args = array();
|
|
$join = '';
|
|
foreach ($_SESSION['node_overview_filter'] as $index => $filter) {
|
|
list($key, $value) = $filter;
|
|
switch ($key) {
|
|
case 'status':
|
|
// Note: no exploitable hole as $key/$value have already been checked when submitted
|
|
list($key, $value) = explode('-', $value, 2);
|
|
$where[] = 'n.'. $key .' = %d';
|
|
break;
|
|
case 'category':
|
|
$table = "tn$index";
|
|
$where[] = "$table.tid = %d";
|
|
$join .= "INNER JOIN {term_node} $table ON n.nid = $table.nid ";
|
|
break;
|
|
case 'type':
|
|
$where[] = "n.type = '%s'";
|
|
case 'language':
|
|
$where[] = "n.language = '%s'";
|
|
}
|
|
$args[] = $value;
|
|
}
|
|
$where = count($where) ? 'WHERE '. implode(' AND ', $where) : '';
|
|
|
|
return array('where' => $where, 'join' => $join, 'args' => $args);
|
|
}
|
|
|
|
/**
|
|
* Return form for node administration filters.
|
|
*/
|
|
function node_filter_form() {
|
|
$session = &$_SESSION['node_overview_filter'];
|
|
$session = is_array($session) ? $session : array();
|
|
$filters = node_filters();
|
|
|
|
$i = 0;
|
|
$form['filters'] = array('#type' => 'fieldset',
|
|
'#title' => t('Show only items where'),
|
|
'#theme' => 'node_filters',
|
|
);
|
|
foreach ($session as $filter) {
|
|
list($type, $value) = $filter;
|
|
if ($type == 'category') {
|
|
// Load term name from DB rather than search and parse options array.
|
|
$value = module_invoke('taxonomy', 'get_term', $value);
|
|
$value = $value->name;
|
|
}
|
|
else if ($type == 'language') {
|
|
$value = empty($value) ? t('Language neutral') : module_invoke('locale', 'language_name', $value);
|
|
}
|
|
else {
|
|
$value = $filters[$type]['options'][$value];
|
|
}
|
|
if ($i++) {
|
|
$form['filters']['current'][] = array('#value' => t('<em>and</em> where <strong>%a</strong> is <strong>%b</strong>', array('%a' => $filters[$type]['title'], '%b' => $value)));
|
|
}
|
|
else {
|
|
$form['filters']['current'][] = array('#value' => t('<strong>%a</strong> is <strong>%b</strong>', array('%a' => $filters[$type]['title'], '%b' => $value)));
|
|
}
|
|
if (in_array($type, array('type', 'language'))) {
|
|
// Remove the option if it is already being filtered on.
|
|
unset($filters[$type]);
|
|
}
|
|
}
|
|
|
|
foreach ($filters as $key => $filter) {
|
|
$names[$key] = $filter['title'];
|
|
$form['filters']['status'][$key] = array('#type' => 'select', '#options' => $filter['options']);
|
|
}
|
|
|
|
$form['filters']['filter'] = array('#type' => 'radios', '#options' => $names, '#default_value' => 'status');
|
|
$form['filters']['buttons']['submit'] = array('#type' => 'submit', '#value' => (count($session) ? t('Refine') : t('Filter')));
|
|
if (count($session)) {
|
|
$form['filters']['buttons']['undo'] = array('#type' => 'submit', '#value' => t('Undo'));
|
|
$form['filters']['buttons']['reset'] = array('#type' => 'submit', '#value' => t('Reset'));
|
|
}
|
|
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* Theme node administration filter form.
|
|
*/
|
|
function theme_node_filter_form($form) {
|
|
$output = '';
|
|
$output .= '<div id="node-admin-filter">';
|
|
$output .= drupal_render($form['filters']);
|
|
$output .= '</div>';
|
|
$output .= drupal_render($form);
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Theme node administration filter selector.
|
|
*/
|
|
function theme_node_filters($form) {
|
|
$output = '';
|
|
$output .= '<ul class="clear-block">';
|
|
if (!empty($form['current'])) {
|
|
foreach (element_children($form['current']) as $key) {
|
|
$output .= '<li>'. drupal_render($form['current'][$key]) .'</li>';
|
|
}
|
|
}
|
|
|
|
$output .= '<li><dl class="multiselect">'. (!empty($form['current']) ? '<dt><em>'. t('and') .'</em> '. t('where') .'</dt>' : '') .'<dd class="a">';
|
|
foreach (element_children($form['filter']) as $key) {
|
|
$output .= drupal_render($form['filter'][$key]);
|
|
}
|
|
$output .= '</dd>';
|
|
|
|
$output .= '<dt>'. t('is') .'</dt><dd class="b">';
|
|
|
|
foreach (element_children($form['status']) as $key) {
|
|
$output .= drupal_render($form['status'][$key]);
|
|
}
|
|
$output .= '</dd>';
|
|
|
|
$output .= '</dl>';
|
|
$output .= '<div class="container-inline" id="node-admin-buttons">'. drupal_render($form['buttons']) .'</div>';
|
|
$output .= '</li></ul>';
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Process result from node administration filter form.
|
|
*/
|
|
function node_filter_form_submit($form, &$form_state) {
|
|
$filters = node_filters();
|
|
switch ($form_state['values']['op']) {
|
|
case t('Filter'):
|
|
case t('Refine'):
|
|
if (isset($form_state['values']['filter'])) {
|
|
$filter = $form_state['values']['filter'];
|
|
|
|
// Flatten the options array to accommodate hierarchical/nested options.
|
|
$flat_options = form_options_flatten($filters[$filter]['options']);
|
|
|
|
if (isset($flat_options[$form_state['values'][$filter]])) {
|
|
$_SESSION['node_overview_filter'][] = array($filter, $form_state['values'][$filter]);
|
|
}
|
|
}
|
|
break;
|
|
case t('Undo'):
|
|
array_pop($_SESSION['node_overview_filter']);
|
|
break;
|
|
case t('Reset'):
|
|
$_SESSION['node_overview_filter'] = array();
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Submit the node administration update form.
|
|
*/
|
|
function node_admin_nodes_submit($form, &$form_state) {
|
|
$operations = module_invoke_all('node_operations');
|
|
$operation = $operations[$form_state['values']['operation']];
|
|
// Filter out unchecked nodes
|
|
$nodes = array_filter($form_state['values']['nodes']);
|
|
if ($function = $operation['callback']) {
|
|
// Add in callback arguments if present.
|
|
if (isset($operation['callback arguments'])) {
|
|
$args = array_merge(array($nodes), $operation['callback arguments']);
|
|
}
|
|
else {
|
|
$args = array($nodes);
|
|
}
|
|
call_user_func_array($function, $args);
|
|
|
|
cache_clear_all();
|
|
drupal_set_message(t('The update has been performed.'));
|
|
}
|
|
}
|
|
|
|
function node_admin_nodes_validate($form, &$form_state) {
|
|
$nodes = array_filter($form_state['values']['nodes']);
|
|
if (count($nodes) == 0) {
|
|
form_set_error('', t('No items selected.'));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Menu callback: content administration.
|
|
*/
|
|
function node_admin_content() {
|
|
$output = drupal_get_form('node_filter_form');
|
|
|
|
if (isset($_POST['operation']) && ($_POST['operation'] == 'delete') && $_POST['nodes']) {
|
|
return drupal_get_form('node_multiple_delete_confirm');
|
|
}
|
|
// Call the form first, to allow for the form_values array to be populated.
|
|
$output .= drupal_get_form('node_admin_nodes');
|
|
|
|
return $output;
|
|
}
|
|
|
|
function node_admin_nodes() {
|
|
$filter = node_build_filter_query();
|
|
|
|
$result = pager_query(db_rewrite_sql('SELECT n.*, u.name FROM {node} n '. $filter['join'] .' INNER JOIN {users} u ON n.uid = u.uid '. $filter['where'] .' ORDER BY n.changed DESC'), 50, 0, NULL, $filter['args']);
|
|
|
|
// Enable language column if locale is enabled or if we have any node with language
|
|
$count = db_result(db_query("SELECT COUNT(*) FROM {node} n WHERE language != ''"));
|
|
$multilanguage = (module_exists('locale') || $count);
|
|
|
|
$form['options'] = array('#type' => 'fieldset',
|
|
'#title' => t('Update options'),
|
|
'#prefix' => '<div class="container-inline">',
|
|
'#suffix' => '</div>',
|
|
);
|
|
$options = array();
|
|
foreach (module_invoke_all('node_operations') as $operation => $array) {
|
|
$options[$operation] = $array['label'];
|
|
}
|
|
$form['options']['operation'] = array('#type' => 'select', '#options' => $options, '#default_value' => 'approve');
|
|
$form['options']['submit'] = array('#type' => 'submit', '#value' => t('Update'));
|
|
|
|
$destination = drupal_get_destination();
|
|
$nodes = array();
|
|
while ($node = db_fetch_object($result)) {
|
|
$nodes[$node->nid] = '';
|
|
$form['title'][$node->nid] = array('#value' => l($node->title, 'node/'. $node->nid) .' '. theme('mark', node_mark($node->nid, $node->changed)));
|
|
$form['name'][$node->nid] = array('#value' => node_get_types('name', $node));
|
|
$form['username'][$node->nid] = array('#value' => theme('username', $node));
|
|
$form['status'][$node->nid] = array('#value' => ($node->status ? t('published') : t('not published')));
|
|
if ($multilanguage) {
|
|
$form['language'][$node->nid] = array('#value' => empty($node->language) ? t('Language neutral') : module_invoke('locale', 'language_name', $node->language));
|
|
}
|
|
$form['operations'][$node->nid] = array('#value' => l(t('edit'), 'node/'. $node->nid .'/edit', array('query' => $destination)));
|
|
}
|
|
$form['nodes'] = array('#type' => 'checkboxes', '#options' => $nodes);
|
|
$form['pager'] = array('#value' => theme('pager', NULL, 50, 0));
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* Theme node administration overview.
|
|
*/
|
|
function theme_node_admin_nodes($form) {
|
|
// Overview table:
|
|
$header = array(theme('table_select_header_cell'), t('Title'), t('Type'), t('Author'), t('Status'));
|
|
if (isset($form['language'])) {
|
|
$header[] = t('Language');
|
|
}
|
|
$header[] = t('Operations');
|
|
$output = '';
|
|
|
|
$output .= drupal_render($form['options']);
|
|
if (isset($form['title']) && is_array($form['title'])) {
|
|
foreach (element_children($form['title']) as $key) {
|
|
$row = array();
|
|
$row[] = drupal_render($form['nodes'][$key]);
|
|
$row[] = drupal_render($form['title'][$key]);
|
|
$row[] = drupal_render($form['name'][$key]);
|
|
$row[] = drupal_render($form['username'][$key]);
|
|
$row[] = drupal_render($form['status'][$key]);
|
|
if (isset($form['language'])) {
|
|
$row[] = drupal_render($form['language'][$key]);
|
|
}
|
|
$row[] = drupal_render($form['operations'][$key]);
|
|
$rows[] = $row;
|
|
}
|
|
|
|
}
|
|
else {
|
|
$rows[] = array(array('data' => t('No posts available.'), 'colspan' => '6'));
|
|
}
|
|
|
|
$output .= theme('table', $header, $rows);
|
|
if ($form['pager']['#value']) {
|
|
$output .= drupal_render($form['pager']);
|
|
}
|
|
|
|
$output .= drupal_render($form);
|
|
|
|
return $output;
|
|
}
|
|
|
|
function node_multiple_delete_confirm(&$form_state) {
|
|
$edit = $form_state['post'];
|
|
|
|
$form['nodes']['#tree'] = TRUE;
|
|
$form['prefix'] = array('#value' => '<ul>');
|
|
|
|
// array_filter() returns only elements with TRUE values.
|
|
$nids = array_filter($edit['nodes']);
|
|
$nodes = db_query('SELECT nid, title, type FROM {node} WHERE nid IN(%s)', implode(', ', $nids));
|
|
while ($node = db_fetch_object($nodes)) {
|
|
|
|
// This is a placeholder -- preserves proper ordering in the confirm form.
|
|
$form["node_$node->nid"] = array();
|
|
|
|
// Start a new package for each node.
|
|
drupal_delete_initiate('node', $node->nid);
|
|
|
|
// Add the confirm form piece for this node.
|
|
drupal_delete_add_form_elements(
|
|
array(
|
|
"node_$node->nid" => array(
|
|
'#value' => check_plain($node->title),
|
|
'#prefix' => '<li>',
|
|
'#suffix' => "</li>\n",
|
|
),
|
|
'nodes' => array(
|
|
"node_$node->nid" => array(
|
|
'#type' => 'hidden',
|
|
'#value' => $node->nid,
|
|
)
|
|
)
|
|
)
|
|
);
|
|
drupal_delete_add_callback(array('node_delete_post' => array($node->nid, $node->title, $node->type)));
|
|
node_delete($node->nid);
|
|
}
|
|
$form['suffix'] = array('#value' => '</ul>');
|
|
|
|
$form['operation'] = array(
|
|
'#type' => 'hidden',
|
|
'#value' => 'delete',
|
|
);
|
|
|
|
// New package for the main admin callback.
|
|
drupal_delete_initiate('node', 'admin');
|
|
|
|
// Add the main callback for the mass deletion last.
|
|
drupal_delete_add_callback(array('node_multiple_delete_confirm_post' => array()));
|
|
|
|
return drupal_delete_confirm(
|
|
array(
|
|
'form' => $form,
|
|
'question' => t('Are you sure you want to delete these items?'),
|
|
'destination' => 'admin/content/node',
|
|
'yes' => t('Delete all'),
|
|
)
|
|
);
|
|
}
|
|
|
|
function node_multiple_delete_confirm_post() {
|
|
// Clear the cache so an anonymous poster can see the nodes being deleted.
|
|
cache_clear_all();
|
|
drupal_set_message(t('The items have been deleted.'));
|
|
}
|
|
|
|
/**
|
|
* Generate an overview table of older revisions of a node.
|
|
*/
|
|
function node_revision_overview($node) {
|
|
drupal_set_title(t('Revisions for %title', array('%title' => $node->title)));
|
|
|
|
$header = array(t('Revision'), array('data' => t('Operations'), 'colspan' => 2));
|
|
|
|
$revisions = node_revision_list($node);
|
|
|
|
$rows = array();
|
|
$revert_permission = FALSE;
|
|
if ((user_access('revert revisions') || user_access('administer nodes')) && node_access('update', $node)) {
|
|
$revert_permission = TRUE;
|
|
}
|
|
$delete_permission = FALSE;
|
|
if (user_access('administer nodes')) {
|
|
$delete_permission = TRUE;
|
|
}
|
|
foreach ($revisions as $revision) {
|
|
$row = array();
|
|
$operations = array();
|
|
|
|
if ($revision->current_vid > 0) {
|
|
$row[] = array('data' => t('!date by !username', array('!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid"), '!username' => theme('username', $revision)))
|
|
. (($revision->log != '') ? '<p class="revision-log">'. filter_xss($revision->log) .'</p>' : ''),
|
|
'class' => 'revision-current');
|
|
$operations[] = array('data' => theme('placeholder', t('current revision')), 'class' => 'revision-current', 'colspan' => 2);
|
|
}
|
|
else {
|
|
$row[] = t('!date by !username', array('!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid/revisions/$revision->vid/view"), '!username' => theme('username', $revision)))
|
|
. (($revision->log != '') ? '<p class="revision-log">'. filter_xss($revision->log) .'</p>' : '');
|
|
if ($revert_permission) {
|
|
$operations[] = l(t('revert'), "node/$node->nid/revisions/$revision->vid/revert");
|
|
}
|
|
if ($delete_permission) {
|
|
$operations[] = l(t('delete'), "node/$node->nid/revisions/$revision->vid/delete");
|
|
}
|
|
}
|
|
$rows[] = array_merge($row, $operations);
|
|
}
|
|
|
|
return theme('table', $header, $rows);
|
|
}
|
|
|
|
/**
|
|
* Revert to the revision with the specified revision number. A node and nodeapi "update" event is triggered
|
|
* (via the node_save() call) when a revision is reverted.
|
|
*/
|
|
function node_revision_revert($nid, $revision) {
|
|
global $user;
|
|
|
|
$node = node_load($nid, $revision);
|
|
if ((user_access('revert revisions') || user_access('administer nodes')) && node_access('update', $node)) {
|
|
if ($node->vid) {
|
|
$node->revision = 1;
|
|
$node->log = t('Copy of the revision from %date.', array('%date' => format_date($node->revision_timestamp)));
|
|
if (module_exists('taxonomy')) {
|
|
$node->taxonomy = array_keys($node->taxonomy);
|
|
}
|
|
|
|
node_save($node);
|
|
|
|
drupal_set_message(t('%title has been reverted back to the revision from %revision-date', array('%revision-date' => format_date($node->revision_timestamp), '%title' => $node->title)));
|
|
watchdog('content', '@type: reverted %title revision %revision.', array('@type' => $node->type, '%title' => $node->title, '%revision' => $revision));
|
|
}
|
|
else {
|
|
drupal_set_message(t('You tried to revert to an invalid revision.'), 'error');
|
|
}
|
|
drupal_goto('node/'. $nid .'/revisions');
|
|
}
|
|
drupal_access_denied();
|
|
}
|
|
|
|
/**
|
|
* Delete the revision with specified revision number. A "delete revision" nodeapi event is invoked when a
|
|
* revision is deleted.
|
|
*/
|
|
function node_revision_delete($nid, $revision) {
|
|
$node = node_load($nid);
|
|
|
|
if (user_access('administer nodes') && node_access('delete', $node)) {
|
|
|
|
// Don't delete the current revision
|
|
if ($revision != $node->vid) {
|
|
$node = node_load($nid, $revision);
|
|
|
|
drupal_delete_initiate('node_revision', $revision);
|
|
drupal_delete_add_callback(array('node_revision_delete_post' => array($node, $revision)));
|
|
drupal_delete_add_query('DELETE FROM {node_revisions} WHERE vid = %d', $revision);
|
|
node_invoke_nodeapi($node, 'delete revision');
|
|
|
|
// Back to revisions page if multiple revisions exist.
|
|
if (db_result(db_query('SELECT COUNT(vid) FROM {node_revisions} WHERE nid = %d', $node->nid)) > 2) {
|
|
$destination = "node/$node->nid/revisions";
|
|
}
|
|
else {
|
|
$destination = "node/$node->nid";
|
|
}
|
|
drupal_delete_execute($destination);
|
|
}
|
|
else {
|
|
drupal_set_message(t('Deletion failed. You tried to delete the current revision.'));
|
|
}
|
|
}
|
|
else {
|
|
drupal_access_denied();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Post revision deletion opertations.
|
|
*/
|
|
function node_revision_delete_post($node, $revision) {
|
|
|
|
drupal_set_message(t('Deleted %title revision %revision.', array('%title' => $node->title, '%revision' => $revision)));
|
|
watchdog('content', '@type: deleted %title revision %revision.', array('@type' => t($node->type), '%title' => $node->title, '%revision' => $revision));
|
|
}
|
|
|
|
/**
|
|
* Return a list of all the existing revision numbers.
|
|
*/
|
|
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_revisions} r LEFT JOIN {node} n ON n.vid = r.vid INNER JOIN {users} u ON u.uid = r.uid WHERE r.nid = %d ORDER BY r.timestamp DESC', $node->nid);
|
|
while ($revision = db_fetch_object($result)) {
|
|
$revisions[$revision->vid] = $revision;
|
|
}
|
|
|
|
return $revisions;
|
|
}
|
|
|
|
function node_admin_search() {
|
|
$keys = isset($_POST['keys']) ? $_POST['keys'] : NULL;
|
|
return drupal_get_form('search_form', url('admin/content/search'), $keys, 'node') . search_data($keys, 'node');
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_block().
|
|
*/
|
|
function node_block($op = 'list', $delta = 0) {
|
|
if ($op == 'list') {
|
|
$blocks[0]['info'] = t('Syndicate');
|
|
return $blocks;
|
|
}
|
|
else if ($op == 'view') {
|
|
$block['subject'] = t('Syndicate');
|
|
$block['content'] = theme('feed_icon', url('rss.xml'), t('Syndicate'));
|
|
|
|
return $block;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A generic function for generating RSS feeds from a set of nodes.
|
|
*
|
|
* @param $nodes
|
|
* An object as returned by db_query() which contains the nid field.
|
|
* @param $channel
|
|
* An associative array containing title, link, description and other keys.
|
|
* The link should be an absolute URL.
|
|
*/
|
|
function node_feed($nodes = 0, $channel = array()) {
|
|
global $base_url, $language;
|
|
|
|
if (!$nodes) {
|
|
$nodes = db_query_range(db_rewrite_sql('SELECT n.nid, n.created FROM {node} n WHERE n.promote = 1 AND n.status = 1 ORDER BY n.created DESC'), 0, variable_get('feed_default_items', 10));
|
|
}
|
|
|
|
$item_length = variable_get('feed_item_length', 'teaser');
|
|
$namespaces = array('xmlns:dc="http://purl.org/dc/elements/1.1/"');
|
|
|
|
$items = '';
|
|
while ($node = db_fetch_object($nodes)) {
|
|
// Load the specified node:
|
|
$item = node_load($node->nid);
|
|
$link = url("node/$node->nid", array('absolute' => TRUE));
|
|
|
|
if ($item_length != 'title') {
|
|
$teaser = ($item_length == 'teaser') ? TRUE : FALSE;
|
|
|
|
// Filter and prepare node teaser
|
|
if (node_hook($item, 'view')) {
|
|
$item = node_invoke($item, 'view', $teaser, FALSE);
|
|
}
|
|
else {
|
|
$item = node_prepare($item, $teaser);
|
|
}
|
|
|
|
// Allow modules to change $node->teaser before viewing.
|
|
node_invoke_nodeapi($item, 'view', $teaser, FALSE);
|
|
}
|
|
|
|
// Allow modules to add additional item fields and/or modify $item
|
|
$extra = node_invoke_nodeapi($item, 'rss item');
|
|
$extra = array_merge($extra, array(array('key' => 'pubDate', 'value' => date('r', $item->created)), array('key' => 'dc:creator', 'value' => $item->name), array('key' => 'guid', 'value' => $item->nid .' at '. $base_url, 'attributes' => array('isPermaLink' => 'false'))));
|
|
foreach ($extra as $element) {
|
|
if (isset($element['namespace'])) {
|
|
$namespaces = array_merge($namespaces, $element['namespace']);
|
|
}
|
|
}
|
|
|
|
// Prepare the item description
|
|
switch ($item_length) {
|
|
case 'fulltext':
|
|
$item_text = $item->body;
|
|
break;
|
|
case 'teaser':
|
|
$item_text = $item->teaser;
|
|
if ($item->readmore) {
|
|
$item_text .= '<p>'. l(t('read more'), 'node/'. $item->nid, array('absolute' => TRUE)) .'</p>';
|
|
}
|
|
break;
|
|
case 'title':
|
|
$item_text = '';
|
|
break;
|
|
}
|
|
|
|
$items .= format_rss_item($item->title, $link, $item_text, $extra);
|
|
}
|
|
|
|
$channel_defaults = array(
|
|
'version' => '2.0',
|
|
'title' => variable_get('site_name', 'Drupal') .' - '. variable_get('site_slogan', ''),
|
|
'link' => $base_url,
|
|
'description' => variable_get('site_mission', ''),
|
|
'language' => $language->language
|
|
);
|
|
$channel = array_merge($channel_defaults, $channel);
|
|
|
|
$output = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
|
|
$output .= "<rss version=\"". $channel["version"] ."\" xml:base=\"". $base_url ."\" ". implode(' ', $namespaces) .">\n";
|
|
$output .= format_rss_channel($channel['title'], $channel['link'], $channel['description'], $items, $channel['language']);
|
|
$output .= "</rss>\n";
|
|
|
|
drupal_set_header('Content-Type: application/rss+xml; charset=utf-8');
|
|
print $output;
|
|
}
|
|
|
|
/**
|
|
* Prepare node for save and allow modules to make changes.
|
|
*/
|
|
function node_submit($node) {
|
|
global $user;
|
|
|
|
// Convert the node to an object, if necessary.
|
|
$node = (object)$node;
|
|
|
|
// Auto-generate the teaser, but only if it hasn't been set (e.g. by a
|
|
// module-provided 'teaser' form item).
|
|
if (!isset($node->teaser)) {
|
|
if (isset($node->body)) {
|
|
$node->teaser = node_teaser($node->body, isset($node->format) ? $node->format : NULL);
|
|
// Chop off the teaser from the body if needed.
|
|
if (!$node->teaser_include && $node->teaser == substr($node->body, 0, strlen($node->teaser))) {
|
|
$node->body = substr($node->body, strlen($node->teaser));
|
|
}
|
|
}
|
|
else {
|
|
$node->teaser = '';
|
|
}
|
|
}
|
|
|
|
if (user_access('administer nodes')) {
|
|
// Populate the "authored by" field.
|
|
if ($account = user_load(array('name' => $node->name))) {
|
|
$node->uid = $account->uid;
|
|
}
|
|
else {
|
|
$node->uid = 0;
|
|
}
|
|
|
|
$node->created = $node->date ? strtotime($node->date) : NULL;
|
|
}
|
|
|
|
$node->validated = TRUE;
|
|
|
|
return $node;
|
|
}
|
|
|
|
/**
|
|
* Perform validation checks on the given node.
|
|
*/
|
|
function node_validate($node, $form = array()) {
|
|
// Convert the node to an object, if necessary.
|
|
$node = (object)$node;
|
|
$type = node_get_types('type', $node);
|
|
|
|
// Make sure the body has the minimum number of words.
|
|
// todo use a better word counting algorithm that will work in other languages
|
|
if (!empty($type->min_word_count) && isset($node->body) && count(explode(' ', $node->body)) < $type->min_word_count) {
|
|
form_set_error('body', t('The body of your @type is too short. You need at least %words words.', array('%words' => $type->min_word_count, '@type' => $type->name)));
|
|
}
|
|
|
|
if (isset($node->nid) && (node_last_changed($node->nid) > $node->changed)) {
|
|
form_set_error('changed', t('This content has been modified by another user, changes cannot be saved.'));
|
|
}
|
|
|
|
if (user_access('administer nodes')) {
|
|
// Validate the "authored by" field.
|
|
if (!empty($node->name) && !($account = user_load(array('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. As of PHP 5.1.0, strtotime returns FALSE instead of -1 upon failure.
|
|
if (!empty($node->date) && strtotime($node->date) <= 0) {
|
|
form_set_error('date', t('You have to specify a valid date.'));
|
|
}
|
|
}
|
|
|
|
// Do node-type-specific validation checks.
|
|
node_invoke($node, 'validate', $form);
|
|
node_invoke_nodeapi($node, 'validate', $form);
|
|
}
|
|
|
|
function node_form_validate($form, &$form_state) {
|
|
node_validate($form_state['values'], $form);
|
|
}
|
|
|
|
function node_object_prepare(&$node) {
|
|
if (user_access('administer nodes')) {
|
|
// Set up default values, if required.
|
|
if (!isset($node->created)) {
|
|
$node->created = time();
|
|
}
|
|
|
|
if (!isset($node->date)) {
|
|
$node->date = format_date($node->created, 'custom', 'Y-m-d H:i:s O');
|
|
}
|
|
}
|
|
|
|
$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)) {
|
|
foreach (array('status', 'promote', 'sticky') as $key) {
|
|
$node->$key = in_array($key, $node_options);
|
|
}
|
|
global $user;
|
|
$node->uid = $user->uid;
|
|
}
|
|
// Always use the default revision setting.
|
|
$node->revision = in_array('revision', $node_options);
|
|
|
|
node_invoke($node, 'prepare');
|
|
node_invoke_nodeapi($node, 'prepare');
|
|
}
|
|
|
|
/**
|
|
* Generate the node add/edit form array.
|
|
*/
|
|
function node_form(&$form_state, $node) {
|
|
global $user;
|
|
|
|
if (isset($form_state['node'])) {
|
|
$node = $form_state['node'] + (array)$node;
|
|
}
|
|
if (isset($form_state['node_preview'])) {
|
|
$form['#prefix'] = $form_state['node_preview'];
|
|
}
|
|
$node = (object)$node;
|
|
foreach (array('body', 'title', 'format') as $key) {
|
|
if (!isset($node->$key)) {
|
|
$node->$key = NULL;
|
|
}
|
|
}
|
|
node_object_prepare($node);
|
|
|
|
// Set the id of the top-level form tag
|
|
$form['#id'] = 'node-form';
|
|
|
|
/**
|
|
* Basic node information.
|
|
* These elements are just values so they are not even sent to the client.
|
|
*/
|
|
foreach (array('nid', 'vid', 'uid', 'created', 'type', 'language') as $key) {
|
|
$form[$key] = array('#type' => 'value', '#value' => isset($node->$key) ? $node->$key : NULL);
|
|
}
|
|
|
|
// Changed must be sent to the client, for later overwrite error checking.
|
|
$form['changed'] = array('#type' => 'hidden', '#default_value' => isset($node->changed) ? $node->changed : NULL);
|
|
// Get the node-specific bits.
|
|
if ($extra = node_invoke($node, 'form', $form_state)) {
|
|
$form = array_merge_recursive($form, $extra);
|
|
}
|
|
if (!isset($form['title']['#weight'])) {
|
|
$form['title']['#weight'] = -5;
|
|
}
|
|
|
|
$form['#node'] = $node;
|
|
|
|
// Add a log field if the "Create new revision" option is checked, or if the
|
|
// current user has the ability to check that option.
|
|
if ($node->revision || user_access('administer nodes')) {
|
|
$form['revision_information'] = array(
|
|
'#type' => 'fieldset',
|
|
'#title' => t('Revision information'),
|
|
'#collapsible' => TRUE,
|
|
// Collapsed by default when "Create new revision" is unchecked
|
|
'#collapsed' => !$node->revision,
|
|
'#weight' => 20,
|
|
);
|
|
$form['revision_information']['revision'] = array(
|
|
'#access' => user_access('administer nodes'),
|
|
'#type' => 'checkbox',
|
|
'#title' => t('Create new revision'),
|
|
'#default_value' => $node->revision,
|
|
);
|
|
$form['revision_information']['log'] = array(
|
|
'#type' => 'textarea',
|
|
'#title' => t('Log message'),
|
|
'#rows' => 2,
|
|
'#description' => t('An explanation of the additions or updates being made to help other authors understand your motivations.'),
|
|
);
|
|
}
|
|
|
|
// Node author information for administrators
|
|
$form['author'] = array(
|
|
'#type' => 'fieldset',
|
|
'#access' => user_access('administer nodes'),
|
|
'#title' => t('Authoring information'),
|
|
'#collapsible' => TRUE,
|
|
'#collapsed' => TRUE,
|
|
'#weight' => 20,
|
|
);
|
|
$form['author']['name'] = array('#type' => 'textfield', '#title' => t('Authored by'), '#maxlength' => 60, '#autocomplete_path' => 'user/autocomplete', '#default_value' => $node->name ? $node->name : '', '#weight' => -1, '#description' => t('Leave blank for %anonymous.', array('%anonymous' => variable_get('anonymous', t('Anonymous')))));
|
|
$form['author']['date'] = array('#type' => 'textfield', '#title' => t('Authored on'), '#maxlength' => 25, '#description' => t('Format: %time. Leave blank to use the time of form submission.', array('%time' => $node->date)));
|
|
|
|
if (isset($node->nid)) {
|
|
$form['author']['date']['#default_value'] = $node->date;
|
|
}
|
|
|
|
// Node options for administrators
|
|
$form['options'] = array(
|
|
'#type' => 'fieldset',
|
|
'#access' => user_access('administer nodes'),
|
|
'#title' => t('Publishing options'),
|
|
'#collapsible' => TRUE,
|
|
'#collapsed' => TRUE,
|
|
'#weight' => 25,
|
|
);
|
|
$form['options']['status'] = array('#type' => 'checkbox', '#title' => t('Published'), '#default_value' => $node->status);
|
|
$form['options']['promote'] = array('#type' => 'checkbox', '#title' => t('Promoted to front page'), '#default_value' => $node->promote);
|
|
$form['options']['sticky'] = array('#type' => 'checkbox', '#title' => t('Sticky at top of lists'), '#default_value' => $node->sticky);
|
|
|
|
// These values are used when the user has no administrator access.
|
|
foreach (array('uid', 'created') as $key) {
|
|
$form[$key] = array('#type' => 'value', '#value' => $node->$key);
|
|
}
|
|
|
|
// Add the buttons.
|
|
$form['buttons'] = array();
|
|
$form['buttons']['preview'] = array(
|
|
'#type' => 'submit',
|
|
'#value' => t('Preview'),
|
|
'#weight' => 5,
|
|
'#submit' => array('node_form_build_preview'),
|
|
);
|
|
$form['buttons']['submit'] = array(
|
|
'#type' => 'submit',
|
|
'#value' => t('Submit'),
|
|
'#weight' => 10,
|
|
'#submit' => array('node_form_submit'),
|
|
);
|
|
if (!empty($node->nid) && node_access('delete', $node)) {
|
|
$form['buttons']['delete'] = array('#type' => 'button', '#value' => t('Delete'), '#weight' => 15);
|
|
}
|
|
$form['#validate'][] = 'node_form_validate';
|
|
$form['#theme'] = 'node_form';
|
|
return $form;
|
|
}
|
|
|
|
function node_form_build_preview($form, &$form_state) {
|
|
// We do not want to execute button level handlers, we want the form level
|
|
// handlers to go in and change the submitted values.
|
|
unset($form_state['submit_handlers']);
|
|
form_execute_handlers('submit', $form, $form_state);
|
|
|
|
$form_state['node_preview'] = node_preview((object)$form_state['values']);
|
|
$form_state['rebuild'] = TRUE;
|
|
$form_state['node'] = $form_state['values'];
|
|
}
|
|
|
|
function theme_node_form($form) {
|
|
$output = "\n<div class=\"node-form\">\n";
|
|
|
|
// Admin form fields and submit buttons must be rendered first, because
|
|
// they need to go to the bottom of the form, and so should not be part of
|
|
// the catch-all call to drupal_render().
|
|
$admin = '';
|
|
if (isset($form['author'])) {
|
|
$admin .= " <div class=\"authored\">\n";
|
|
$admin .= drupal_render($form['author']);
|
|
$admin .= " </div>\n";
|
|
}
|
|
if (isset($form['options'])) {
|
|
$admin .= " <div class=\"options\">\n";
|
|
$admin .= drupal_render($form['options']);
|
|
$admin .= " </div>\n";
|
|
}
|
|
$buttons = drupal_render($form['buttons']);
|
|
|
|
// Everything else gets rendered here, and is displayed before the admin form
|
|
// field and the submit buttons.
|
|
$output .= " <div class=\"standard\">\n";
|
|
$output .= drupal_render($form);
|
|
$output .= " </div>\n";
|
|
|
|
if (!empty($admin)) {
|
|
$output .= " <div class=\"admin\">\n";
|
|
$output .= $admin;
|
|
$output .= " </div>\n";
|
|
}
|
|
$output .= $buttons;
|
|
$output .= "</div>\n";
|
|
|
|
return $output;
|
|
}
|
|
|
|
function _node_add_access() {
|
|
$types = node_get_types();
|
|
foreach ($types as $type) {
|
|
if (function_exists($type->module .'_form') && node_access('create', $type->type)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Present a node submission form or a set of links to such forms.
|
|
*/
|
|
function node_add($type) {
|
|
global $user;
|
|
|
|
$types = node_get_types();
|
|
$type = isset($type) ? str_replace('-', '_', $type) : NULL;
|
|
// If a node type has been specified, validate its existence.
|
|
if (isset($types[$type]) && node_access('create', $type)) {
|
|
// Initialize settings:
|
|
$node = array('uid' => $user->uid, 'name' => $user->name, 'type' => $type, 'language' => '');
|
|
|
|
drupal_set_title(t('Submit @name', array('@name' => $types[$type]->name)));
|
|
$output = drupal_get_form($type .'_node_form', $node);
|
|
}
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Generate a node preview.
|
|
*/
|
|
function node_preview($node) {
|
|
if (node_access('create', $node) || node_access('update', $node)) {
|
|
// Load the user's name when needed:
|
|
if (isset($node->name)) {
|
|
// The use of isset() is mandatory in the context of user IDs, because
|
|
// user ID 0 denotes the anonymous user.
|
|
if ($user = user_load(array('name' => $node->name))) {
|
|
$node->uid = $user->uid;
|
|
$node->picture = $user->picture;
|
|
}
|
|
else {
|
|
$node->uid = 0; // anonymous user
|
|
}
|
|
}
|
|
else if ($node->uid) {
|
|
$user = user_load(array('uid' => $node->uid));
|
|
$node->name = $user->name;
|
|
$node->picture = $user->picture;
|
|
}
|
|
|
|
// Set the timestamps when needed:
|
|
if ($node->date) {
|
|
$node->created = strtotime($node->date);
|
|
}
|
|
$node->changed = time();
|
|
|
|
// Extract a teaser, if it hasn't been set (e.g. by a module-provided
|
|
// 'teaser' form item).
|
|
if (!isset($node->teaser)) {
|
|
$node->teaser = empty($node->body) ? '' : node_teaser($node->body, $node->format);
|
|
// Chop off the teaser from the body if needed.
|
|
if (!$node->teaser_include && $node->teaser == substr($node->body, 0, strlen($node->teaser))) {
|
|
$node->body = substr($node->body, strlen($node->teaser));
|
|
}
|
|
}
|
|
|
|
// Display a preview of the node:
|
|
// Previewing alters $node so it needs to be cloned.
|
|
if (!form_get_errors()) {
|
|
$cloned_node = drupal_clone($node);
|
|
$cloned_node->in_preview = TRUE;
|
|
$output = theme('node_preview', $cloned_node);
|
|
}
|
|
drupal_set_title(t('Preview'));
|
|
drupal_set_breadcrumb(array(l(t('Home'), NULL), l(t('Create content'), 'node/add'), l(t('Submit @name', array('@name' => node_get_types('name', $node))), 'node/add/'. $node->type)));
|
|
|
|
return $output;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Display a node preview for display during node creation and editing.
|
|
*
|
|
* @param $node
|
|
* The node object which is being previewed.
|
|
*/
|
|
function theme_node_preview($node) {
|
|
$output = '<div class="preview">';
|
|
if (!empty($node->teaser) && !empty($node->body) && $node->teaser != $node->body) {
|
|
drupal_set_message(t('The trimmed version of your post shows what your post looks like when promoted to the main page or when exported for syndication.<span class="no-js"> You can insert the delimiter "<!--break-->" (without the quotes) to fine-tune where your post gets split.</span>'));
|
|
$output .= '<h3>'. t('Preview trimmed version') .'</h3>';
|
|
$output .= node_view(drupal_clone($node), 1, FALSE, 0);
|
|
$output .= '<h3>'. t('Preview full version') .'</h3>';
|
|
$output .= node_view($node, 0, FALSE, 0);
|
|
}
|
|
else {
|
|
$output .= node_view($node, 0, FALSE, 0);
|
|
}
|
|
$output .= "</div>\n";
|
|
|
|
return $output;
|
|
}
|
|
|
|
function theme_node_log_message($log) {
|
|
return '<div class="log"><div class="title">'. t('Log') .':</div>'. $log .'</div>';
|
|
}
|
|
|
|
function node_form_submit($form, &$form_state) {
|
|
global $user;
|
|
|
|
// We do not want to execute button level handlers, we want the form level
|
|
// handlers to go in and change the submitted values.
|
|
unset($form_state['submit_handlers']);
|
|
form_execute_handlers('submit', $form, $form_state);
|
|
|
|
// Normally, we don't want people doing anything even remotely like this.
|
|
// For the node submission form, however, it's necessary. Submit handlers
|
|
// alter the $form_state['values'] collection to determine what ultimately makes it
|
|
// into the final $node object.
|
|
$form_state['values'] = $form_state['values'];
|
|
|
|
// Fix up the node when required:
|
|
$node = node_submit($form_state['values']);
|
|
|
|
// Prepare the node's body:
|
|
if ($node->nid) {
|
|
node_save($node);
|
|
watchdog('content', '@type: updated %title.', array('@type' => $node->type, '%title' => $node->title), WATCHDOG_NOTICE, l(t('view'), 'node/'. $node->nid));
|
|
drupal_set_message(t('The %post has been updated.', array('%post' => node_get_types('name', $node))));
|
|
}
|
|
else {
|
|
node_save($node);
|
|
watchdog('content', '@type: added %title.', array('@type' => $node->type, '%title' => $node->title), WATCHDOG_NOTICE, l(t('view'), "node/$node->nid"));
|
|
drupal_set_message(t('Your %post has been created.', array('%post' => node_get_types('name', $node))));
|
|
}
|
|
if ($node->nid) {
|
|
if (node_access('view', $node)) {
|
|
$form_state['redirect'] = 'node/'. $node->nid;
|
|
}
|
|
}
|
|
// it is very unlikely we get here
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Menu callback -- ask for confirmation of node deletion
|
|
*/
|
|
function node_delete_confirm(&$form_state, $node) {
|
|
|
|
drupal_delete_initiate('node', $node->nid);
|
|
drupal_delete_add_callback(
|
|
array(
|
|
'node_delete_post' => array($node->nid, $node->title, $node->type),
|
|
// Clear the cache so an anonymous poster can see the node being deleted.
|
|
'cache_clear_all' => array(),
|
|
)
|
|
);
|
|
|
|
node_delete($node->nid, FALSE);
|
|
|
|
return drupal_delete_confirm(
|
|
array(
|
|
'question' => t('Are you sure you want to delete %title?', array('%title' => $node->title)),
|
|
'cancel' => isset($_GET['destination']) ? $_GET['destination'] : 'node/'. $node->nid,
|
|
'destination' => isset($_GET['destination']) ? $_GET['destination'] : '<front>',
|
|
)
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Delete a node.
|
|
*/
|
|
function node_delete($nid) {
|
|
|
|
$node = node_load($nid);
|
|
|
|
if (node_access('delete', $node)) {
|
|
drupal_delete_add_query('DELETE FROM {node} WHERE nid = %d', $node->nid);
|
|
drupal_delete_add_query('DELETE FROM {node_revisions} WHERE nid = %d', $node->nid);
|
|
|
|
// Call the node-specific callback (if any):
|
|
node_invoke($node, 'delete');
|
|
node_invoke_nodeapi($node, 'delete');
|
|
}
|
|
}
|
|
|
|
function node_delete_post($nid, $title, $type) {
|
|
|
|
// Remove this node from the search index if needed.
|
|
if (function_exists('search_wipe')) {
|
|
search_wipe($nid, 'node');
|
|
}
|
|
drupal_set_message(t('%title has been deleted.', array('%title' => $title)));
|
|
watchdog('content', '@type: deleted %title.', array('@type' => t($type), '%title' => $title));
|
|
}
|
|
|
|
/**
|
|
* Menu callback for revisions related activities.
|
|
*/
|
|
function node_revisions() {
|
|
if (is_numeric(arg(1)) && arg(2) == 'revisions') {
|
|
$op = arg(4) ? arg(4) : 'overview';
|
|
switch ($op) {
|
|
case 'overview':
|
|
$node = node_load(arg(1));
|
|
if ((user_access('view revisions') || user_access('administer nodes')) && node_access('view', $node)) {
|
|
return node_revision_overview($node);
|
|
}
|
|
drupal_access_denied();
|
|
return;
|
|
case 'view':
|
|
if (is_numeric(arg(3))) {
|
|
$node = node_load(arg(1), arg(3));
|
|
if ($node->nid) {
|
|
if ((user_access('view revisions') || user_access('administer nodes')) && node_access('view', $node)) {
|
|
drupal_set_title(t('Revision of %title from %date', array('%title' => $node->title, '%date' => format_date($node->revision_timestamp))));
|
|
return node_show($node, arg(2));
|
|
}
|
|
drupal_access_denied();
|
|
return;
|
|
}
|
|
}
|
|
break;
|
|
case 'revert':
|
|
node_revision_revert(arg(1), arg(3));
|
|
break;
|
|
case 'delete':
|
|
node_revision_delete(arg(1), arg(3));
|
|
break;
|
|
}
|
|
}
|
|
drupal_not_found();
|
|
}
|
|
|
|
/**
|
|
* Menu callback; Generate a listing of promoted nodes.
|
|
*/
|
|
function node_page_default() {
|
|
$result = pager_query(db_rewrite_sql('SELECT n.nid, n.sticky, n.created FROM {node} n WHERE n.promote = 1 AND n.status = 1 ORDER BY n.sticky DESC, n.created DESC'), variable_get('default_nodes_main', 10));
|
|
|
|
if (db_num_rows($result)) {
|
|
$feed_url = url('rss.xml', array('absolute' => TRUE));
|
|
drupal_add_feed($feed_url, variable_get('site_name', 'Drupal') .' '. t('RSS'));
|
|
|
|
$output = '';
|
|
while ($node = db_fetch_object($result)) {
|
|
$output .= node_view(node_load($node->nid), 1);
|
|
}
|
|
$output .= theme('pager', NULL, variable_get('default_nodes_main', 10));
|
|
}
|
|
else {
|
|
// Check for existence of admin account.
|
|
$admin = db_result(db_query('SELECT uid FROM {users} WHERE uid = 1'));
|
|
|
|
$default_message = t('<h1 class="title">Welcome to your new Drupal website!</h1><p>Please follow these steps to set up and start using your website:</p>');
|
|
$default_message .= '<ol>';
|
|
|
|
$default_message .= '<li>'. t('<strong>Configure your website</strong> Once logged in, visit the <a href="@admin">administration section</a>, where you can <a href="@config">customize and configure</a> all aspects of your website.', array('@admin' => url('admin'), '@config' => url('admin/settings'))) .'</li>';
|
|
$default_message .= '<li>'. t('<strong>Enable additional functionality</strong> Next, visit the <a href="@modules">module list</a> and enable features which suit your specific needs. You can find additional modules in the <a href="@download_modules">Drupal modules download section</a>.', array('@modules' => url('admin/build/modules'), '@download_modules' => 'http://drupal.org/project/modules')) .'</li>';
|
|
$default_message .= '<li>'. t('<strong>Customize your website design</strong> To change the "look and feel" of your website, visit the <a href="@themes">themes section</a>. You may choose from one of the included themes or download additional themes from the <a href="@download_themes">Drupal themes download section</a>.', array('@themes' => url('admin/build/themes'), '@download_themes' => 'http://drupal.org/project/themes')) .'</li>';
|
|
$default_message .= '<li>'. t('<strong>Start posting content</strong> Finally, you can <a href="@content">create content</a> for your website. This message will disappear once you have promoted a post to the front page.', array('@content' => url('node/add'))) .'</li>';
|
|
$default_message .= '</ol>';
|
|
$default_message .= '<p>'. t('For more information, please refer to the <a href="@help">help section</a>, or the <a href="@handbook">online Drupal handbooks</a>. You may also post at the <a href="@forum">Drupal forum</a>, or view the wide range of <a href="@support">other support options</a> available.', array('@help' => url('admin/help'), '@handbook' => 'http://drupal.org/handbooks', '@forum' => 'http://drupal.org/forum', '@support' => 'http://drupal.org/support')) .'</p>';
|
|
|
|
$output = '<div id="first-time">'. $default_message .'</div>';
|
|
}
|
|
drupal_set_title('');
|
|
|
|
return $output;
|
|
}
|
|
|
|
/**
|
|
* Menu callback; view a single node.
|
|
*/
|
|
function node_page_view($node, $cid = NULL) {
|
|
drupal_set_title(check_plain($node->title));
|
|
return node_show($node, $cid);
|
|
}
|
|
|
|
/**
|
|
* Menu callback; presents the node editing form, or redirects to delete confirmation.
|
|
*/
|
|
function node_page_edit($node) {
|
|
if (isset($_POST['op']) && ($_POST['op'] == t('Delete'))) {
|
|
$destination = '';
|
|
// Note: we redirect from node/nid/edit to node/nid/delete to make the tabs disappear.
|
|
if (isset($_REQUEST['destination'])) {
|
|
$destination = drupal_get_destination();
|
|
unset($_REQUEST['destination']);
|
|
}
|
|
drupal_goto('node/'. $node->nid .'/delete', $destination);
|
|
}
|
|
|
|
drupal_set_title(check_plain($node->title));
|
|
return drupal_get_form($node->type .'_node_form', $node);
|
|
}
|
|
|
|
/**
|
|
* shutdown function to make sure we always mark the last node processed.
|
|
*/
|
|
function node_update_shutdown() {
|
|
global $last_change, $last_nid;
|
|
|
|
if ($last_change && $last_nid) {
|
|
variable_set('node_cron_last', $last_change);
|
|
variable_set('node_cron_last_nid', $last_nid);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_update_index().
|
|
*/
|
|
function node_update_index() {
|
|
global $last_change, $last_nid;
|
|
|
|
register_shutdown_function('node_update_shutdown');
|
|
|
|
$last = variable_get('node_cron_last', 0);
|
|
$last_nid = variable_get('node_cron_last_nid', 0);
|
|
$limit = (int)variable_get('search_cron_limit', 100);
|
|
|
|
// Store the maximum possible comments per thread (used for ranking by reply count)
|
|
variable_set('node_cron_comments_scale', 1.0 / max(1, db_result(db_query('SELECT MAX(comment_count) FROM {node_comment_statistics}'))));
|
|
variable_set('node_cron_views_scale', 1.0 / max(1, db_result(db_query('SELECT MAX(totalcount) FROM {node_counter}'))));
|
|
|
|
$result = db_query_range('SELECT GREATEST(IF(c.last_comment_timestamp IS NULL, 0, c.last_comment_timestamp), n.changed) as last_change, n.nid FROM {node} n LEFT JOIN {node_comment_statistics} c ON n.nid = c.nid WHERE n.status = 1 AND ((GREATEST(n.changed, c.last_comment_timestamp) = %d AND n.nid > %d) OR (n.changed > %d OR c.last_comment_timestamp > %d)) ORDER BY GREATEST(n.changed, c.last_comment_timestamp) ASC, n.nid ASC', $last, $last_nid, $last, $last, $last, 0, $limit);
|
|
|
|
while ($node = db_fetch_object($result)) {
|
|
$last_change = $node->last_change;
|
|
$last_nid = $node->nid;
|
|
$node = node_load($node->nid);
|
|
|
|
// Build the node body.
|
|
$node = node_build_content($node, FALSE, FALSE);
|
|
$node->body = drupal_render($node->content);
|
|
|
|
$text = '<h1>'. check_plain($node->title) .'</h1>'. $node->body;
|
|
|
|
// Fetch extra data normally not visible
|
|
$extra = node_invoke_nodeapi($node, 'update index');
|
|
foreach ($extra as $t) {
|
|
$text .= $t;
|
|
}
|
|
|
|
// Update index
|
|
search_index($node->nid, 'node', $text);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_form_alter().
|
|
*/
|
|
function node_form_alter(&$form, $form_state, $form_id) {
|
|
// Advanced node search form
|
|
if ($form_id == 'search_form' && $form['module']['#value'] == 'node' && user_access('use advanced search')) {
|
|
// Keyword boxes:
|
|
$form['advanced'] = array(
|
|
'#type' => 'fieldset',
|
|
'#title' => t('Advanced search'),
|
|
'#collapsible' => TRUE,
|
|
'#collapsed' => TRUE,
|
|
'#attributes' => array('class' => 'search-advanced'),
|
|
);
|
|
$form['advanced']['keywords'] = array(
|
|
'#prefix' => '<div class="criterion">',
|
|
'#suffix' => '</div>',
|
|
);
|
|
$form['advanced']['keywords']['or'] = array(
|
|
'#type' => 'textfield',
|
|
'#title' => t('Containing any of the words'),
|
|
'#size' => 30,
|
|
'#maxlength' => 255,
|
|
);
|
|
$form['advanced']['keywords']['phrase'] = array(
|
|
'#type' => 'textfield',
|
|
'#title' => t('Containing the phrase'),
|
|
'#size' => 30,
|
|
'#maxlength' => 255,
|
|
);
|
|
$form['advanced']['keywords']['negative'] = array(
|
|
'#type' => 'textfield',
|
|
'#title' => t('Containing none of the words'),
|
|
'#size' => 30,
|
|
'#maxlength' => 255,
|
|
);
|
|
|
|
// Taxonomy box:
|
|
if ($taxonomy = module_invoke('taxonomy', 'form_all', 1)) {
|
|
$form['advanced']['category'] = array(
|
|
'#type' => 'select',
|
|
'#title' => t('Only in the category(s)'),
|
|
'#prefix' => '<div class="criterion">',
|
|
'#size' => 10,
|
|
'#suffix' => '</div>',
|
|
'#options' => $taxonomy,
|
|
'#multiple' => TRUE,
|
|
);
|
|
}
|
|
|
|
// Node types:
|
|
$types = node_get_types('names');
|
|
$form['advanced']['type'] = array(
|
|
'#type' => 'checkboxes',
|
|
'#title' => t('Only of the type(s)'),
|
|
'#prefix' => '<div class="criterion">',
|
|
'#suffix' => '</div>',
|
|
'#options' => $types,
|
|
);
|
|
$form['advanced']['submit'] = array(
|
|
'#type' => 'submit',
|
|
'#value' => t('Advanced search'),
|
|
'#prefix' => '<div class="action">',
|
|
'#suffix' => '</div>',
|
|
);
|
|
|
|
$form['#validate'][] = 'node_search_validate';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Form API callback for the search form. Registered in node_form_alter().
|
|
*/
|
|
function node_search_validate($form, &$form_state) {
|
|
// Initialise using any existing basic search keywords.
|
|
$keys = $form_state['values']['processed_keys'];
|
|
|
|
// Insert extra restrictions into the search keywords string.
|
|
if (isset($form_state['values']['type']) && is_array($form_state['values']['type'])) {
|
|
// Retrieve selected types - Forms API sets the value of unselected checkboxes to 0.
|
|
$form_state['values']['type'] = array_filter($form_state['values']['type']);
|
|
if (count($form_state['values']['type'])) {
|
|
$keys = search_query_insert($keys, 'type', implode(',', array_keys($form_state['values']['type'])));
|
|
}
|
|
}
|
|
|
|
if (isset($form_state['values']['category']) && is_array($form_state['values']['category'])) {
|
|
$keys = search_query_insert($keys, 'category', implode(',', $form_state['values']['category']));
|
|
}
|
|
if ($form_state['values']['or'] != '') {
|
|
if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' '. $form_state['values']['or'], $matches)) {
|
|
$keys .= ' '. implode(' OR ', $matches[1]);
|
|
}
|
|
}
|
|
if ($form_state['values']['negative'] != '') {
|
|
if (preg_match_all('/ ("[^"]+"|[^" ]+)/i', ' '. $form_state['values']['negative'], $matches)) {
|
|
$keys .= ' -'. implode(' -', $matches[1]);
|
|
}
|
|
}
|
|
if ($form_state['values']['phrase'] != '') {
|
|
$keys .= ' "'. str_replace('"', ' ', $form_state['values']['phrase']) .'"';
|
|
}
|
|
if (!empty($keys)) {
|
|
form_set_value($form['basic']['inline']['processed_keys'], trim($keys), $form_state);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @defgroup node_access Node access rights
|
|
* @{
|
|
* The node access system determines who can do what to which nodes.
|
|
*
|
|
* In determining access rights for a node, node_access() first checks
|
|
* whether the user has the "administer nodes" permission. Such users have
|
|
* unrestricted access to all nodes. Then the node module's hook_access()
|
|
* is called, and a TRUE or FALSE return value will grant or deny access.
|
|
* This allows, for example, the blog module to always grant access to the
|
|
* blog author, and for the book module to always deny editing access to
|
|
* PHP pages.
|
|
*
|
|
* If node module does not intervene (returns NULL), then the
|
|
* node_access table is used to determine access. All node access
|
|
* modules are queried using hook_node_grants() to assemble a list of
|
|
* "grant IDs" for the user. This list is compared against the table.
|
|
* If any row contains the node ID in question (or 0, which stands for "all
|
|
* nodes"), one of the grant IDs returned, and a value of TRUE for the
|
|
* operation in question, then access is granted. Note that this table is a
|
|
* list of grants; any matching row is sufficient to grant access to the
|
|
* node.
|
|
*
|
|
* In node listings, the process above is followed except that
|
|
* hook_access() is not called on each node for performance reasons and for
|
|
* proper functioning of the pager system. When adding a node listing to your
|
|
* module, be sure to use db_rewrite_sql() to add
|
|
* the appropriate clauses to your query for access checks.
|
|
*
|
|
* To see how to write a node access module of your own, see
|
|
* node_access_example.module.
|
|
*/
|
|
|
|
/**
|
|
* Determine whether the current user may perform the given operation on the
|
|
* specified node.
|
|
*
|
|
* @param $op
|
|
* The operation to be performed on the node. Possible values are:
|
|
* - "view"
|
|
* - "update"
|
|
* - "delete"
|
|
* - "create"
|
|
* @param $node
|
|
* The node object (or node array) on which the operation is to be performed,
|
|
* or node type (e.g. 'forum') for "create" operation.
|
|
* @return
|
|
* TRUE if the operation may be performed.
|
|
*/
|
|
function node_access($op, $node) {
|
|
global $user;
|
|
|
|
if (!$node) {
|
|
return FALSE;
|
|
}
|
|
// Convert the node to an object if necessary:
|
|
if ($op != 'create') {
|
|
$node = (object)$node;
|
|
}
|
|
// If the node is in a restricted format, disallow editing.
|
|
if ($op == 'update' && !filter_access($node->format)) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (user_access('administer nodes')) {
|
|
return TRUE;
|
|
}
|
|
|
|
if (!user_access('access content')) {
|
|
return FALSE;
|
|
}
|
|
|
|
// Can't use node_invoke(), because the access hook takes the $op parameter
|
|
// before the $node parameter.
|
|
$module = node_get_types('module', $node);
|
|
if ($module == 'node') {
|
|
$module = 'node_content'; // Avoid function name collisions.
|
|
}
|
|
$access = module_invoke($module, 'access', $op, $node);
|
|
if (!is_null($access)) {
|
|
return $access;
|
|
}
|
|
|
|
// If the module did not override the access rights, use those set in the
|
|
// node_access table.
|
|
if ($op != 'create' && $node->nid && $node->status) {
|
|
$grants = array();
|
|
foreach (node_access_grants($op) as $realm => $gids) {
|
|
foreach ($gids as $gid) {
|
|
$grants[] = "(gid = $gid AND realm = '$realm')";
|
|
}
|
|
}
|
|
|
|
$grants_sql = '';
|
|
if (count($grants)) {
|
|
$grants_sql = 'AND ('. implode(' OR ', $grants) .')';
|
|
}
|
|
|
|
$sql = "SELECT COUNT(*) FROM {node_access} WHERE (nid = 0 OR nid = %d) $grants_sql AND grant_$op >= 1";
|
|
$result = db_query($sql, $node->nid);
|
|
return (db_result($result));
|
|
}
|
|
|
|
// Let authors view their own nodes.
|
|
if ($op == 'view' && $user->uid == $node->uid && $user->uid != 0) {
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Generate an SQL join clause for use in fetching a node listing.
|
|
*
|
|
* @param $node_alias
|
|
* If the node table has been given an SQL alias other than the default
|
|
* "n", that must be passed here.
|
|
* @param $node_access_alias
|
|
* If the node_access table has been given an SQL alias other than the default
|
|
* "na", that must be passed here.
|
|
* @return
|
|
* An SQL join clause.
|
|
*/
|
|
function _node_access_join_sql($node_alias = 'n', $node_access_alias = 'na') {
|
|
if (user_access('administer nodes')) {
|
|
return '';
|
|
}
|
|
|
|
return 'INNER JOIN {node_access} '. $node_access_alias .' ON '. $node_access_alias .'.nid = '. $node_alias .'.nid';
|
|
}
|
|
|
|
/**
|
|
* Generate an SQL where clause for use in fetching a node listing.
|
|
*
|
|
* @param $op
|
|
* The operation that must be allowed to return a node.
|
|
* @param $node_access_alias
|
|
* If the node_access table has been given an SQL alias other than the default
|
|
* "na", that must be passed here.
|
|
* @return
|
|
* An SQL where clause.
|
|
*/
|
|
function _node_access_where_sql($op = 'view', $node_access_alias = 'na', $uid = NULL) {
|
|
if (user_access('administer nodes')) {
|
|
return;
|
|
}
|
|
|
|
$grants = array();
|
|
foreach (node_access_grants($op, $uid) as $realm => $gids) {
|
|
foreach ($gids as $gid) {
|
|
$grants[] = "($node_access_alias.gid = $gid AND $node_access_alias.realm = '$realm')";
|
|
}
|
|
}
|
|
|
|
$grants_sql = '';
|
|
if (count($grants)) {
|
|
$grants_sql = 'AND ('. implode(' OR ', $grants) .')';
|
|
}
|
|
|
|
$sql = "$node_access_alias.grant_$op >= 1 $grants_sql";
|
|
return $sql;
|
|
}
|
|
|
|
/**
|
|
* Fetch an array of permission IDs granted to the given user ID.
|
|
*
|
|
* The implementation here provides only the universal "all" grant. A node
|
|
* access module should implement hook_node_grants() to provide a grant
|
|
* list for the user.
|
|
*
|
|
* @param $op
|
|
* The operation that the user is trying to perform.
|
|
* @param $uid
|
|
* The user ID performing the operation. If omitted, the current user is used.
|
|
* @return
|
|
* An associative array in which the keys are realms, and the values are
|
|
* arrays of grants for those realms.
|
|
*/
|
|
function node_access_grants($op, $uid = NULL) {
|
|
global $user;
|
|
|
|
if (isset($uid)) {
|
|
$user_object = user_load(array('uid' => $uid));
|
|
}
|
|
else {
|
|
$user_object = $user;
|
|
}
|
|
|
|
return array_merge(array('all' => array(0)), module_invoke_all('node_grants', $user_object, $op));
|
|
}
|
|
|
|
/**
|
|
* Determine whether the user has a global viewing grant for all nodes.
|
|
*/
|
|
function node_access_view_all_nodes() {
|
|
static $access;
|
|
|
|
if (!isset($access)) {
|
|
$grants = array();
|
|
foreach (node_access_grants('view') as $realm => $gids) {
|
|
foreach ($gids as $gid) {
|
|
$grants[] = "(gid = $gid AND realm = '$realm')";
|
|
}
|
|
}
|
|
|
|
$grants_sql = '';
|
|
if (count($grants)) {
|
|
$grants_sql = 'AND ('. implode(' OR ', $grants) .')';
|
|
}
|
|
|
|
$sql = "SELECT COUNT(*) FROM {node_access} WHERE nid = 0 $grants_sql AND grant_view >= 1";
|
|
$result = db_query($sql);
|
|
$access = db_result($result);
|
|
}
|
|
|
|
return $access;
|
|
}
|
|
|
|
/**
|
|
* Implementation of hook_db_rewrite_sql
|
|
*/
|
|
function node_db_rewrite_sql($query, $primary_table, $primary_field) {
|
|
if ($primary_field == 'nid' && !node_access_view_all_nodes()) {
|
|
$return['join'] = _node_access_join_sql($primary_table);
|
|
$return['where'] = _node_access_where_sql();
|
|
$return['distinct'] = 1;
|
|
return $return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This function will call module invoke to get a list of grants and then
|
|
* write them to the database. It is called at node save, and should be
|
|
* called by modules whenever something other than a node_save causes
|
|
* the permissions on a node to change.
|
|
*
|
|
* This function is the only function that should write to the node_access
|
|
* table.
|
|
*
|
|
* @param $node
|
|
* The $node to acquire grants for.
|
|
*/
|
|
function node_access_acquire_grants($node) {
|
|
$grants = module_invoke_all('node_access_records', $node);
|
|
if (!$grants) {
|
|
$grants[] = array('realm' => 'all', 'gid' => 0, 'grant_view' => 1, 'grant_update' => 0, 'grant_delete' => 0);
|
|
}
|
|
else {
|
|
// retain grants by highest priority
|
|
$grant_by_priority = array();
|
|
foreach ($grants as $g) {
|
|
$grant_by_priority[intval($g['priority'])][] = $g;
|
|
}
|
|
krsort($grant_by_priority);
|
|
$grants = array_shift($grant_by_priority);
|
|
}
|
|
|
|
node_access_write_grants($node, $grants);
|
|
}
|
|
|
|
/**
|
|
* This function will write a list of grants to the database, deleting
|
|
* any pre-existing grants. If a realm is provided, it will only
|
|
* delete grants from that realm, but it will always delete a grant
|
|
* from the 'all' realm. Modules which utilize node_access can
|
|
* use this function when doing mass updates due to widespread permission
|
|
* changes.
|
|
*
|
|
* @param $node
|
|
* The $node being written to. All that is necessary is that it contain a nid.
|
|
* @param $grants
|
|
* A list of grants to write. Each grant is an array that must contain the
|
|
* following keys: realm, gid, grant_view, grant_update, grant_delete.
|
|
* The realm is specified by a particular module; the gid is as well, and
|
|
* is a module-defined id to define grant privileges. each grant_* field
|
|
* is a boolean value.
|
|
* @param $realm
|
|
* If provided, only read/write grants for that realm.
|
|
* @param $delete
|
|
* If false, do not delete records. This is only for optimization purposes,
|
|
* and assumes the caller has already performed a mass delete of some form.
|
|
*/
|
|
function node_access_write_grants($node, $grants, $realm = NULL, $delete = TRUE) {
|
|
if ($delete) {
|
|
$query = 'DELETE FROM {node_access} WHERE nid = %d';
|
|
if ($realm) {
|
|
$query .= " AND realm in ('%s', 'all')";
|
|
}
|
|
db_query($query, $node->nid, $realm);
|
|
}
|
|
|
|
// Only perform work when node_access modules are active.
|
|
if (count(module_implements('node_grants'))) {
|
|
foreach ($grants as $grant) {
|
|
if ($realm && $realm != $grant['realm']) {
|
|
continue;
|
|
}
|
|
// Only write grants; denies are implicit.
|
|
if ($grant['grant_view'] || $grant['grant_update'] || $grant['grant_delete']) {
|
|
db_query("INSERT INTO {node_access} (nid, realm, gid, grant_view, grant_update, grant_delete) VALUES (%d, '%s', %d, %d, %d, %d)", $node->nid, $grant['realm'], $grant['gid'], $grant['grant_view'], $grant['grant_update'], $grant['grant_delete']);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Rebuild the node access database. This is occasionally needed by modules
|
|
* that make system-wide changes to access levels.
|
|
*/
|
|
function node_access_rebuild() {
|
|
db_query("DELETE FROM {node_access}");
|
|
// only recalculate if site is using a node_access module
|
|
if (count(module_implements('node_grants'))) {
|
|
// If not in 'safe mode', increase the maximum execution time:
|
|
if (!ini_get('safe_mode')) {
|
|
set_time_limit(240);
|
|
}
|
|
$result = db_query("SELECT nid FROM {node}");
|
|
while ($node = db_fetch_object($result)) {
|
|
node_access_acquire_grants(node_load($node->nid, NULL, TRUE));
|
|
}
|
|
}
|
|
else {
|
|
// not using any node_access modules. add the default grant.
|
|
db_query("INSERT INTO {node_access} VALUES (0, 0, 'all', 1, 0, 0)");
|
|
}
|
|
cache_clear_all();
|
|
}
|
|
/**
|
|
* @} End of "defgroup node_access".
|
|
*/
|
|
|
|
|
|
/**
|
|
* @defgroup node_content Hook implementations for user-created content types.
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Implementation of hook_access().
|
|
*/
|
|
function node_content_access($op, $node) {
|
|
global $user;
|
|
$type = is_string($node) ? $node : (is_array($node) ? $node['type'] : $node->type);
|
|
|
|
if ($op == 'create') {
|
|
return user_access('create '. $type .' content');
|
|
}
|
|
|
|
if ($op == 'update') {
|
|
if (user_access('edit '. $type .' content') || (user_access('edit own '. $type .' content') && ($user->uid == $node->uid))) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
if ($op == 'delete') {
|
|
if (user_access('delete '. $type .' content') || (user_access('delete own '. $type .' content') && ($user->uid == $node->uid))) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a node body field, with format and teaser.
|
|
*/
|
|
function node_body_field(&$node, $label, $word_count) {
|
|
|
|
// Check if we need to restore the teaser at the beginning of the body.
|
|
$include = !isset($node->teaser) || ($node->teaser == substr($node->body, 0, strlen($node->teaser)));
|
|
|
|
$form = array(
|
|
'#after_build' => array('node_teaser_js'));
|
|
|
|
$form['teaser_js'] = array(
|
|
'#type' => 'textarea',
|
|
'#rows' => 10,
|
|
'#teaser' => 'edit-body',
|
|
'#teaser_checkbox' => 'edit-teaser-include',
|
|
'#disabled' => TRUE);
|
|
|
|
$form['teaser_include'] = array(
|
|
'#type' => 'checkbox',
|
|
'#title' => t('Show summary in full view'),
|
|
'#default_value' => $include,
|
|
'#prefix' => '<div class="teaser-checkbox">',
|
|
'#suffix' => '</div>',
|
|
);
|
|
|
|
$form['body'] = array(
|
|
'#type' => 'textarea',
|
|
'#title' => check_plain($label),
|
|
'#default_value' => $include ? $node->body : ($node->teaser . $node->body),
|
|
'#rows' => 20,
|
|
'#required' => ($word_count > 0));
|
|
|
|
$form['format'] = filter_form($node->format);
|
|
|
|
return $form;
|
|
}
|
|
/**
|
|
* Implementation of hook_form().
|
|
*/
|
|
function node_content_form($node, $form_state) {
|
|
$type = node_get_types('type', $node);
|
|
$form = array();
|
|
|
|
if ($type->has_title) {
|
|
$form['title'] = array(
|
|
'#type' => 'textfield',
|
|
'#title' => check_plain($type->title_label),
|
|
'#required' => TRUE,
|
|
'#default_value' => $node->title,
|
|
'#weight' => -5,
|
|
);
|
|
}
|
|
|
|
if ($type->has_body) {
|
|
$form['body_field'] = node_body_field($node, $type->body_label, $type->min_word_count);
|
|
}
|
|
|
|
return $form;
|
|
}
|
|
|
|
/**
|
|
* @} End of "defgroup node_content".
|
|
*/
|
|
|
|
/**
|
|
* Implementation of hook_forms(). All node forms share the same form handler
|
|
*/
|
|
function node_forms() {
|
|
foreach (array_keys(node_get_types()) as $type) {
|
|
$forms[$type .'_node_form']['callback'] = 'node_form';
|
|
}
|
|
return $forms;
|
|
}
|