modules/publish/publish.module

<?php
// $Id: publish.module,v 1.27 2006/09/06 11:59:52 jvandyk Exp $

/**
 * @file
 * Enable users to publish content to other Drupal sites (running subscribe.module) via XML-RPC.
 */

define('PUBLISH_DEBUG_MODE', TRUE);
define('PUBLISH_PULL', 0);
define('PUBLISH_PUSH', 1);
define('PUBLISH_AUTHTYPE_NONE', 0);
define('PUBLISH_AUTHTYPE_PERM', 1);
define('PUBLISH_AUTHTYPE_SIMPLE', 2);
define('PUBLISH_WHENPUB_CRON', 0);
define('PUBLISH_WHENPUB_NODESUB', 1);


/********************************************************************
 * Drupal Hooks :: General Overview
 ********************************************************************/

/**
 * Implementation of hook_help().
 */
function publish_help($section) {
  switch ($section) {
    case 'admin/modules#description':
      return t('Allow site to send content to other Drupal sites.');
    case 'admin/publish' :
      return t('<p>Channels can be subscribed to by other Drupal sites using the subscribe module.<p>');
    case strstr($section, 'admin/publish/pub/nodes'):
      return t('<p>Choose which which node types you would like to publish to other Drupal sites.</p>');
    case strstr($section, 'admin/publish/pub/vocabularies'):
      return t('<p>Choose which vocabularies will accompany the nodes you publish to other Drupal sites. If a checkbox does not appear next to a node type it is because the node type is not associated with the vocabulary (you can change associations using administer &gt; categories &gt; edit vocabulary.)</p>');
  }
}

/**
 * Implementation of hook_menu().
 */
function publish_menu($may_cache) {
  $items = array();
  $admin = user_access('administer channels');

  if (!$may_cache) {
    if (arg(2) == 'pub' && is_numeric(arg(4))) {
      $items[] = array(
        'path' => 'admin/publish/pub/edit/' . arg(4),
        'title' => t('edit'),
        'callback' => 'publish_channel_edit',
        'type' => MENU_CALLBACK,
        'access' => $admin);
    }
    $items[] = array(
      'path' =>'admin/publish/subscribers/' . arg(3),
      'title' => t('subscribers'),
      'callback' => 'publish_subscribers',
      'type' => MENU_CALLBACK,
      'access' => $admin);
    $items[] = array('path' => 'admin/publish/filters/' . arg(3),
      'title' => t('filters'),
      'callback' => 'publish_channel_filter_form',
      'type' => MENU_CALLBACK,
      'access' => $admin);
    $items[] = array('path' => 'admin/publish/edit/' . arg(4),
      'title' => t('configure'),
      'callback' => 'publish_channel_edit',
      'type' => MENU_CALLBACK,
      'access' => $admin);
  }
  else {
    $items[] = array(
      'path' => 'admin/publish',
      'title' => t('publish'),
      'callback' => 'publish_overview',
      'access' => $admin);
    $items[] = array(
      'path' => 'admin/publish/pub/vocabularies',
      'title' => t('vocabularies'),
      'callback' => 'publish_vocabulary_form',
      'type' => MENU_CALLBACK,
      'access' => $admin);
    $items[] = array(
      'path' => 'admin/publish/list',
      'title' => t('channels'),
      'type' => MENU_DEFAULT_LOCAL_TASK,
      'weight' => -10,
      'callback' => 'publish_overview',
      'access' => $admin);
    $items[] = array(
      'path' => 'admin/publish/add',
      'title' => t('add channel'),
      'type' => MENU_LOCAL_TASK,
      'callback' => 'publish_channel_form',
      'access' => $admin);
    $items[] = array(
      'path' => 'admin/publish/pub/delete',
      'title' => t('delete'),
      'callback' => 'publish_channel_delete_form',
      'type' => MENU_CALLBACK,
      'access' => $admin);
    $items[] = array(
      'path' => 'admin/publish/pub/filters/delete',
      'title' => t('filters'),
      'callback' => 'publish_channel_filter_delete_form',
      'type' => MENU_CALLBACK,
      'access' => $admin);
  }
  return $items;
}

/**
* Implementation of hook_perm().
*/
function publish_perm() {
  return array('subscribe to channels', 'administer channels');
}

/********************************************************************
 * Drupal Hooks :: Core
 ********************************************************************/

/**
 * Implementation of hook_cron().
 *
 * Used to invoke content transfer when cron runs.
 *
 */
function publish_cron() {
  publish_push();
}

/**
 * Implementation of hook_nodeapi().
 *
 * Used to invoke content transfer when a node is submitted.
 *
 */
