modules/decisions/decisions.module

<?php

/**
 * @file
 *
 * Modular voting mechanisms, delegatable votes, taxonomy/category
 * influenced controls and weighted voting
 *
 * See http://decisions.gnuvernment.org for more information on the project.
 *
 * Heavily inspired by other Drupal modules, mostly from poll.module,
 * but we adapted it to "drupal forms api".  Thanks to everyone for
 * all the that was already written. (...and debugged!)
 */

// $Id: decisions.module,v 1.221 2009/08/19 22:34:36 anarcat Exp $

define('DECISIONS_DEFAULT_ELECTORAL_LIST', 0);
// always, aftervote, or afterclose
define('DECISIONS_DEFAULT_VIEW_RESULTS', 'aftervote');
define('DECISIONS_RUNTIME_INFINITY', 0);


/**
 * hook_init() implementation
 *
 * Most of the stuff here is in subfiles now.
 *
 * Decision modes are in seperate modules in modes/*.module
 */
function decisions_init() {
  // extension files are included here in order to lighten Drupal bootstrap
  drupal_add_css(drupal_get_path('module', 'poll') .'/poll.css');
}

/**
 * Implementation of hook_access().
 */
function decisions_access($op, $node, $account) {
  if ($op == 'create') {
    return user_access('create decisions', $account);
  }
  if ($op == 'delete') {
    return user_access('delete decisions', $account);
  }
  if ($op == 'update') {
    /* you can update it if you can create it, provided it is your own... */
    if (user_access('create decisions', $account) && ($account->uid == $node->uid)) {
      return TRUE;
    }
  }
}

/**
 * Implementation of hook_block().
 */
function decisions_block($op = 'list', $delta = 'mostrecent', $edit = array()) {
  if ($op == 'list') {
    $block = array('mostrecent' => array('info' => t('Decisions - Newest')));
  }
  elseif ($op == 'view') {
    if (user_access('view decisions')) {
      switch ($delta) {
      case 'mostrecent':
        $block = array('subject' => t('Decisions - Newest'), 'content' => _decisions_block_mostrecent());
        break;
      default:
        $block = array();
        break;
      }
    }
  }
  return $block;
}

/**
 * Implementation of hook_cron().
 *
 * Closes decisions that have exceeded their allowed runtime.
 */
function decisions_cron() {
  $result = db_query('SELECT d.nid FROM {decisions} d INNER JOIN {node} n ON d.nid = n.nid WHERE (d.startdate + d.runtime) < '. time() .' AND d.active = 1 AND d.runtime <> 0');
  while ($decision = db_fetch_object($result)) {
    db_query("UPDATE {decisions} SET active = 0 WHERE nid=%d", $decision->nid);
  }
}

/**
 * Implementation of votingapi_hook_calculate()
 */
function decisions_votingapi_calculate(&$cache, $votes, $content_type, $content_id) {
  if ($content_type == 'decisions') {
    $node = node_load($content_id);
    $mode = _decisions_get_mode($node);
    $function = "{$mode}_decisions_votingapi_calculate";
    if (function_exists($function)) {
      return call_user_func($function, $node, $cache, $votes, $content_type, $content_id);
    }
  }
}

/**
 * Implementation of hook_help().
 */
function decisions_help($path, $arg) {
  switch ($path) {
  case 'admin/modules#description':
    return t('Allow people to reproduce and surpass the kinds of decision-making instances that exist in face-to-face meetings.');
  }
}

/**
 * Implementation of hook_menu().
 *
 * Just a path for creating new decisions for now, but we could
 * eventually have a 'my decisions' and 'view decisions' kind of
 * page. (TODO)
 */
function decisions_menu() {
  $items['admin/settings/decisions'] = array(
    'title' => 'Configure decisions',
    'description' => 'Configure Decisions',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('decisions_admin'),
    'access arguments' => array('administer decisions'),
    'type' => MENU_NORMAL_ITEM,
   );

  $items['node/%node/votes'] = array(
    'title' => 'Votes',
    'page callback' => 'decisions_votes_tab',
    'page arguments' => array(1),
    'access callback' => '_decisions_votes_access',
    'access arguments' => array(1, 'inspect all votes'),
    'weight' => 4,
    'type' => MENU_LOCAL_TASK
  );
  $items['node/%node/results'] = array(
    'title' => 'Results',
    'page callback' => 'decisions_results',
    'page arguments' => array(1),
    'access callback' => '_decisions_can_view_results',
    'access arguments' => array(1),
    'weight' => 1, 	 
    'type' => MENU_LOCAL_TASK);
  $items['node/%node/electoral_list'] = array(
    'title' => 'Electoral list',
    'page callback' => 'decisions_electoral_list_tab',
    'page arguments' => array(1),
    'access callback' => '_decisions_electoral_list_access',
    'access arguments' => array(1, 'view electoral list'),
    'weight' => 2,
    'type' => MENU_LOCAL_TASK
  );
  // Allow voters to be removed
  $items['node/%node/remove'] = array(
    'page callback' => 'decisions_electoral_list_remove_voter',
    'page arguments' => array(1, 3),
    'access callback' => '_decisions_electoral_list_access',
    'access arguments' => array(1, 'remove voters'),
    'weight' => 3,
    'type' => MENU_CALLBACK,
  );
  $items['node/%node/reset'] = array(
    'title' => 'Reset votes',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('decisions_reset_form', 1),
    'access callback' => '_decisions_reset_access',
    'access arguments' => array(1, 'administer decisions'),
    'weight' => 3,
    'type' => MENU_LOCAL_TASK,
  );
  $items['decisions/add_choices_js'] = array(
    'page callback' => 'decisions_add_choices_js',
    'type' => MENU_CALLBACK,
    'access arguments' => array('create decisions'),
  );

  return $items;
}

