<?php
// $Id: scheduler.module,v 1.50.2.36 2010/05/02 16:36:06 ericschaefer Exp $

define('SCHEDULER_DATE_FORMAT', 'Y-m-d H:i:s');

/**
 * Implementation of hook_perm().
 */
function scheduler_perm() {
  return array('schedule (un)publishing of nodes', 'administer scheduler');
}

/**
 * Implementation of hook_menu().
 */
function scheduler_menu() {
  $items = array();
  $items['scheduler/cron'] = array(
    'title' => 'Light weight cron handler',
    'description' => 'A light weight cron handler to allow more frequent runs of Schedulers internal cron system',
    'page callback' => '_scheduler_run_cron',
    'access callback' => TRUE,
    'type' => MENU_CALLBACK,
  );
  $items['scheduler/timecheck'] = array(
    'title' => 'Test your servers UTC clock',
    'description' => 'Allows site admin to check their servers internal clock',
    'page callback' => '_scheduler_timecheck',
    'access arguments' => array('access administration pages'),
    'type' => MENU_CALLBACK,
  );
  $items['admin/settings/scheduler'] = array(
    'title' => 'Scheduler module settings',
    'description' => 'Allows site admins to configure scheduler.',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('scheduler_admin'),
    'access arguments' => array('administer scheduler'),
    'type' => MENU_NORMAL_ITEM,
  );
  $items['admin/content/node/scheduler'] = array(
    'type' => MENU_LOCAL_TASK,
    'title' => 'Scheduled',
    'page callback' => 'scheduler_list',
    'access callback' => 'scheduler_list_access_callback',
    'description' => 'Display a list of scheduled nodes',
  );
  return $items;
}

/**
 * Return the users access to the scheduler list page. Separate function required because of the two access values to be checked.
 */
function scheduler_list_access_callback() {
  return user_access('administer nodes') && user_access('schedule (un)publishing of nodes');
}

function scheduler_admin() {
  $form['scheduler_date_format'] = array(
    '#type' => 'textfield',
    '#title' => t('Date format'),
    '#default_value' => variable_get('scheduler_date_format', SCHEDULER_DATE_FORMAT),
    '#size' => 20,
    '#maxlength' => 20,
    '#description' => t('The input format for the (un)scheduling time/date. See the date() function for formatting options: http://www.php.net/manual/en/function.date.php (only the following format characters are supported (don\'t use \'G\', \'a\' or \'A\' with Date Popup): djmnyYhHgGisaA)'),
  );
  return system_settings_form($form);
}

/**
 * Implementation of hook_form_alter().
 */