function publish_nodeapi(&$node, $op, $teaser = NULL, $page = NULL) {
  switch ($op) {
    case 'insert':
    case 'update':
      // exit quickly if node is not in published state
      if ($node->status != 1) {
        return;
      }
      if (PUBLISH_DEBUG_MODE) watchdog('publish', t('nodeapi firing'));
      // Find all subscribers to this node.
      $result = db_query("SELECT * FROM {publish_channel} p INNER JOIN {publish_nodetypes} n ON n.channel_id = p.channel_id INNER JOIN {publish_subscribers} s ON s.channel_id = p.channel_id WHERE n.type = '%s'", $node->type);
      $exists = db_result(db_query("SELECT nid FROM {publish_queue} WHERE nid = %d", $node->nid));
      if ($exists) { // delete older version from queue
        db_query("DELETE FROM {publish_queue} WHERE nid = %d", $node->nid);
      }
      $publish_now = FALSE;
      while ($data = db_fetch_object($result)) {
        if ($data->whenpub == PUBLISH_WHENPUB_NODESUB) {
          $publish_now = TRUE;
        }
        // add them to the queue to have the node pushed out to them
        // TODO: we should run the node through the channel's condition filters here?
        db_query("INSERT INTO {publish_queue} (qid, nid, sid, channel_id, changed) VALUES (%d, %d, %d, %d, %d)", db_next_id('publish_queue'), $node->nid, $data->sid, $data->channel_id, $node->changed);
        if (PUBLISH_DEBUG_MODE) watchdog('publish', t('channel %cid added node %nid to q for subscriber id %sid', array('%cid' => $data->channel_id, '%nid' => $node->nid, '%sid' => $data->sid)));
      }
      // set publish on exit if channel is set to publish at node submission time
      if ($publish_now) {
        if (PUBLISH_DEBUG_MODE) watchdog('publish', t('setting publish_exit'));
        publish_exit(TRUE);
      }
      break;
  }
}

/**
 * Implementation of hook_exit().
 *
 * Used to invoke push content transfer
 *
 */
function publish_exit($set = FALSE) {
  static $do_transfer = FALSE;

  if ($do_transfer) {
    publish_push();
    return;
  }

  if ($set) {
    $do_transfer = TRUE;
  }
}

/**
 * Implementation of hook_xmlrpc().
 *
 * This is the server side of the xml-rpc request.
 * Registering xml-rpc methods to callback functions.
 */
function publish_xmlrpc() {
  return array(
    array('drupal.publish.maySubscribe', 'publish_xmls_may_subscribe', array('array', 'int','string','string'), t('Return channel info if caller supplies appropriate credentials.')),
    array('drupal.publish.subscribe', 'publish_xmls_receive_subscription', array('int', 'int', 'string', 'string', 'string', 'string', 'array', 'array', 'array'), t('Establish relationship with subscriber.')),
    array('drupal.publish.pull', 'publish_xmls_publish', array('array', 'int', 'int', 'string', 'string', 'array'), t('Send nodes matching certain conditions to subscriber.')),
    array('drupal.publish.getNode', 'publish_xmls_get_node', array('array', 'int', 'string', 'string', 'int'), t('Send single node to subscriber.')),
    array('drupal.publish.getChannels', 'publish_xmls_get_channels', array('array'), t('Return list of public channels on this site.')),
    array('drupal.publish.cancelSubscription', 'publish_xmls_cancel_subscription', array('boolean', 'int', 'string'), t('Cancel subscription.'))
  );
}

/********************************************************************
 * Module Functions :: Publishing
 ********************************************************************/

/**
 * Display list of channels
 *
 * @return
 *   HTML output
 */
function publish_overview() {
  $header = array(array('data' => t('ID')), array('data' => t('Name')), array('data' => t('Advertise')), array('data' => t('Subscribers')), array('data' => t('Operations')));
  $result = db_query('SELECT * FROM {publish_channel}');
  $row = array();
  while ($data = db_fetch_object($result)) {
    $edit_items = array();
    $edit_items[] = l(t('edit'), "admin/publish/pub/edit/$data->channel_id");
    $edit_items[] = l(t('vocabularies'), "admin/publish/pub/vocabularies/$data->channel_id");
    $edit_items[] = l(t('filters'), "admin/publish/filters/$data->channel_id");
    $count = db_result(db_query("SELECT COUNT(*) FROM {publish_subscribers} WHERE channel_id = %d", $data->channel_id));
    $edit_items[] = l(t('delete'), "admin/publish/pub/delete/$data->channel_id");
    $row[] = array(
      array('data' => $data->channel_id, 'valign' => 'top'),
      array('data' => "$data->name", 'valign' => 'top'),
      array('data' => $data->advertise ? t('yes') : t('no'), 'valign' => 'top'),
      array('data' => $count ? l($count, "admin/publish/subscribers/$data->channel_id") : t('none'), 'valign' => 'top'),
      array('data' => implode("<br />\n", $edit_items)));
  }

  $output = $row ? theme('table', $header, $row) : t('No channels created. Would you like to <a href="%add-channel">create one</a>?', array('%add-channel' => url('admin/publish/add')));

  return $output;
}

/**
 * Load a channel from the database
 *
 * @param $channel_id
 *   The ID of the channel in question
 *
 * @return
 *   An object representing a channel
 */