/**
 * Implementation of hook_perm().
 */
function decisions_perm() {
  return array('create decisions', 'delete decisions', 'view decisions', 'vote on decisions', 'cancel own vote', 'administer decisions', 'inspect all votes', 'view electoral list', 'remove voters');
}

/**
 * Implementation of the admin_settings hook
 */
function decisions_admin() {

  $enabled = array(0 => t('Disabled'), 1 => t('Enabled'));

  $form['main']['decisions_default_electoral_list'] = array(
                                                            '#type' => 'radios',
                                                            '#title' => t('Use electoral list by default'),
                                                            '#description' => t('Use an electoral list by default for new decisions.'),
                                                            '#default_value' => variable_get('decisions_default_electoral_list', DECISIONS_DEFAULT_ELECTORAL_LIST),
                                                            '#options' => $enabled,
                                                            );

  $view_results = array(
                        'always' => t('Always'),
                        'aftervote' => t('After user has voted'),
                        'afterclose' => t('After voting has closed'),
                        );

  $form['main']['decisions_view_results'] = array(
                                                  '#type' => 'radios',
                                                  '#title' => t('When should results be displayed'),
                                                  '#description' => t('Determines when users may view the results of the decision.'),
                                                  '#default_value' => variable_get('decisions_view_results', DECISIONS_DEFAULT_VIEW_RESULTS),
                                                  '#options' => $view_results,
                                                  );

  return system_settings_form($form);
}

function decisions_cancel_form($form_state, $nid) {
  $form['node'] = array('#type' => 'hidden', '#value' => $nid);
  $form['submit'] = array('#type' => 'submit', '#value' => t('Cancel your vote'));
  return $form; 
}

function decisions_cancel_form_submit($form, &$form_state) {
  decisions_cancel($form_state['values']['node']);
}

/*******************/
/* Theme functions */
/*******************/

function decisions_theme($existing, $type, $theme, $path) {
  return array(
    'decisions_view_header' => array('arguments' => array('node' => NULL, 'teaser' => FALSE)),
    'decisions_view_voting' => array('arguments' => array('form' => NULL)),
    'decisions_bar' => array('arguments' => array('title' => NULL, 'percentage' => NULL, 'votes' => NULL)),
    'decisions_status' => array('arguments' => array('message' => NULL)),
    'decisions_morechoices' => array('arguments' => array(), 'decisions_morechoices' => NULL),
    'decisions_view_own_result' => array(),
    );
}

function theme_decisions_view_own_result() {
  $output = '<div class="decisions-own-result">' . t("Your vote has been recorded.") . '</div>';
  return $output;
}

/**
 * Theme stub for rendering ecisions header (contains dates and quorum informations).
 */
function theme_decisions_view_header($node, $teaser = FALSE) {

  $output = '<div class="decisions-header">';

  // dates
  $output .= '<div class="decisions-dates">';
  $output .= theme('item_list',
              array(
                 t('Current date: @date', array('@date' => format_date(time()))),
                 t('Opening date: @date', array('@date' => format_date($node->startdate))),
                 ($node->runtime == DECISIONS_RUNTIME_INFINITY ? 
                   t('No closing date.') :
                   t('Closing date: @date', array('@date' => format_date($node->startdate + $node->runtime))))));
  $output .= '</div>';

  // votes
  $num_eligible_voters = _decisions_count_eligible($node);
  $num_voters = _decisions_count_voters($node);
  $output .= '<div class="decisions-votes">';
  $output .= t('@num-voters out of @num-voters-eligible eligible @voters cast their ballot',
               array(
                 '@num-voters' => $num_voters,
                 '@num-voters-eligible' => $num_eligible_voters,
                 '@voters' => format_plural($num_eligible_voters, 'voter', 'voters')
               )
              );
  $output .= '</div>';

  // quorum
  $quorum = _decisions_get_quorum($node);
  if ($quorum > 0) {
    $output .= '<div class="decisions-quorum">';
    $output .= t('Quorum: @d', array('@d' => $quorum));
    $output .= '</div>';
  }
    
  $output .= '</div>';
  return $output;
}

/**
 * Theme stub for redering the voting form, to allow the chance for
 * themes to make this nicer/different
 */