function scheduler_form_alter(&$form, $form_state, $form_id) {
  //allow scheduling on a per-node-type basis

  if ('node_type_form' == $form_id) {
    $form['workflow']['scheduler'] = array(
      '#type' => 'checkbox',
      '#title' => t('Enable scheduled (un)publishing'),
      '#default_value' => variable_get('scheduler_'. $form['#node_type']->type, 0),
      '#description' => t('Check this box to enable scheduled (un)publishing for this node type.')
    );
    $form['workflow']['scheduler_touch'] = array(
      '#type' => 'checkbox',
      '#title' => t('Alter published on time'),
      '#default_value' => variable_get('scheduler_touch_'. $form['#node_type']->type, 0),
      '#description' => t('Check this box to alter the published on time to match the scheduled time ("touch feature").')
    );
  }

  // is this a node form?
  elseif (isset($form['type']['#value']) && $form['type']['#value'] .'_node_form' == $form_id) {
    if (user_access('schedule (un)publishing of nodes')) {
      // if scheduling has been enabled for this node type
      if (variable_get('scheduler_'. $form['type']['#value'], 0) == 1) {

        $node = $form['#node'];

        $date_format = variable_get('scheduler_date_format', SCHEDULER_DATE_FORMAT);
        $internal_date_format = module_exists('date_popup') ? SCHEDULER_DATE_FORMAT : $date_format;

        // if this is a preview then get the values from the form, not the db
        if (isset($form_state['values']['op']) && $form_state['values']['op'] == 'Preview') {
          $defaults = new StdClass;
          $defaults->publish_on = $form_state['values']['publish_on'];
          $defaults->unpublish_on = $form_state['values']['unpublish_on'];
        }
        elseif (isset($node->nid) && $node->nid > 0) {
          // load the values if we are viewing an existing node
          $defaults = db_fetch_object(db_query('SELECT publish_on, unpublish_on FROM {scheduler} WHERE nid = %d', $node->nid));
        }
        else {
          // init standard values
          $defaults = new StdClass;
          $defaults->publish_on = $defaults->unpublish_on = NULL;
        }

        // if there is a text value then convert it to a unix timestamp
        if (isset($defaults->publish_on) && $defaults->publish_on && !is_numeric($defaults->publish_on)) {
          $defaults->publish_on = _scheduler_strtotime($defaults->publish_on);
        }
        if (isset($defaults->unpublish_on) && $defaults->unpublish_on && !is_numeric($defaults->unpublish_on)) {
          $defaults->unpublish_on = _scheduler_strtotime($defaults->unpublish_on);
        }

        $form['scheduler_settings'] = array(
          '#type' => 'fieldset',
          '#title' => t('Scheduling options'),
          '#collapsible' => TRUE,
          '#collapsed' => ((isset($defaults->publish_on) && $defaults->publish_on != 0) || (isset($defaults->unpublish_on) && $defaults->unpublish_on != 0)) ? FALSE: TRUE,
          '#weight' => 35,
          '#group' => 'additional_settings',
          '#attached' => array(
            'js' => array(
              'vertical-tabs' => drupal_get_path('module', 'scheduler') . "/scheduler_vertical_tabs.js"
            ),
          )
        );

        $form['scheduler_settings']['publish_on'] = array(
          '#type' => 'textfield',
          '#title' => t('Publish on'),
          '#maxlength' => 25,
          '#default_value' => isset($defaults->publish_on) && $defaults->publish_on ? format_date($defaults->publish_on, 'custom', $internal_date_format) : '',
          '#description' => t('Format: %time. Leave blank to disable scheduled publishing.', array('%time' => format_date(time(), 'custom', $date_format))),
        );

        $form['scheduler_settings']['unpublish_on'] = array(
          '#type' => 'textfield',
          '#title' => t('Unpublish on'),
          '#maxlength' => 25,
          '#default_value' => isset($defaults->unpublish_on) && $defaults->unpublish_on ? format_date($defaults->unpublish_on, 'custom', $internal_date_format) : '',
          '#description' => t('Format: %time. Leave blank to disable scheduled unpublishing.', array('%time' => format_date(time(), 'custom', $date_format))),
        );

        if (module_exists('date_popup')) {
          // Make this a popup calendar widget if Date Popup module is enabled.
          $form['scheduler_settings']['publish_on']['#type'] = 'date_popup';
          $form['scheduler_settings']['publish_on']['#date_format'] = $date_format;
          $form['scheduler_settings']['publish_on']['#date_year_range'] = '0:+10';
          $form['scheduler_settings']['publish_on']['#description'] = t('Leave blank to disable scheduled publishing.');
          unset($form['scheduler_settings']['publish_on']['#maxlength']);
          $form['scheduler_settings']['unpublish_on']['#type'] = 'date_popup';
          $form['scheduler_settings']['unpublish_on']['#date_format'] = $date_format;
          $form['scheduler_settings']['unpublish_on']['#date_year_range'] = '0:+10';
          $form['scheduler_settings']['unpublish_on']['#description'] = t('Leave blank to disable scheduled unpublishing.');
          unset($form['scheduler_settings']['unpublish_on']['#maxlength']);
        }
      }
    }
  }
}

/*
 * Displays a list of nodes that are scheduled for (un)publication. This will
 * appear as a tab on the content admin page ('admin/content/node').
 */