function publish_channel_load($channel_id) {
  $channel = db_fetch_object(db_query('SELECT * FROM {publish_channel} WHERE channel_id = %d', $channel_id));
  if ($channel) {
    $result = db_query('SELECT * FROM {publish_cond} WHERE channel_id = %d AND sid = 0', $channel_id);
    $channel->filters = array();
    while ($data = db_fetch_object($result)) {
      $channel->filters[] = array('fid' => $data->fid, 'field' => $data->field, 'operator' => $data->cond, 'value' => $data->value);
    }
  }

  return $channel;
}

function publish_channel_edit() {
  $channel_id = arg(4);
  $channel = publish_channel_load($channel_id);
  if (!$channel) {
    drupal_set_message(t('No such channel.', 'error'));
    drupal_goto('admin/publish');
  }
  return publish_channel_form($channel);
}

/**
 * Build form for editing most channel metadata
 *
 * @param $channel
 *   Object representing a channel (see publish_channel_load())
 * @param $edit
 *   Array with form values
 *
 * @return
 *   HTML output
 */
function publish_channel_form($channel = NULL, $edit = array()) {
  if (!isset($channel->name)) {
    $output = '<h3>' . t('Adding channel') . '</h3>';
  }
  else {
    $output = '<h3>' . t('Configuring channel') . ' "' . $channel->name . '"' . '</h3>';
  }

  $form['name'] = array(
    '#type' => 'textfield',
    '#title' => t('Name'),
    '#default_value' => isset($channel->name) ? $channel->name : '',
    '#size' => '60',
    '#maxlength' => '255'
    );
  $form['description'] = array(
    '#type' => 'textfield',
    '#title' => t('Description'),
    '#default_value' => isset($channel->description) ? $channel->description : '',
    '#size' => '60',
    '#maxlength' => '255',
    '#description' => t('A brief description of this channel.')
    );
  $form['advertise'] = array(
    '#type' => 'checkbox',
    '#title' => t('Advertise on channel list'),
    '#default_value' => isset($channel->advertise) ? $channel->advertise : '0',
    '#description' => t('Show name and description of this channel when another site asks which channels are available.')
    );

  $published = array();
  $result = db_query("SELECT * FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel->channel_id);
  while ($data = db_fetch_object($result)) {
    $published[] = $data->type;
  }

  $form['node_types'] = array(
    '#type' => 'fieldset',
    '#title' => t('Node types')
    );
  $form['node_types']['types'] = array(
    '#type' => 'checkboxes',
    '#title' => t('Publish the following node types'),
    '#default_value' => $published,
    '#options' => node_get_types(),
    );
  $form['authentication'] = array(
    '#type' => 'fieldset',
    '#title' => t('Who may subscribe to this channel?')
    );
  $form['authentication']['authtype'] = array(
    '#type' => 'radios',
    '#title' => t('Choose an authorization model'),
    '#default_value' => isset($channel->authtype) ? $channel->authtype : 'none',
    '#options' =>  array(t('None'), t('Users with %perm permission', array('%perm' => theme('placeholder', 'subscribe to channel'))), t('Username and password (enter below)'))
    );
  $form['authentication']['username'] = array(
    '#type' => 'textfield',
    '#title' => t('Username'),
    '#size' => '10',
    '#maxlength' => '32',
    '#default_value' => isset($channel->username) ? $channel->username : ''
    );
  $form['authentication']['pass'] = array(
    '#type' => 'password',
    '#title' => t('Password'),
    '#size' => '10',
    '#maxlength' => '32',
    '#default_value' => isset($channel->pass) ? $channel->pass : ''
    );
  $form['domains'] = array(
    '#type' => 'fieldset',
    '#title' => t('Domains that may subscribe')
    );
  $form['domains']['allowed'] = array(
    '#type' => 'textarea',
    '#title' => t('Domains'),
    '#rows' => '2',
    '#description' => t('Subscribers will be restricted to domains listed here, e.g. %example. If no domains are listed, all may subscribe.', array('%example' => theme('placeholder', 'example.org, example2.org')))
    );
  $form['channel_id'] = array(
    '#type' => 'value',
    '#value' => isset($channel->channel_id) ? $channel->channel_id : ''
    );
  $form['when'] = array(
    '#type' => 'fieldset',
    '#title' => t('How often do you want content published?')
    );
  $form['when']['whenpub'] = array(
    '#type' => 'radios',
    '#title' => t('When should content be published?'),
    '#default_value' => isset($channel->whenpub) ? $channel->whenpub : 'cron',
    '#options' => array(t('At regular intervals'), t('As soon as it is submitted/updated'))
    );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Update Channel Settings')
    );
  return drupal_get_form('publish_channel_form', $form);
}

/**
 * Validate input channel_detail_form
 */