function theme_decisions_view_voting($form) {
  
  $render = 'drupal_render';
  if (!function_exists($render)) {
    $render = 'form_render';
  }
  $output .= '<div class="decisions">';
  $output .= '  <div class="choice-form">';
  $output .= '    <div class="choices">';
  $output .= $render($form['choice']);
  $output .= '    </div>';
  $output .= $render($form['nid']);
  $output .= $render($form['vote']);
  $output .= '  </div>';
  $output .= $render($form);
  $output .= '</div>';
  return $output;
}

/**
 * Theme stub for a decisions bar.
 */
function theme_decisions_bar($title, $percentage, $votes) {
  $output = '<div class="text">'. $title .'</div>';
  $output .= '<div class="bar"><div style="width: '. $percentage .'%;" class="foreground"></div></div>';
  $output .= '<div class="percent">'. $percentage .'% ('. $votes .')</div>';
  return $output;
}
 
/**
 * Outputs a status line.
 */
function theme_decisions_status($message) {
  return '<div class="error">'. $message .'</div>';
}


/****************************/
/* Electoral list functions */
/****************************/

/**
 * Creates the form for the electoral list.
 */
function decisions_electoral_list_form($form_state, $nid) {
  $form = array();
  $form['electoral_list'] = array(
                                  '#type' => 'fieldset',
                                  '#tree' => TRUE,
                                  '#title' => t('Administer electoral list'),
                                  '#collapsible' => TRUE,
                                  '#weight' => 2,
                                  '#collapsed' => TRUE,
                                  );

  $form['electoral_list']['add_user'] = array(
                                              '#type' => 'textfield',
                                              '#title' => t('Add user'),
                                              '#size' => 40,
                                              '#autocomplete_path' => 'user/autocomplete',
                                              '#description' => t('Add an individual user to the electoral list'),
                                              );

  $form['electoral_list']['submit'] = array(
                                            '#type' => 'submit',
                                            '#value' => t('Modify electoral list'),
                                            );

  $form['electoral_list']['reset'] = array(
                                           '#type' => 'button',
                                           '#value' => t('Reset electoral list'),
                                           );

  $form['nid'] = array('#type' => 'hidden', '#value' => $nid);
  return $form;        

}

/**
 * Outputs the electoral list tab.
 */
function decisions_electoral_list_tab() {
  if ($node = menu_get_object()) {
    $output = "";
    if (!$node->uselist) {
      drupal_not_found();
      return;
    }
    drupal_set_title(check_plain($node->title));
    if (user_access('administer decisions')) {
      $form['electoral_list'] = array(
                                      '#type' => 'fieldset',
                                      '#tree' => TRUE,
                                      '#title' => t('Administer electoral list'),
                                      '#collapsible' => TRUE,
                                      '#weight' => 2,
                                      '#collapsed' => TRUE,
                                      );
  	 
      $form['electoral_list']['add_user'] = array(
                                                  '#type' => 'textfield',
                                                  '#title' => t('Add user'),
                                                  '#size' => 40,
                                                  '#autocomplete_path' => 'user/autocomplete',
                                                  '#description' => t('Add an individual user to the electoral list'),
                                                  );
  	 
      $form['electoral_list']['submit'] = array(
                                                '#type' => 'submit',
                                                '#value' => t('Modify electoral list'),
                                                );
  	 
      $form['electoral_list']['reset'] = array(
                                               '#type' => 'button',
                                               '#value' => t('Reset electoral list'),
                                               );
  	 
      $form['nid'] = array('#type' => 'hidden', '#value' => $node->nid);
      $output .= drupal_get_form('decisions_electoral_list_form', $node->nid);
    }
    $output .= t('This table lists all the eligible voters for this Decision.');

    $header[] = array('data' => t('Voter'), 'field' => 'u.name');

    $result = pager_query("SELECT u.uid, u.name FROM {decisions_electoral_list} el LEFT JOIN {users} u ON el.uid = u.uid WHERE el.nid = %d" . tablesort_sql($header), 20, 0, NULL, $node->nid);
    $eligible_voters = array();
    while ($voter = db_fetch_object($result)) {
      $temp = array(theme('username', $voter));
      
      if (user_access('administer decisions')) {
        $temp[] = l(t('remove'), 'node/'. $node->nid .'/remove/'. $voter->uid);
      }
      
      $eligible_voters[] = $temp;
    }
    $output .= theme('table', $header, $eligible_voters);
    $output .= theme('pager', NULL, 20, 0);
    print theme('page', $output);
  }
  else {
    drupal_not_found();
  }
}

/**
 * Remove an individual voter from the electoral list
 */
function decisions_electoral_list_remove_voter($node, $uid) {
  # XXX: useless SELECT call
  $result = db_query('SELECT name FROM {users} WHERE uid=%d', $uid);
  if ($user = db_fetch_object($result)) {
    db_query('DELETE FROM {decisions_electoral_list} WHERE nid=%d AND uid=%d', $node->nid, $uid);
    drupal_set_message(t('%user removed from the electoral list.', array('%user' => $user->name)));
  }
  else {
    drupal_set_message(t('No user found with a uid of %uid.', array('%uid' => $uid)));
  }
  
  drupal_goto('node/'. $node->nid .'/electoral_list');
}
  	 