function scheduler_list() {
  $header = array(
    array('data' => t('Title'), 'field' => 'n.title'),
    array('data' => t('Author'), 'field' => 'u.name'),
    array('data' => t('Publish on'), 'field' => 's.publish_on'),
    array('data' => t('Unpublish on'), 'field' => 's.unpublish_on'),
    array('data' => t('Operations'))
  );

  // Default ordering
  if (!isset($_GET['order']) && !isset($_GET['sort'])) {
    $_GET['order'] = t('Publish on');
    $_GET['sort'] = 'ASC';
  }

  $sql = 'SELECT n.nid, n.uid, n.status, u.name, n.title, s.publish_on, s.unpublish_on FROM {scheduler} s LEFT JOIN {node} n ON s.nid = n.nid LEFT JOIN {users} u ON n.uid = u.uid' . tablesort_sql($header);
  $result = pager_query($sql, 50);

  while ($node = db_fetch_object($result)) {
    $rows[] = array(
      l($node->title, "node/$node->nid"),
      theme('username', $node),
      ($node->publish_on ? format_date($node->publish_on) : '&nbsp;'),
      ($node->unpublish_on ? format_date($node->unpublish_on) : '&nbsp;'),
      l(t('edit'), 'node/'. $node->nid .'/edit', array(), 'destination=admin/content/node/scheduler'),
    );
  }

  if (count($rows)) {
    if ($pager = theme('pager', NULL, 50, 0)) {
      $rows[] = array(array('data' => $pager, 'colspan' => 6));
    }

    print theme('page', theme('table', $header, $rows));
  }
  else {
    print theme('page', t('There are no scheduled nodes.'));
  }
}

/**
 * Converts an english time string ('Y-m-d H:i:s') from the users timezone into an unix timestamp
 * @param string $str the time string ('Y-m-d H:i:s')
 * @return the time in unix timestamp representation (utc);
 * NULL, if $str is NULL, FALSE, empty, or contains only white spaces;
 * FALSE, if $str is malformed
 */
function _scheduler_strtotime($str) {
  if ($str && trim($str) != "" ) {
    $date_format = variable_get('scheduler_date_format', SCHEDULER_DATE_FORMAT);
    if (module_exists('date_popup')) {
      $date_format = SCHEDULER_DATE_FORMAT;
    }
    $time=_scheduler_strptime(trim($str), $date_format);
    if ($time!==FALSE) {
      // success
      $time -= _scheduler_get_user_timezone();
    }
  }
  else {
    // $str is empty
    $time = NULL;
  }
  return $time;
}

/**
 * Parse a time/date as UTC time
 *
 * @param string $date The string to parse
 * @param string $format The format used in $date. See date() (http://www.php.net/manual/en/function.date.php)
 * specification for format options. Right now only dHhmiaAsyY are supported.
 * @return the parsed time as a UTC timestamp
 * @see date()
 */
function _scheduler_strptime($date, $format) {
  # we need to build a regex pattern for the date format
  $date_entities = array('d', 'H', 'h', 'm', 'i', 'a', 'A', 's', 'y', 'Y', 'n', 'j', 'g', 'G');
  $date_regex_replacements = array('(\d{2})', '(\d{2})', '(\d{2})', '(\d{2})', '(\d{2})', '([ap]m)', '([AP]M)', '(\d{2})', '(\d{2})', '(\d{4})', '(\d{1,2})', '(\d{1,2})', '(\d{1,2})', '(\d{1,2})');
  $custom_pattern = str_replace($date_entities, $date_regex_replacements, $format);
  if (!preg_match("#$custom_pattern#", $date, $value_matches)) {
    return FALSE;
  }

  if (!preg_match_all("/(\w)/", $format, $entity_matches)) {
    return FALSE;
  }

  $results = array('day' => 0, 'hour' => 0, 'month' => 0, 'minute' => 0, 'meridiem' => NULL, 'second' => 0, 'year' => 0);
  $index = 1;
  foreach ($entity_matches[1] as $entity) {
    $value = intval($value_matches[$index]);
    switch ($entity) {
      case 'd':
      case 'j':
        $results['day'] = $value;
        break;
      case 'H':
      case 'h':
      case 'g':
      case 'G':
        $results['hour'] = $value;
        break;
      case 'm':
      case 'n':
        $results['month'] = $value;
        break;
      case 'i':
        $results['minute'] = $value;
        break;
      case 'a':
      case 'A':
        $results['meridiem'] = $value_matches[$index];
        break;
      case 's':
        $results['second'] = $value;
        break;
      case 'y':
      case 'Y':
        $results['year'] = $value;
        break;
    }
    $index++;
  }
  if ((strncasecmp($results['meridiem'], "pm", 2) == 0) && ($results['hour'] <= 12)) {
    $results['hour'] += 12;
  }

  $time = gmmktime( $results['hour'], $results['minute'], $results['second'], $results['month'], $results['day'], $results['year'] );
  return $time;
}