function publish_channel_form_validate($form_id, $form_values, $form) {
  $errors = array();

  form_set_value($form['name'], check_plain($form_values['name']));
  if ($form_values['name'] == '') {
    $errors['name'] = t('You must specify a nonblank descriptor for this channel.');
  }
  if ($form_values['allowed'] != '') {
    $domain_pattern = "/([[:alpha:]][-[:alnum:]]*[[:alnum:]])(\.[[:alpha:]][-[:alnum:]]*[[:alpha:]])+/i";
    $domains = explode(',', $form_values['allowed']);
    $err_domains = '';
    $clean_domains = '';
    foreach ($domains as $domain) {
      $domain = trim($domain);
      if (!preg_match($domain_pattern, $domain)) {
        $err_domains = $err_domains . ', ' . $domain;
      }
      else {
        $clean_domains = $clean_domains . ',' . $domain;
      }
    }
    if ($err_domains != '') {
      $errors['allowed'] = t('The following domains are invalid:') . ltrim($err_domains, ',');
    }
    else {
      form_set_value($form['domains']['allowed'], ltrim($clean_domains, ','));
    }
  }
  if (!array_filter($form_values['types'])) {
    $errors['types'] = t('You must choose at least one node type to publish.');
  }
  foreach ($errors as $name => $message) {
    form_set_error($name, $message);
  }
}

function publish_channel_form_submit($form_id, $form_values) {
  // get an array of checked node types
  $form_values['types'] = array_filter($form_values['types']);
  if ($form_values['channel_id']) {
    publish_channel_save($form_values);
  }
  else { // new channel
    $form_values['channel_id'] = publish_channel_save($form_values);
  }
  publish_node_save($form_values);
  return 'admin/publish';
}

/**
 * Menu callback. Build form for editing channel filters
 *
 * @param $edit
 *   Array with form values
 *
 * @return
 *   HTML output
 */
function publish_channel_filter_form($edit = array()) {
  $channel_id = arg(3);
  $channel = publish_channel_load($channel_id);
  if (!$channel) {
    drupal_set_message(t('No such channel.'), 'error');
    drupal_goto('admin/publish');
  }
  $form['field'] = array(
    '#type' => 'select',
    '#title' => t('Field'),
    '#options' => publish_channel_filter_options()
    );
  foreach (publish_supported_operators() as $operator) {
    $operators[$operator] = $operator;
  }
  $form['operation'] = array(
    '#type' => 'select',
    '#title' => t('Condition'),
    '#options' => $operators
    );
  $form['value'] = array(
    '#type' => 'textfield',
    '#title' => t('Value'),
    '#size' => '25',
    '#maxlength' => '254'
    );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Add filter')
    );
  $form['channel_id'] = array(
    '#type' => 'value',
    '#value' => $channel_id);
  return drupal_get_form('publish_channel_filter_form', $form);
}

function theme_publish_channel_filter_form($form) {
  $channel = publish_channel_load($form['channel_id']['#value']);
  if (count($channel->filters)) {
    $output = t('The following filters are in effect for this channel:');
    $header = array(t('Field'), t('Condition'), t('Value'), t('Operation'));
    foreach ($channel->filters as $filter) {
      $operation = l(t('delete'), 'admin/publish/pub/filters/delete/' . $channel->channel_id . '/' .$filter['fid']);
      $rows[] = array(
        array('data' => $filter['field']),
        array('data' => $filter['condition']),
        array('data' => $filter['value']),
        array('data' => $operation)
        );
    }
    $output = theme('table', $header, $rows);
  }
  else {
    $output = t('No filters are currently defined.');
  }

  // we don't want theming so we do a table the old-fashioned way
  $output .= '<table><tr>';
  $output .= '<td>' . form_render($form['field']) . '<td>';
  $output .= '<td>' . form_render($form['operation']) . '<td>';
  $output .= '<td>' . form_render($form['value']) . '<td>';
  $output .= '<td>' . form_render($form['submit']) . '</td>';
  $output .= '</tr></table>';
  $output .= form_render($form);

  return $output;
}

function publish_channel_filter_options() {
  $v_names = array();
  if (module_exist('taxonomy')) {
    $vocabularies = taxonomy_get_vocabularies();
    foreach ($vocabularies as $v) {
      $v_names[$v->vid] = $v->name;
    }
  }
  $merged = array_merge($v_names, publish_supported_fields());
  foreach ($merged as $name) {
    $options[$name] = $name;
  }
  return $options;
}

function publish_channel_filter_form_validate($form_id, $edit) {
  $errors = array();

  if ($edit['field'] == '') {
    $errors['field'] = t('Please choose a field.');
  }
  elseif (!array_key_exists($edit['field'], publish_channel_filter_options())) {
    $errors['field'] = t('Invalid field.');
  }

  if (!in_array($edit['operation'], publish_supported_operators())) {
    $errors['operation'] = t('Invalid condition.');
  }

  foreach ($errors as $name => $message) {
    form_set_error($name, $message);
  }
}