/**
 * Validate changes to the electoral list
 */
function decisions_electoral_list_form_validate($form, &$form_state) {
  if ($form_state['values']['op'] == t('Reset electoral list')) {
    if (user_access('administer decisions')) {
      db_query('DELETE FROM {decisions_electoral_list} WHERE nid=%d', $form_state['values']['nid']);
      drupal_set_message(t('Electoral list cleared.'));
      $node = menu_get_object();
      if (_decisions_electoral_list_reset($node)) {
        drupal_set_message(t('Electoral list reset.'));
      }
      return;
    }
  }
  $add_user = $form_state['values']['electoral_list']['add_user'];
  if ($add_user) {
    // Check that the user exists
    if (!db_fetch_object(db_query('SELECT uid FROM {users} WHERE name="%s"', $add_user))) {
      form_set_error('electoral_list][add_user', t('User %user does not exist.', array('%user' => $add_user)));
      return FALSE;
    }
  }
  else {
    form_set_error('electoral_list][add_user', t('Please enter a user.'));
    return FALSE;
  }
}
  	 
/**
 * Submit changes to the electoral list
 */
function decisions_electoral_list_form_submit($form, &$form_state) {
  $add_user = $form_state['values']['electoral_list']['add_user'];
  $nid = $form_state['values']['nid'];
  if ($add_user) {
    db_query('REPLACE INTO {decisions_electoral_list} (nid, uid) SELECT "%d", u.uid FROM {users} u WHERE u.name = "%s"', $nid, $add_user);
    drupal_set_message(t('%user added to electoral list.', array('%user' => $add_user)));
    drupal_goto('node/'. $nid .'/electoral_list');
  }
  else {
    drupal_not_found();
  }
}


/***********************************/
/* Decision-mode related functions */
/***********************************/

/**
 * Show results of the vote.
 *
 * This calls the appropriate vote results function, depending on the
 * mode. It will call the decisions_view_results_$mode hook.
 */
function decisions_view_results(&$node, $teaser, $page) {
  $mode = _decisions_get_mode($node);
  $function = "{$mode}_decisions_view_results";
  if (function_exists($function)) {
    return call_user_func($function, $node, $teaser, $page);
  }
  else {
    _decisions_panic_on_mode($mode, __FUNCTION__);
  }
}

/**
 * View the voting form.
 *
 * This calls a function decisions_vote_$mode, where $mode is defined
 * in the node. If the function does not exist, a watchdog error is
 * raised and the error is reported using drupal_set_message().
 *
 * This also takes care of registering new votes, if the vote button
 * has been pressed.
 */
function decisions_voting_form($form, &$node, $teaser = FALSE, $page = FALSE) {
  $mode = _decisions_get_mode($node);
  if (function_exists("{$mode}_decisions_voting_form")) {
    return call_user_func("{$mode}_decisions_voting_form", $node, $teaser, $page);
  }
  else {
    _decisions_panic_on_mode($mode, __FUNCTION__);
  }
}

function decisions_voting_form_submit($form, &$form_state) {
  $node = node_load($form_state['values']['nid']);
  decisions_vote($node, $form_state['values']);
  drupal_set_message(t('Your vote was registered.'));
  // Transferring makes the results tab display correctly
  drupal_goto('node/'. $node->nid);
}

/**
 * Validate vote form submission
 *
 * This will call a hook named decisions_vote_validate_$mode and
 * return its value. hooks should check $POST to see if the vote data
 * submitted is valid and use form_set_error() if the form has invalid
 * data.
 *
 * @returns boolean true if form has valid data or if no hook is
 * defined in mode
 */
function decisions_voting_form_validate($form, &$form_state) {
  $node = node_load($form_state['values']['nid']);
  $mode = _decisions_get_mode($node);
  if (function_exists("{$mode}_decisions_vote_validate") ) {
    return call_user_func("{$mode}_decisions_vote_validate", $node, $form_state['values']);
  }
  return TRUE;
}

/**
 * Record a vote on the node.
 *
 * This calls the appropriate vote recording function, depending on
 * the mode. It will call the decisions_vote_$mode hook.
 */
function decisions_vote($node, $form_values) {
  $mode = _decisions_get_mode($node);
  $ok = FALSE; // error by default
  if (_decisions_eligible($node)) {
    if (function_exists("{$mode}_decisions_vote")) {
      call_user_func("{$mode}_decisions_vote", $node, $form_values);
    }
    else {
      _decisions_panic_on_mode($mode, __FUNCTION__);
    }
  }
  else {
    drupal_set_message(t('You are not eligible to vote on this decision.'));
  }
}

/**
 * Helper function to list algorithms for a given mode
 */