/**
 * Gets the users timezone if configurable timezones are enabled or otherwise the default timezone of the site
 *
 * @return the offset of the users timezone in seconds
 */
function _scheduler_get_user_timezone() {
  global $user;
  $timezone = variable_get('date_default_timezone', 0);
  if ((variable_get('configurable_timezones', 1) == 1) && (strlen($user->timezone))) {
    $timezone = $user->timezone;
  }
  return $timezone;
}

/**
 * Implementation of hook_nodeapi().
 */
function scheduler_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) {
  // Run $op == load for any user.
  if ($op == 'load') {
    if (isset($node->nid) && $node->nid && variable_get('scheduler_'. $node->type, 0) == 1) {
      $result = db_query('SELECT * FROM {scheduler} WHERE nid = %d', $node->nid);
      if ($result) {
        $row = db_fetch_array($result);
        if (isset($row['nid'])) {
          unset($row['nid']);
          $node->publish_on = $row['publish_on'];
          $node->unpublish_on = $row['unpublish_on'];
          $row['published'] = $row['publish_on'] ? date(variable_get('date_format_long', 'l, F j, Y - H:i'), $row['publish_on']) : NULL;
          $row['unpublished'] = $row['unpublish_on'] ? date(variable_get('date_format_long', 'l, F j, Y - H:i'), $row['unpublish_on']) : NULL;
          $node->scheduler = $row;
        }
      }
    }
  }
  elseif (user_access('schedule (un)publishing of nodes')) {
    switch ($op) {
      case 'view':
        if (isset($a4) && $a4 && isset($node->unpublish_on) && $node->unpublish_on) {
          $unavailable_after = date("d-M-Y H:i:s T", $node->unpublish_on);
          drupal_set_html_head('<meta name="googlebot" content="unavailable_after: '. $unavailable_after .'" />');
        }
        break;
      case 'validate':
      case 'presave':
        // adjust the entered times for timezone consideration.
        // Note, we must check to see if the value is numeric,
        // if it is, assume we have already done the strtotime
        // conversion. This prevents us running strtotime on
        // a value we have already converted. This is needed
        // because DRUPAL6 removed 'submit' and added 'presave'
        // and all this happens at different times.

        $date_format = variable_get('scheduler_date_format', SCHEDULER_DATE_FORMAT);

        if (isset($node->publish_on) && $node->publish_on && !is_numeric($node->publish_on)) {
          $publishtime = _scheduler_strtotime($node->publish_on);
          if ($publishtime === FALSE) {
            form_set_error('publish_on', t("The 'publish on' value does not match the expected format of %time", array('%time' => format_date(time(), 'custom', $date_format))));
          }
          elseif ($publishtime && $publishtime < time()) {
            form_set_error('publish_on', t("The 'publish on' date must be in the future"));
          }
          else {
            $node->publish_on = $publishtime;
          }
        }

        if (isset($node->unpublish_on) && $node->unpublish_on && !is_numeric($node->unpublish_on)) {
          $unpublishtime = _scheduler_strtotime($node->unpublish_on);
          if ($unpublishtime === FALSE) {
            form_set_error('unpublish_on', t("The 'unpublish on' value does not match the expected format of %time", array('%time' => format_date(time(), 'custom', $date_format))));
          }
          elseif ($unpublishtime && $unpublishtime < time()) {
            form_set_error('unpublish_on', t("The 'unpublish on' date must be in the future"));
          }
          else {
            $node->unpublish_on = $unpublishtime;
          }
        }

        if (isset($publishtime) && isset($unpublishtime) && $unpublishtime < $publishtime) {
          form_set_error('unpublish_on', t("The 'unpublish on' date must be later than the 'publish on' date."));
        }

        // Right before we save the node, we need to check if a "publish on" value has been set.
        // If it has been set, we want to make sure the node is unpublished since it will be published at a later date
        if (isset($node->publish_on) && $node->publish_on != '' && is_numeric($node->publish_on) && $node->publish_on > time()) {
          $node->status = 0;
        }
        break;
      case 'insert':
        // only insert into database if we need to (un)publish this node at some date
        if (isset($node->nid) && $node->nid && (isset($node->publish_on) && $node->publish_on != NULL) || (isset($node->unpublish_on) && $node->unpublish_on != NULL)) {
          db_query('INSERT INTO {scheduler} (nid, publish_on, unpublish_on) VALUES (%d, %d, %d)', $node->nid, $node->publish_on, $node->unpublish_on);
        }
        break;
      case 'update':
        if (isset($node->nid) && $node->nid) {
          $exists = db_result(db_query('SELECT nid FROM {scheduler} WHERE nid = %d', $node->nid));

          // if this node has already been scheduled, update its record
          if ($exists) {
            // only update database if we need to (un)publish this node at some date
            // otherwise the user probably cleared out the (un)publish dates so we should remove the record
            if (($node->status == 0 && isset($node->publish_on) && $node->publish_on != NULL) || (isset($node->unpublish_on) && $node->unpublish_on != NULL)) {
              db_query('UPDATE {scheduler} SET publish_on = %d, unpublish_on = %d WHERE nid = %d', $node->publish_on, $node->unpublish_on, $node->nid);
            }
            else {
              db_query('DELETE FROM {scheduler} WHERE nid = %d', $node->nid);
            }
          }
          // node doesn't exist, create a record only if the (un)publish fields are blank
          elseif ((isset($node->publish_on) && $node->publish_on != NULL) || (isset($node->unpublish_on) && $node->unpublish_on != NULL)) {
            db_query('INSERT INTO {scheduler} (nid, publish_on, unpublish_on) VALUES (%d, %d, %d)', $node->nid, $node->publish_on, $node->unpublish_on);
          }
        }
        break;
      case 'delete':
        if (isset($node->nid) && $node->nid) {
          db_query('DELETE FROM {scheduler} WHERE nid = %d', $node->nid);
        }
        break;
    }
  }
}