function publish_channel_filter_form_submit($form_id, $form_values) {
  $channel = publish_channel_load($form_values['channel_id']);
  publish_channel_filter_save($channel, $form_values);
  drupal_set_message(t('Filter added.'));
  return 'admin/publish/filters/' . $form_values['channel_id'];
}

function publish_channel_filter_save(&$channel, $edit = array()) {
  $options = publish_channel_filter_options();
  $field = $options[$edit['field']];
  $condition = $edit['operation'];
  $value = $edit['value'];
  // get the new field, condition and value from the form
  // validate them (make sure they're not already in
  if (!isset($channel->filters)) {
    $channel->filters = array();
  }
  $duplicate = FALSE;
  foreach ($channel->filters as $filter) {
    if (($filter['field'] == $field) && ($filter['condition'] == $condition) && ($filter['value'] == $value)) {
      $duplicate = TRUE;
    }
  }
  if (!$duplicate) {
    $fid = db_next_id('publish_filter');
    $channel->filters[] = array('fid' => $fid, 'field' => $field, 'condition' => $condition, 'value' => $value);
    // the insertion of 0 into the sid (subscription id) field denotes
    // that this condition is a local channel condition
    db_query("INSERT INTO {publish_cond} (fid, channel_id, sid, field, cond, value) VALUES (%d, %d, 0, '%s', '%s', '%s')", $fid, $channel->channel_id, $field, $condition, $value);
  }
  else {
    drupal_set_message(t('This filter already exists.'), 'error');
  }
}

function publish_channel_filter_delete_form() {
  $channel_id = arg(5);
  $filter_id = arg(6);
  $channel = publish_channel_load($channel_id);
  if (!$channel) {
    drupal_set_message(t('No such channel.', 'error'));
    drupal_goto('admin/publish');
  }
  $form['channel_id'] = array('#type' => 'value', '#value' => $channel_id);
  $form['filter_id'] = array('#type' => 'value', '#value' => $filter_id);
  $output = confirm_form('publish_channel_filter_delete_form', $form,
                   t('Are you sure you want to delete this filter?'),
                   'admin/publish', t('This action cannot be undone.'),
                   t('Delete'), t('Cancel')  );
  return $output;
}

function publish_channel_filter_delete_form_submit($form_id, $form_values) {
  publish_channel_filter_delete($form_values['channel_id'], $form_values['filter_id']);
  return 'admin/publish/filters/' . $form_values['channel_id'];
}
function publish_channel_filter_delete($channel_id, $fid) {
  $data = db_fetch_object(db_query('SELECT pc.field, pc.cond, pc.value, pp.name FROM {publish_cond} as pc, {publish_channel} as pp WHERE pc.fid = %d AND pp.channel_id = %d', $fid, $channel_id));
  $filtertext = $data->field . ' ' . $data->cond . ' ' . $data->value;
  db_query('DELETE FROM {publish_cond} WHERE fid = %d', $fid);
  watchdog('special', t('Deleted filter %filter from channel %name.', array('%filter' => theme('placeholder', $filtertext), '%name' => $data->name)));
  drupal_set_message(t('Deleted filter %filter.', array('%filter' => theme('placeholder', $filtertext))));
}

/**
 * Load list of publishable node types from the database.
 *
 * @param $channel_id
 *   The ID of the channel in question.
 *
 * @return
 *   An array with node types as keys
 */
function publish_nodetypes_load($channel_id) {
  $types = array();

  $result = db_query('SELECT type FROM {publish_nodetypes} WHERE channel_id = %d', $channel_id);
  while ($data = db_fetch_object($result)) {
    $types[$data->type] = $data->type;
  }

  return $types;
}

/**
 * Save a channel to the database.
 *
 * @param $edit
 */
function publish_channel_save($edit) {
  if (!$edit['clean_domains']) $edit['clean_domains'] = '';
  $channel_id = $edit['channel_id'];
  $fields = publish_db_fields('publish_channel');

  // update if this channel_id already exists
  if (db_result(db_query('SELECT COUNT(channel_id) FROM {publish_channel} WHERE channel_id = %d', $channel_id))) {
    // Prepare the query:
    foreach ($edit as $key => $value) {
      if (in_array($key, $fields)) {
        $q[] = db_escape_string($key) ." = '%s'";
        $v[] = $value;
      }
    }
    db_query("UPDATE {publish_channel} SET ". implode(', ', $q) ." WHERE channel_id = ". db_escape_string($edit['channel_id']), $v);
     watchdog('special', t('%type: updated channel %name', array('%type' => '<em>'. t('publish') .'</em>', '%name' => "<em>" . $edit['name'] . "</em>")));
    drupal_set_message(t('Updated channel %name', array('%name' => theme('placeholder', $edit['name']))));
  }
  else {
    // create new channel
    if (!$channel_id) {
     $edit['channel_id'] = db_next_id('publish_channel');
    }

    // Prepare the query:
    foreach ($edit as $key => $value) {
      if (in_array((string) $key, $fields)) {
        $k[] = db_escape_string($key);
        $v[] = $value;
        $s[] = "'%s'";
      }
    }
    // Insert the node into the database:
    $query = "INSERT INTO {publish_channel} (". implode(", ", $k) .") VALUES(". implode(", ", $s) .")";
    db_query($query, $v);
    watchdog('special', t('%type: created channel %name.', array('%type' => '<em>'. t('publish') .'</em>', '%name' => "<em>" . $edit['name'] . "</em>")));
    drupal_set_message(t('Created channel %name', array('%name' => theme('placeholder', $edit['name']))));
  }
  return $edit['channel_id'];
}