function decisions_algorithms($mode) {
  $algs = array();
  if (function_exists("{$mode}_decisions_algorithms")) {
    $algs = call_user_func("{$mode}_decisions_algorithms");
    $error = FALSE;
    if (!is_array($algs)) {
      $error = t('Element returned by the call to function @function is not an array, returning dummy value.', 
                    array('@function' => "decisions_{$mode}_algorithms"));
    }
    else if (count($algs) == 0) {
      $error = t('Array returned by the call to function @function is empty, returning dummy value.', 
                    array('@function' => "decisions_{$mode}_algorithms"));      
    }
    if ($error) {
      watchdog('decisions', $error, WATCHDOG_WARNING);
      drupal_set_message($error, 'warning');
    }
  }
  else {
    _decisions_panic_on_mode($mode, __FUNCTION__);
  }
  return $algs;
}


/*************/
/* Callbacks */
/*************/

/**
 * Callback for canceling a vote.
 */
function decisions_cancel($nid) {
  if ($node = node_load($nid)) {
    if ($node->voted && $node->active) {
      $criteria = votingapi_current_user_identifier();
      $criteria['content_type'] = 'decisions';
      $criteria['content_id'] = $node->nid;
      votingapi_delete_votes(votingapi_select_votes($criteria));
      drupal_set_message(t('Your vote was canceled.'));
    }
    else {
      drupal_set_message(t("You are not allowed to cancel an invalid choice."), 'error');
    }
    drupal_goto('node/'. $nid);
  }       
  else {
    drupal_not_found();
  }
}

/**
 * Callback to display the votes tab.
 */
function decisions_votes_tab() {
  if ($node = menu_get_object()) {
    if (!$node->showvotes) {
      // Decision is set to not allow viewing of votes
      drupal_not_found();
      return;
    }
    drupal_set_title(check_plain($node->title));
    $output = t('This table lists all the recorded votes for this Decision. If anonymous users are allowed to vote, they will be identified by the IP address of the computer they used when they voted.');

    $header[] = array('data' => t('Visitor'), 'field' => 'u.name');
    $header[] = array('data' => t('Vote'), '');

    /* this query will group all the vote of a user in one record so that the pager can deal with it
     *
     * the "votes" column will look something like: 
     *
     *  v1=>t1,v2=>t2
     *
     * for a table like this:
     *
     * uid | v1 | t1
     * uid | v2 | t2
     *
     * where vN are values and tN are tags (tags being the choice being made and values the score given to it)
     *
     * XXX: highly MySQL specific
     */
    $query = 'SELECT u.name, v.uid, v.vote_source, GROUP_CONCAT(DISTINCT CONCAT(v.value,"=>",v.tag) ORDER BY v.value) as votes FROM {votingapi_vote} v LEFT JOIN {users} u ON v.uid = u.uid WHERE v.content_id = %d GROUP BY v.uid' . tablesort_sql($header) . '';
    $query_count = 'SELECT COUNT(DISTINCT v.uid) FROM {votingapi_vote} v LEFT JOIN {users} u ON v.uid = u.uid WHERE v.content_id = %d GROUP BY content_id'. tablesort_sql($header);
    $result = pager_query($query, variable_get('decisions_votes_per_page', 20), 0, $query_count, $node->nid);
    $votes = array();
    $names = array();
    while ($vote = db_fetch_object($result)) {
      $key = $vote->uid? $vote->uid : $vote->vote_source;
      $choices = explode(',', $vote->votes);
      foreach ($choices as $choice) {
        $choice = explode("=>", $choice);
        $votes[$key][] = (object) array('value' => $choice[0], 'tag' => $choice[1]);
      }
      $names[$key] = $vote->name ? theme('username', $vote) : check_plain($vote->vote_source);
    }

    $mode = _decisions_get_mode($node);
    $function_format_votes = "{$mode}_decisions_format_votes";
    if (!function_exists($function_format_votes)) {
      _decisions_panic_on_mode($mode, __FUNCTION__);
      drupal_not_found();
    }
    
    $rows = array();
    foreach ($names as $key => $name) {
      $rows[$key]['name'] = $name;
      $rows[$key]['vote'] = call_user_func($function_format_votes, $node, $votes[$key]);
    }

    $output .= theme('table', $header, $rows);
    $output .= theme('pager', array(), variable_get('decisions_votes_per_page', 20), 0);
    print theme('page', $output);
  }
  else {
    drupal_not_found();
  }
}

/**
 * Callback for 'results' tab for decisions you can vote on. 	 
 */ 	 
function decisions_results() { 	 
  if ($node = menu_get_object()) { 	 
    drupal_set_title(check_plain($node->title)); 	 
    return node_show($node, 0); 	 
  } 	 
  else { 	 
    // The url does not provide the appropriate node id 	 
    drupal_not_found(); 	 
  } 	 
}

 /**
 * Callback to display a reset votes confirmation form
 */
function decisions_reset_form($form_state, $node) {
  $form['nid'] = array('#type' => 'hidden', '#value' => $node->nid);
  return confirm_form($form,
                         t('Are you sure you want to reset the votes for !title?',
                           array('!title' => theme('placeholder', $node->title))),
                         'node/'. $node->nid,
                         t('This action cannot be undone.'),
                         t('Reset votes'),
                         t('Cancel') );
}

/**
 * Reset votes once the confirmation is given
 */