/**
 * Implementation of hook_cron().
 */
function scheduler_cron() {
  $clear_cache = FALSE;

  // if the time now is greater than the time to publish a node, publish it
  $nodes = db_query('SELECT * FROM {scheduler} s LEFT JOIN {node} n ON s.nid = n.nid WHERE n.status = 0 AND s.publish_on > 0 AND s.publish_on < %d ', time());

  while ($node = db_fetch_object($nodes)) {
    $n = node_load($node->nid);
    $n->changed = $node->publish_on;
    if (variable_get('scheduler_touch_'. $n->type, 0) == 1) {
      $n->created = $node->publish_on;
    }

    // Use the actions system to publish the node.
    watchdog('scheduler', '@type: scheduled publishing of %title.', array('@type' => $n->type, '%title' => $n->title), WATCHDOG_NOTICE, l(t('view'), 'node/'. $n->nid));
    $actions = array('node_publish_action', 'node_save_action');
    $context['node'] = $n;
    actions_do($actions, $n, $context, NULL, NULL);

    // if this node is not to be unpublished, then we can delete the record
    if (isset($n->unpublish_on) && $n->unpublish_on == 0) {
      db_query('DELETE FROM {scheduler} WHERE nid = %d', $n->nid);
    }
    // we need to unpublish this node at some time so clear the publish on since it's been published
    else {
      db_query('UPDATE {scheduler} SET publish_on = 0 WHERE nid = %d', $n->nid);
    }

    // invoke scheduler API
    _scheduler_scheduler_api($n, 'publish');

    $clear_cache = TRUE;
  }

  // if the time is greater than the time to unpublish a node, unpublish it
  $nodes = db_query('SELECT * FROM {scheduler} s LEFT JOIN {node} n ON s.nid = n.nid WHERE n.status = 1 AND s.unpublish_on > 0 AND s.unpublish_on < %d', time());

  while ($node = db_fetch_object($nodes)) {
    // if this node is to be unpublished, we can update the node and remove the record since it can't be republished
    $n = node_load($node->nid);
    $n->changed = $node->unpublish_on;

    // Use the actions system to unpublish the node.
    watchdog('scheduler', '@type: scheduled unpublishing of %title.', array('@type' => $n->type, '%title' => $n->title), WATCHDOG_NOTICE, l(t('view'), 'node/'. $n->nid));
    $actions = array('node_unpublish_action', 'node_save_action');
    $context['node'] = $n;
    actions_do($actions, $n, $context, NULL, NULL);
    db_query('DELETE FROM {scheduler} WHERE nid = %d', $n->nid);

    // invoke scheduler API
    _scheduler_scheduler_api($n, 'unpublish');

    $clear_cache = TRUE;
  }

  if ($clear_cache) {
    // clear the cache so an anonymous poster can see the node being published or unpublished
    cache_clear_all();
  }
}