/**
 * Menu callback.
 * The HTML form to confirm deletion of a channel.
 */
function publish_channel_delete_form() {
  $channel_id = arg(4);
  $channel = publish_channel_load($channel_id);
  if (!$channel) {
    drupal_set_message(t('No such channel.', 'error'));
    drupal_goto('admin/publish');
  }
  $form['channel_id'] = array('#type' => 'value', '#value' => $channel_id);
  $output = confirm_form('publish_delete_form', $form,
                   t('Are you sure you want to delete %title?', array('%title' => theme('placeholder', $channel->name))),
                   'admin/publish', t('This action cannot be undone.'),
                   t('Delete'), t('Cancel')  );
  return $output;
}

function publish_delete_form_submit($form_id, $form_values) {
  $channel = publish_channel_load($form_values['channel_id']);
  publish_channel_delete($channel);
  return 'admin/publish';
}

/**
 * Delete a channel.
 *
 * @param $channel
 *   a channel object
 */
function publish_channel_delete($channel) {
  db_query('DELETE FROM {publish_channel} WHERE channel_id = %d', $channel->channel_id);
  db_query("DELETE FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel->channel_id);
  db_query('DELETE FROM {publish_cond} WHERE channel_id = %d', $channel->channel_id);

  watchdog('publish', t('deleted channel %name.', array('%name' => $channel->name)));
}


/**
 * Form to set the publish settings for node types.
 */
function publish_node_form($channel_id, $edit = array()) {

  $nodetypes = array();
  foreach (node_list() as $type) {
    $nodetypes[$type] = node_invoke($type, 'node_name');
  }

  $published = array();
  $result = db_query("SELECT * FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel_id);
  while ($data = db_fetch_object($result)) {
    $published[] = $data->type;
  }


  $node_checkboxes = '';
  foreach ($nodetypes as $internal_type => $type) {
    $node_checkboxes .= form_checkbox($type, 'pub_' . $internal_type, $internal_type, in_array($internal_type, $published));
  }

  $output = form_group(t('Publish the following node types'), $node_checkboxes);
  $output .= form_hidden('channel_id', $channel_id);

  return $output;
}

/**
 * Save a nodetype config data to the database.
 */
function publish_node_save($edit) {

  $channel_id = $edit['channel_id'];
  $submitted_nodetypes = $edit['types'];

  /*

  $nodetypes = array();
  foreach (node_list() as $type) {
    $nodetypes[$type] = node_invoke($type, 'node_name');
    if ($edit['pub_' . $type]) {
      $submitted_nodetypes[$type] = $type;
    }
  }

  $result = db_query("SELECT * FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel_id);
  while ($data = db_fetch_object($result)) {
    if (key_exists($data->type, $submitted_nodetypes)) {
      // node type exists in database and has been checked; no change so delete from array
      unset($submitted_nodetypes[$data->type]);
    }
    else {
      // node type exists in database but not checked; delete from database
      db_query("DELETE FROM {publish_nodetypes} WHERE type = '%s'", $data->type);
    }
  }
  */
  db_query("DELETE FROM {publish_nodetypes} WHERE channel_id = %d", $channel_id);

  // now we are left with the node types to add
  foreach ($submitted_nodetypes as $type) {
    db_query("INSERT INTO {publish_nodetypes} (channel_id, type) VALUES ('%s', '%s')", $channel_id, $type);
  }
}


/**
 * Form to set the publish settings for vocabularies.
 */
function publish_vocabulary_form($channel_id) {
  $channel = publish_channel_load($channel_id);
  if (!$channel) {
    drupal_set_message(t('No such channel.', 'error'));
    drupal_goto('admin/publish');
  }

  if (!module_exist('taxonomy')) {
    drupal_set_message(t('The taxonomy module is disabled. Please enable the taxonomy module.'), 'warning');
    drupal_goto('/admin/publish');
  }

  $vocabularies = taxonomy_get_vocabularies();

  //this is where we would do vocabulary autoimport
  if (!$vocabularies) return $output . t('No vocabularies have been defined for this Drupal site. You will need to define vocabularies using administer -&gt; categories before you can publish them.');

  $result = publish_node_vocabularies($channel_id);
  $nodetypes = $result[0];
  $published_vocabularies = $result[1];
  // for each node type chosen for publication
  if ($nodetypes) {
    // probably want to clean this up by using theme('table')
    // header row
    $table = '<table>';
    $table .= '<th>' . t('Node Type') . '</th>';
    foreach ($vocabularies as $v) {
      $table .= '<th>' . $v->name . '</th>';
    }
    $table .= '</tr>';

    // data rows
    foreach ($nodetypes as $type => $friendly_type) {
      $table .= "<tr><td>$friendly_type</td>";

      // which vocabularies apply to this node type?
      $tax_voc_this_node = taxonomy_get_vocabularies($type);
      $tax_voc_ids = array();
      foreach ($tax_voc_this_node as $v) {
        $tax_voc_ids[$v->vid] = TRUE;
      }
      foreach ($vocabularies as $v) {
        $s = '';
        // if this vocabulary is applicable
        if (key_exists($v->vid, $tax_voc_ids)) {
          // add a checkbox, appropriately checked
          $form[$type . '|' . $v->name] = array(
            '#type' => 'checkbox',
            '#title' => '',
            '#value' => (int) key_exists((int) $v->vid, $published_vocabularies[$type]),
            '#parents' => array(),
            '#name' => 'edit[' . $type . '|' . $v->name . ']',
            '#return_value' => 1
            );
          $s = form_render($form[$type . '|' . $v->name]);
        }
        $table .= '<td>' . $s . '</td>';
      }
      $table .= '</tr>';
    }

    $form['markup'] = array(
      '#type' => 'markup',
      '#value' => theme('fieldset', array('#title' => t('Vocabularies to Publish'), '#children' => $table . '</table>')));
    $form['channel_id'] = array(
      '#type' => 'value',
      '#value' => $channel_id
    );
    $form['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Save vocabulary settings')
      );
  }
  else {
    // no node types have been chosen for publication
    drupal_set_message(t('No node types have been chosen for publication. Edit channel and choose at least one node type.'));
    drupal_goto('/admin/publish');
  }

  return drupal_get_form('publish_vocabulary_form', $form);
}

/**
 * Save a nodetype's configuration data to the database.
 *
 * @param $edit
 *   array from form
 */
function publish_vocabulary_form_submit($form_id, $edit) {
  $channel_id = $edit['channel_id'];

  // only step through nodes that user has chosen to publish
  $nodetypes = array();
  $result = db_query("SELECT * FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel_id);
  while ($data = db_fetch_object($result)) {
    $nodetypes[] = $data->type;
  }

  foreach ($nodetypes as $type) {
    $vocs_this_node = array();
    // get vocabularies specific to this node type
    $vocabularies = taxonomy_get_vocabularies($type);
    foreach ($vocabularies as $v) {
      $key = $type . '|' . $v->name;
      if ($_POST['edit'][$key]) { // hack; TODO: rewrite publish_vocabulary_form
        $vocs_this_node[$v->vid] = TRUE;
      }
    }
    db_query("DELETE FROM {publish_nodetypes} WHERE channel_id = '%s' AND type = '%s'", $channel_id, $type);
    db_query("INSERT INTO {publish_nodetypes} (channel_id, type, pub_vocab) VALUES ('%s', '%s', '%s')", $channel_id, $type, serialize($vocs_this_node));
  }
  $channel = publish_channel_load($channel_id);
  drupal_set_message(t("Saved vocabulary publication configuration for channel %name.", array('%name' => theme('placeholder', $channel->name))));

  return 'admin/publish';
}

/**
 * Retrieve configuration settings for a given nodetype.
 *
 * @param $type
 *   the internal type of a node, e.g. 'story'
 */
function publish_vocabulary_load($type) {
  static $config = array();

  if (!$config[$type]) {
    $data = db_fetch_object(db_query("SELECT * FROM {publish_nodetypes} WHERE type = '%s'", $type));
    if ($data->pub_vocab) {
      $data->pub_vocab = unserialize($data->pub_vocab);
    }
    $config[$type] = $data;
  }

  return $config[$type];
}

/**
 * Retrieve published node types and published vocabularies for those node types
 *
 * @param $channel_id
 *   the ID of the channel
 *
 * @return
 *   array containing
 *   - an associative array of published node type names keyed by internal node type name
 *   - an associative array of published vocabularies keyed by internal node type name
 */
 function publish_node_vocabularies($channel_id) {
  static $nodetypes = array();
  static $published_vocabularies = array();

  $lookup = node_get_types();
  $result = db_query("SELECT * FROM {publish_nodetypes} WHERE channel_id = '%s'", $channel_id);
  while ($data = db_fetch_object($result)) {
    $nodetypes[$data->type] = $lookup[$data->type];
    if ($data->pub_vocab) {
      $published_vocabularies[$data->type] = unserialize($data->pub_vocab);
    }
    else {
      $published_vocabularies[$data->type] = array();
    }
  }

  return array($nodetypes, $published_vocabularies);
 }

 /**
  * Get the list of subscribers for a channel.
  *
  * @param $channel_id
  *   the ID of the channel
  *
  * @return
  *   an HTML table of subscribers and related information
  */
 function publish_subscribers () {
   $channel_id = arg(3);
   $channel = publish_channel_load($channel_id);
   $output = '<h3>' . t('Subscribers to channel') . " '$channel->name':</h3>";
    $header = array(array('data' => t('Subscriber')), array('data' => t('Status')), array('data' => 'Operations', 'colspan' => '1'));
   $row = array();

   $result = db_query("SELECT url, sub_status FROM {publish_subscribers} WHERE channel_id = '%s'", $channel_id);
   while ($data = db_fetch_object($result)) {
    // build table
    $row[] = array(array('data' => $data->url), array('data' => $data->sub_status), array('data' => ''));
   }
    $output .= ($row) ? theme('table', $header, $row) : '<p>' . t('No one is currently subscribed to this channel.') . '</p>';

  return $output;
 }

/**
 * Compile array of publishable nodes according to given conditions.
 *
 * @param $channel_id
 *   The ID of the channel in question.
 *
 * @param $cond
 *   Array of triplet arrays containing field, condition, value.
 *   Example: array(array('created', '>', '0'))
 *   Example: array(array('created', '>', '0'), array('nid', '<', '5'))
 *
 * @return
 *   An array of node objects.
 */
function publish_publish($channel_id, $cond) {
  static $channels = array();

  if (isset($channels[$channel_id])) {
    $channel = $channels[$channel_id];
  }
  else {
    $channel = publish_channel_load($channel_id);
    $channels[$channel_id] = $channel;
  }
  $node_ids = array();
  $published_types = publish_nodetypes_load($channel_id);
  if (!$published_types) return array();

  $where = '';
  foreach ($published_types as $type) {
    $where .= "OR type = '" . (function_exists('db_escape_string') ? db_escape_string($type) : check_query($type)) . "' ";
  }
  // strip off leading 'OR '
  $where = $where ? '(' . strstr($where, " ") . ')' : '';

  list($clean_cond, $taxonomy_cond) = publish_cond_validate(array_merge($channel->filters, $cond));
  $filter = array();

  foreach ($clean_cond as $triplet) {
    $field = $triplet['field'];
    $operator = $triplet['operator'];
    $value = $triplet['value'];

    // check if value is numeric. If not, put single quotes around it and clean it
    $quot_start  = ' ';
    $quot_end    = ' ';
    $clean_value = null;;

    if (!is_numeric($value)) {
      $quot_start = " '";
      $quot_end   = "' ";
      $clean_value = function_exists('db_escape_string') ? db_escape_string($value) : check_query($value);
    }

    $filter[] = $field . ' ' . $operator . $quot_start . ($clean_value ? $clean_value : $value) . $quot_end;
  }

  if ($filter) {
    $where .= $filter[1] ? implode($filter, ' AND') : ' AND ' . $filter[0];
  }

  $result = db_query("SELECT nid FROM {node} WHERE $where");
  while ($data = db_fetch_object($result)) {
    $node_ids[] = $data->nid;
  }

  return _publish_publish($node_ids, $taxonomy_cond);
}

/**
 * Return an object representing a subscription to this site.
 *
 * @param $sid
 *   the ID of the subscription
 */
function publish_subscriptions_load($sid) {
  return db_fetch_object(db_query('SELECT * FROM {publish_subscribers} WHERE sid = %d', $sid));
}

/**
 * Push content in the publication queue out to subscribers
 */
function publish_push() {
  global $base_url;
  $qtime = variable_get('publish_queue_time', 300); // 5 minutes
  // this loops through the queue (oldest nodes first) with a time window set by qtime
  // qtime should be long enough that an attempt to send each item
  // in the queue can be made within the time window
  // we use db_fetch_object() to get one node at a time
  while ($data = db_fetch_object(db_query("SELECT * FROM {publish_queue} WHERE last_attempt < %d ORDER BY changed", time() - $qtime))) {
    if (PUBLISH_DEBUG_MODE) watchdog('publish', t('beginning push for channel %channel, subscriber %subscriber', array('%channel' => $data->channel_id, '%subscriber' => $data->sid)));

    // see if there are any other nodes we can include for this subscriber
    // while we have the overhead of sending xmlrpc anyway
    $node_ids = array();
    $qids = array();
    $result = db_query("SELECT qid, nid, attempts FROM {publish_queue} WHERE sid = %d AND channel_id = %d", $data->sid, $data->channel_id);
    while ($row = db_fetch_object($result)) {
      if (PUBLISH_DEBUG_MODE) watchdog('publish', t('preparing to push qid %qid; nid %nid', array('%qid' => $row->qid, '%nid' => $row->nid)));
      $node_ids[] = $row->nid;
      $qids[$row->nid] = array('qid' => $row->qid, 'attempts' => $row->attempts);
    }
    $nodes = array();
    foreach ($node_ids as $nid) {
      // run the nodes through the channel's condition filters
      // note that if push is happening from nodeapi insert/update (not cron),