function decisions_reset_form_submit($form, &$form_state) {
  $nid = $form_state['values']['nid'];
  // Delete any votes for the poll
  db_query("DELETE FROM {votingapi_vote} WHERE content_id = %d", $nid);
  drupal_set_message('Votes have been reset.');
  drupal_goto('node/'. $nid);
}

/**
 * Return the mode of a decision based on its type
 */
function _decisions_get_mode($node) {
  if ($node->type) {
    $types = explode('_', $node->type, 2);
    return $types[1];
  }
  else {
    drupal_set_message('No type specified for node: '. $node->nid, 'error');
    return '';
  }
}

/**
 * Callback function to see if a node is acceptable for poll menu items.
 */
function _decisions_votes_access($node, $perm) {
	return user_access($perm) && $node->showvotes && strpos($node->type, 'decisions_') === 0;
}

function _decisions_reset_access($node, $perm) {
	return user_access($perm) && strpos($node->type, 'decisions_') === 0;
}

function _decisions_electoral_list_access($node, $perm) {
  return user_access($perm) && $node->uselist;
}

/**
 * Function that tells if the given decision is open to votes.
 */
function _decisions_is_open($node) {
  $time = time();
  return ($node->active &&                    // node must be active
          // current time must be past start date and before end date
          ($time >= $node->startdate) &&
          ($node->runtime == DECISIONS_RUNTIME_INFINITY ||
           $time < ($node->startdate + $node->runtime)));
}

/**
 * Function that tells if the given user can vote on this decision.
 */
function _decisions_can_vote($node, $user = NULL) {
  return (_decisions_is_open($node) &&         // node must be open
          !$node->voted &&                    // user should not have already voted
          _decisions_eligible($node, $user));  // user must be eligible to vote
}

/**
 * Function that tells if the given decision meets the quorum.
 */
function _decisions_meets_quorum($node) {
  // compute number of people that have cast their vote
  $num_voters = _decisions_count_voters($node);
  $quorum = _decisions_get_quorum($node);
  return ($num_voters >= $quorum);
}


/**
 * Internal function factored out that just rings lots of bells when
 * we detect an unknown mode.
 */
function _decisions_panic_on_mode($mode, $function = '') {
  watchdog('decisions', 'Unknown decision mode : @mode in "@function".', array('@mode' => $mode, '@function' => $function, WATCHDOG_ERROR));
  drupal_set_message(t('Unknown decision mode : @mode in "@function".', array('@mode' => $mode, '@function' => $function), 'error'));
}

/**
 * Get all votes from the given node.
 */
function _decisions_votes($node) {
  $votes = array();
  // we bypass votingapi because we need ORDER BY value ASC lets us ensure no gaps
  $result = db_query("SELECT * FROM {votingapi_vote} v WHERE content_type='%s' AND content_id='%d' ORDER BY value ASC", 'decisions', $node->nid);
  while ($vobj = db_fetch_array($result)) {
    $votes[] = $vobj;
  }
  return $votes;
}

/**
 * Count the elligible voters for a given decision.
 */
function _decisions_count_eligible($node) {
  if ($node->uselist) {
    $result = db_fetch_object(db_query("SELECT COUNT(*) AS num FROM {decisions_electoral_list} WHERE nid=%d", $node->nid));
  }
  else {
    // check first if authenticated users have the right to vote, because
    // authenticated users are not added to the users_roles permission,
    // probably for performance reasons
    $roles = user_roles(FALSE, 'vote on decisions');
    if ($roles[DRUPAL_AUTHENTICATED_RID]) {
      // special case: any authenticated user can vote
      // consider all current to be elligible
      $result = db_fetch_object(db_query("SELECT COUNT(*) AS num FROM {users} u WHERE u.uid <> 0"));
    }
    else {
      // only some roles are elligible, add relevant users only
      $result = db_fetch_object(db_query("SELECT COUNT(DISTINCT ur.uid) AS num FROM {users_roles} ur JOIN {permission} p ON ur.rid = p.rid WHERE FIND_IN_SET(' vote on decisions', p.perm) AND ur.uid <> 0"));
    }
  }
  return $result->num;    
}

/**
 * Returns the quorum (minimum voters) of a node.
 */
function _decisions_get_quorum($node) {
  $num_eligible_voters = _decisions_count_eligible($node);
  $quorum = $node->quorum_abs + ceil(($node->quorum_percent / 100.0) * $num_eligible_voters);
  return min($quorum, $num_eligible_voters);
}

/**
 * Count the number of distinct voters.
 */
function _decisions_count_voters($node) {
  $num_voters = 0;
  if ($result = db_fetch_object(db_query("SELECT COUNT(DISTINCT CONCAT(uid,vote_source)) AS voters FROM {votingapi_vote} WHERE content_id=%d", $node->nid))) {
    $num_voters = $result->voters;
  }
  return $num_voters;
}

/**
 * Get all votes by uid in a an array, in a uid => votes fashion.
 */
function _decisions_user_votes($node) {
  $votes = _decisions_votes($node);
  
  // aggregate votes by user (uid if logged in, IP if anonymous)
  // in ascending order of value
  $user_votes = array();

  foreach ($votes as $vote) {
    $key = ($vote->uid == 0 ? $vote->vote_source: $vote->uid);
    $user_votes[$key][] = $vote;
  }
  
  return $user_votes;
}