/**
 * Implementation of hook_theme().
 */
function scheduler_theme() {
  return array(
    'scheduler_timecheck' => array(
      'arguments' => array('now' => NULL),
    ),
  );
}

function _scheduler_run_cron() {
  watchdog('scheduler', 'Internal scheduler run activated', array(), WATCHDOG_NOTICE);
  scheduler_cron();
  if (ob_get_level() > 0) {
    $handlers = ob_list_handlers();
    if (isset($handlers[0]) && $handlers[0] == 'default output handler') {
      ob_clean();
    }
  }
  exit();
}

/**
 * Scheduler API to perform actions when nodes are (un)published
 *
 * @param $node
 *  The node object
 * @param $action
 *  The action being performed, either "publish" or "unpublish"
 */
function _scheduler_scheduler_api($node, $action) {
  foreach (module_implements('scheduler_api') as $module) {
    $function = $module .'_scheduler_api';
    $function($node, $action);
  }
}

function _scheduler_timecheck() {
  $now = time();
  return theme('scheduler_timecheck', $now);
}

function theme_scheduler_timecheck($now) {

  drupal_set_title(t('Scheduler OS time check'));

  $t = localtime($now, TRUE);

  $lt = ($t['tm_year']+1900) .'-'. ($t['tm_mon']+1) .'-'. $t['tm_mday'] .' '. $t['tm_hour'] .':'. $t['tm_min'] .':'. $t['tm_sec'];

  $t_options = array(
    '%time' => date("Y-m-d H:i:s", $now),
    '%lt' => $lt,
  );

  return
    t('Your server reports the UTC time as %time and "localtime" as %lt.', $t_options) .
   '<p />'.
    t('If all is well with your server\'s time configuration UTC should match <a target="_blank" href="http://wwp.greenwichmeantime.com/">UTC London Time</a> and the localtime should be the time where you are.') .
    '<p />'.
    t('If this is not the case please have your Unix System Administrator fix your servers time/date configuration.');
}

/**
 * Implementation of "contrib module views" hook_views_tables()
 */
function scheduler_views_api() {
  $info['api'] = 2;
  return $info;
}

/**
 * Implementation of hook_content_extra_fields().
 */
function scheduler_content_extra_fields($type_name) {
  $fields = array();
  if (variable_get('scheduler_'. $type_name, 0) == 1) {
    $fields['scheduler_settings'] = array(
      'label' => t('Scheduler'),
      'description' => t('Scheduler module form.'),
      'weight' => 10,
    );
  }

  return $fields;
}