/**
 * Check if user is eligible to this decision.
 */
function _decisions_eligible($node, $uid = NULL) {
  global $user;
  if (is_null($uid)) {
    $uid = $user->uid;
  }

  if ($node->uselist) {
    $can_vote = db_fetch_object(db_query("SELECT COUNT(*) AS eligible FROM {decisions_electoral_list} WHERE nid=%d AND uid=%d", $node->nid, $uid));
    $eligible = $can_vote->eligible;
  }
  else {
    $eligible = user_access('vote on decisions');
  }
  return $eligible;
}

/**
 * Constructs the time select boxes.
 * 
 * @ingroup event_support
 * @param $timestamp The time GMT timestamp of the event to use as the default
 *   value.
 * @return An array of form elements for month, day, year, hour, and minute
 */
function _decisions_form_date($timestamp) {
  // populate drop down values...
  // ...months
  $months = array(1 => t('January'), t('February'), t('March'), t('April'), t('May'), t('June'), t('July'), t('August'), t('September'), t('October'), t('November'), t('December'));
  // ...hours
  if (variable_get('event_ampm', '0')) {
    $hour_format = t('g');
    $hours = drupal_map_assoc(range(1, 12));
    $am_pms = array('am' => t('am'), 'pm' => t('pm'));
  }
  else {
    $hour_format = t('H');
    $hours = drupal_map_assoc(range(0, 23));
  }
  // ...minutes (with leading 0s)
  for ($i = 0; $i <= 59; $i++) $minutes[$i] = $i < 10 ? "0$i" : $i;

  // This is a GMT timestamp, so the _event_date() wrapper to display local times.
  $form['day'] = array(
    '#prefix' => '<div class="container-inline"><div class="day">',
    '#type' => 'textfield',
    '#default_value' => _decisions_date('d', $timestamp),
    '#maxlength' => 2,
    '#size' => 2,
    '#required' => TRUE);
  $form['month'] = array(
    '#type' => 'select',
    '#default_value' => _decisions_date('n', $timestamp),
    '#options' => $months,
    '#required' => TRUE);
  $form['year'] = array(
    '#type' => 'textfield',
    '#default_value' => _decisions_date('Y', $timestamp),
    '#maxlength' => 4,
    '#size' => 4,
    '#required' => TRUE);
  $form['hour'] = array(
    '#prefix' => '</div>&#8212;<div class="time">',
    '#type' => 'select',
    '#default_value' => _decisions_date($hour_format, $timestamp),
    '#options' => $hours,
    '#required' => TRUE);
  $form['minute'] = array(
    '#prefix' => ':',
    '#type' => 'select',
    '#default_value' => _decisions_date('i', $timestamp),
    '#options' => $minutes,
    '#required' => TRUE);
  if (isset($am_pms)) {
    $form['ampm'] = array(
      '#type' => 'radios',
      '#default_value' => _decisions_date('a', $timestamp),
      '#options' => $am_pms,
      '#required' => TRUE);
  }
  $form['close'] = array(
    '#type' => 'markup',
    '#value' => '</div></div>');

  return $form;
}

/**
 * Takes a time element and prepares to send it to form_date()
 * 
 * @param $time
 *   The time to be turned into an array. This can be:
 *   - a timestamp when from the database
 *   - an array (day, month, year) when previewing
 *   - null for new nodes
 * @returnn
 *   an array for form_date (day, month, year)
 */
function _decisions_form_prepare_datetime($time = '', $offset = 0) {
  // if this is empty, get the current time
  if ($time == '') {
    $time = time();
    $time = strtotime("+$offset days", $time);
  }
  // If we are previewing, $time will be an array so just pass it through
  $time_array = array();
  if (is_array($time)) {
    $time_array = $time;
  } 
  // otherwise build the array from the timestamp
  elseif (is_numeric($time)) {
    $time_array = array(
      'day' => _decisions_date('j', $time),
      'month' => _decisions_date('n', $time),
      'year' => _decisions_date('Y', $time),
      'hour' => _decisions_date('H', $time),
      'min' => _decisions_date('i', $time),
      'sec' => _decisions_date('s', $time),
    );
  }
  // return the array
  return $time_array;
}

/**
 * Content of the block, as returned by decisions_block('view')
 */
function _decisions_block_mostrecent() {
  $output = '';
  $result = db_query_range('SELECT nid FROM {decisions} WHERE active=1 ORDER BY nid DESC', 1);
  // Check that there is an active decision
  if ($decision = db_fetch_object($result)) {
    $n = decisions_view(node_load($decision->nid), FALSE, FALSE, TRUE);
    /* XXX: we have to do this because somehow the #printed settings lives across multiple node_load */
    unset($n->content['#printed']);
    $output = drupal_render($n->content);
  }
  else {
    $output = t('No active decisions.');
  }
  return $output;
}

/**
 * Returns true if the user can view the results of current node.
 */
function _decisions_can_view_results($node) {
  $view_results = variable_get('decisions_view_results', DECISIONS_DEFAULT_VIEW_RESULTS);
  return (_decisions_meets_quorum($node) && // node meets the quorum
          strpos($node->type, 'decisions_') === 0 &&
          (!_decisions_is_open($node)       // node is closed
          || ($node->voted && $view_results == 'aftervote') // user voted
          || ($view_results == 'always'))); // all can view
}

/**
 * Insert the right users in the electoral list
 */
function _decisions_electoral_list_reset($node) {
  // check first if authenticated users have the right to vote, because authenticated users are not added to the users_roles permission, probably for performance reasons
  $result = db_fetch_object(db_query("SELECT COUNT(*) AS hit FROM {permission} JOIN role ON role.rid = permission.rid WHERE FIND_IN_SET(' vote on decisions', perm) AND role.name = 'authenticated user'"));
  if (isset($result) && $result->hit) {
    // special case: any authenticated user can vote
    // add all current users to electoral list
    return db_query("INSERT INTO {decisions_electoral_list} (nid, uid) SELECT '%d', u.uid FROM users u WHERE u.uid <> 0", $node->nid);
  }
  else {
    // all users must not be allowed to vote, add relevant users only
    return db_query("INSERT INTO {decisions_electoral_list} (nid, uid) SELECT '%d', u.uid FROM users_roles u, permission p WHERE FIND_IN_SET(' view decisions', p.perm) AND u.rid = p.rid AND u.uid <> 0", $node->nid);
  }

}

/**
 * Implementation of hook_load().
 *
 * Load the votes and decision-specific data into the node object.
 */
function decisions_load($node) {
  $decision = db_fetch_object(db_query("SELECT * FROM {decisions} WHERE nid = %d", $node->nid));
  $result = db_query("SELECT vote_offset, label FROM {decisions_choices} WHERE nid = %d ORDER BY vote_offset", $node->nid);
  while ($choice = db_fetch_array($result)) {
    $decision->choice[$choice['vote_offset']] = $choice;
  }
  $decision->choices = count($decision->choice);

  // See if user has voted
  $criteria = votingapi_current_user_identifier();
  $criteria['content_type'] = 'decisions';
  $criteria['content_id'] = $node->nid;
  $decision->voted = count(votingapi_select_votes($criteria)) > 0;

  return $decision;
}

/**
 * Implementation of hook_delete().
 *
 */
function decisions_delete($node) {
  db_query("DELETE FROM {decisions} WHERE nid = %d", $node->nid);
  db_query("DELETE FROM {decisions_choices} WHERE nid = %d", $node->nid);
  db_query("DELETE FROM {decisions_electoral_list} WHERE nid = %d", $node->nid);

  // Note: this should be converted to a votingapi method eventually
  db_query("DELETE FROM {votingapi_vote} WHERE content_id = %d", $node->nid);
}

/**
 * Implementation of hook_insert()
 *
 * This is called upon node creation
 */
function decisions_insert($node) {
  // Compute startdate and runtime.
  $startdate = _decisions_translate_form_date($node->settings['date']['startdate']['date']);
  if ($node->settings['date']['noenddate']) {
    $runtime = DECISIONS_RUNTIME_INFINITY;
  }
  else {
    $enddate =  _decisions_translate_form_date($node->settings['date']['enddate']['date']);
    if ($enddate < $startdate) {
      form_set_error('enddate', t('The specified close date is less than the opening date, setting it to the same for now.'));
      $enddate = $startdate;
    }
    $runtime = $enddate - $startdate;
  }
  
  // just create an empty entry for now
  $mode = _decisions_get_mode($node);

  db_query("INSERT INTO {decisions} (nid, mode, quorum_abs, quorum_percent, uselist, active, runtime, maxchoices, algorithm, startdate, randomize) VALUES (%d, '%s', %d, %f, %d, %d, %d, %d, '%s', %d, %d)", $node->nid, $mode, $node->settings['quorum']['quorum_abs'], $node->settings['quorum']['quorum_percent'], $node->settings['uselist'], $node->settings['active'], $node->settings['runtime'], $node->settings['maxchoices'], $node->settings['algorithm'], $startdate, $node->settings['randomize']);

  // create the electoral list if desired

  if ($node->settings['uselist']) {
    _decisions_electoral_list_reset($node);
  }

  // insert the choices, same sequence than update
  decisions_update($node);
}

/**
 * Implementation of hook_validate().
 *
 * XXX: No validation yet.
 */
function decisions_validate(&$node) {
  // Use form_set_error for any errors
  $node->choice = array_values($node->choice);

  // Start keys at 1 rather than 0
  array_unshift($node->choice, '');
  unset($node->choice[0]);

  // Check for at least two choices
  $realchoices = 0;
  foreach ($node->choice as $i => $choice) {
    if ($choice['label'] != '') {
      $realchoices++;
    }
  }

  if ($realchoices < 2) {
    form_set_error("choice][$realchoices][label", t('You must fill in at least two choices.'));
  }

  $startdate 