modules/advpoll/advpoll.module

<?php
// $Id: advpoll.module,v 1.44 2006/11/28 06:54:15 chriskennedy Exp $
/**
 * @file
 * Advanced Poll - a sophisticated polling module for voting, elections, and group decision-making.
 */


define('ADVPOLL_DEFAULT_ELECTORAL_LIST', 0);
// always, aftervote, or afterclose
define('ADVPOLL_DEFAULT_VIEW_RESULTS', 'aftervote');

/**
 * Implementation of hook_access().
 */
function advpoll_access($op, $node) {
  global $user;

  if ($op == 'create') {
    return user_access('create polls');
  }
  if ($op == 'delete') {
    return user_access('delete polls');
  }
  if ($op == 'update') {
    if (user_access('create polls') && ($user->uid == $node->uid)) {
      return TRUE;
    }
  }
}

/**
 * Implementation of hook_block().
 */
function advpoll_block($op = 'list', $delta = 'mostrecent', $edit = array()) {
  switch($op) {
    case 'list':
      $blocks['mostrecent']['info'] = t('Advanced Poll - Newest');
      return $blocks;
    case 'view':
      if (user_access('view polls')) {
        switch ($delta) {
          case 'mostrecent': default:
            $block['content'] = advpoll_block_mostrecent();
            $block['subject'] = t('Advanced Poll - Newest');
        }

        if ($block['content']) {
          return $block;
        }
      }
    default:
  }
}

/**
 * Content of the block, as returned by advpoll_block('view')
 */
function advpoll_block_mostrecent() {
  $output = '';
  $result = db_query('SELECT nid FROM {advpoll} WHERE active=1 ORDER BY nid DESC LIMIT 1');
  // Check that there is an active poll
  if (db_num_rows($result) > 0) {
    $poll = db_fetch_object($result);
    $node = advpoll_view(node_load($poll->nid), FALSE, FALSE, TRUE);
    $output = drupal_render($node->content);
  }
  else {
    $output .= t('No active Advanced Poll.');
  }
  return $output;
}

/**
 *
 */
function advpoll_page() {
  // List all polls
  $sql = 'SELECT n.nid, n.title, p.active, n.created, c.value AS votes FROM {node} n INNER JOIN {advpoll} p ON n.nid = p.nid INNER JOIN {votingapi_cache} c ON n.nid = c.content_id WHERE n.status = 1 AND c.tag = "_advpoll" AND c.function="total_votes" AND c.content_type="advpoll" GROUP BY n.nid, n.title, p.active, n.created ORDER BY n.created DESC';
  $sql = db_rewrite_sql($sql);
  $result = pager_query($sql, 15);
  $output = '<ul>';
  while ($node = db_fetch_object($result)) {
    $output .= '<li>'. l($node->title, "node/$node->nid") .' - '. format_plural($node->votes, '1 vote', '@count votes') .' - '. ($node->active ? t('open') : t('closed')) .'</li>';
  }
  $output .= '</ul>';
  $output .= theme('pager', NULL, 15);
  return $output;
}

/**
 * Implementation of VotingAPI's hook_calculate
 * Recalculate results whenever a vote is added or removed
 */
function advpoll_votingapi_calculate(&$results, $votes, $content_type, $content_id) {
  // Make sure it's an Advanced Poll content type
  if ($content_type == 'advpoll') {
    $node = node_load($content_id);
    $mode = _advpoll_get_mode($node);
    $function = 'advpoll_calculate_results_' . $mode;
    if (function_exists($function)) {
      $function($results, $votes, $node);
    }
    cache_clear_all();
  }
}


/**
 * Implementation of hook_cron().
 *
 * Closes polls that have exceeded their allowed runtime.
 */
function advpoll_cron() {
  // Open polls with a startdate that is in the past but that need to be opened
  $sql = 'SELECT p.nid FROM {advpoll} p WHERE p.startdate IS NOT NULL AND (p.runtime = 0 OR p.startdate + p.runtime >= ' . (time() - time() % (3600 * 24)) . ') AND p.startdate < ' . time() . ' AND p.active = 0';
  $result = db_query($sql);
  drupal_set_message($sql);
  while ($poll = db_fetch_object($result)) {
    db_query("UPDATE {advpoll} SET active = 1 WHERE nid=%d", $poll->nid);
  }

  // Close polls
  $sql = 'SELECT p.nid FROM {advpoll} p INNER JOIN {node} n ON p.nid = n.nid WHERE ((p.startdate IS NULL AND (n.created + p.runtime) < '. time() .') OR (p.startdate IS NOT NULL AND (p.startdate + p.runtime) < ' . time() . ')) AND p.active = 1 AND p.runtime != 0';
  $result = db_query($sql);
  while ($poll = db_fetch_object($result)) {
    db_query("UPDATE {advpoll} SET active = 0 WHERE nid=%d", $poll->nid);
  }
}


/**
 * Implementation of hook_delete().
 *
 */
function advpoll_delete($node) {
  db_query("DELETE FROM {advpoll} WHERE nid = %d", $node->nid);
  db_query("DELETE FROM {advpoll_choices} WHERE nid = %d", $node->nid);
  db_query("DELETE FROM {advpoll_electoral_list} WHERE nid = %d", $node->nid);

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

/**
 * Implementation of hook_form().
 *
 * This hook displays the form necessary to create/edit the poll.
 */
function advpoll_form($node, $form_values = NULL) {
  $mode = _advpoll_get_mode($node);
  
  // Only add javascript once, even if _form is called multiple times
  static $add_js;
  if (!$add_js) {
    // Pass translatable strings
    drupal_add_js(array('advPoll' => array('remove' => t('Remove'), 'addChoice' => t('Add choice'), 'noLimit' => t('No limit'))), 'setting');
    drupal_add_js(drupal_get_path('module', 'advpoll') .'/advpoll-form.js', 'module');
    drupal_add_css(drupal_get_path('module', 'advpoll') .'/advpoll.css', 'module');
    $add_js = true;
  }

  $form['title'] = array(
    '#type' => 'textfield',
    '#title' => ucfirst($mode) .' '. t('question'),
    '#required' => TRUE,
    '#default_value' => $node->title,
  );

  $form['body'] = array(
    '#type' => 'textarea',
    '#title' => t('Description'),
    '#required' => FALSE,
    '#default_value' => $node->body,
  );

  if (isset($form_values)) {
    $choices = $form_values['choices'];
    if ($form_values['morechoices']) {
      $choices *= 2;
    }
  }
  else {
    $choices = max(2, count($node->choice)? count($node->choice) : 5);
  }

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

  // Advanced Poll choices
  $form['choice'] = array(
    '#type' => 'fieldset',
    '#title' => t('Poll choices'),
    '#collapsible' => TRUE,
    '#prefix' => '<div class="poll-form">',
    '#suffix' => '</div>',
    '#tree' => TRUE,
    '#weight' => 1,
  );
  
  $form['choice']['morechoices'] = array(
    '#type' => 'checkbox',
    '#title' => t('Need more choices'),
    '#value' => 0,
    '#parents' => array('morechoices'), // don't pollute $form['choice']
    '#prefix' => '<div id="morechoices">',
    '#suffix' => '</div>',
    '#description' => t("If the amount of boxes above isn't enough, check this box and click the Preview button below to add some more."),
    '#weight' => 1
  );

  for ($a = 1; $a <= $choices; $a++) {
    $form['choice'][$a]['label'] = array(
      '#type' => 'textfield',
      '#title' => t('Choice %n', array('%n' => $a)),
      '#default_value' => $node->choice[$a]['label'],
      '#attributes' => array('class' => 'choices'),
    );
  }

  $form['settings'] = array(
    '#type' => 'fieldset',
    '#title' => t('Poll settings'),
    '#collapsible' => TRUE,
    '#weight' => 2,
    '#tree' => TRUE,
  );

  $maxChoiceList = array();
  for ($i = 0; $i <= $choices; $i++) {
    $maxChoiceList[$i] = ($i == 0? 'No limit' : $i);
  }

  $form['settings']['maxchoices'] = array(
    '#type' => 'select',
    '#title' => t('Maximum choices'),
    '#default_value' => ($node->maxchoices? $node->maxchoices : 0),
    '#options' => $maxChoiceList,
    '#DANGEROUS_SKIP_CHECK' => true, // allow jQuery to add new options
    '#description' => t('Limits the total number of choices voters may select.')
  );

  $voting_algorithms = array();

  foreach (advpoll_algorithms($mode) as $alg) {
    $voting_algorithms[$alg] = ucfirst($alg);
  }

  $defaultalg = ($form_values['settings']['algorithm']?
    $form_values['settings']['algorithm'] : $node->algorithm);
      
  if (count($voting_algorithms) > 1) {
    $form['settings']['algorithm'] = array(
      '#type' => 'select',
      '#title' => t('Algorithm'),
      '#options' => $voting_algorithms,
      '#default_value' => $defaultalg,
      '#description' => 'Voting algorithm to use to calculate the winner.',
    );
  }
  else {
    $form['settings']['algorithm'] = array(
      '#type' => 'hidden',
      '#value' => $defaultalg,
    );
  }

  $active = array(1 => t('Active'), 0 => t('Closed'));
  $form['settings']['active'] = array(
    '#type' => 'radios',
    '#title' => t('Status'),
    '#options' => $active,
    '#default_value' => (isset($node->active)? $node->active : 1),
    '#description' => t('When a poll is closed users may no longer vote on it.'),
  );

  $_duration = array(0 => t('Unlimited')) + drupal_map_assoc(array(86400, 172800, 345600, 604800, 1209600, 2419200, 4838400, 9676800, 31536000), 'format_interval');

  $form['settings']['usestart'] = array(
    '#type' => 'checkbox',
    '#title' => t('Use start date'),
    '#description' => t('Specify a date that the poll opens.'),
    '#default_value' => (isset($node->startdate)? TRUE :
      ($form_values['startdate']? $form_values['startdate'] : FALSE)),
  );

  $date = $form_values['startdate']? $form_values['startdate'] :
    $node->startdate? $node->startdate : time();

  $form['settings']['startdate'] = array(
    '#prefix' => '<div class="edit-settings-startdate">',
    '#suffix' => '</div>',
    '#type' => 'date',
    '#title' => t('Starting date'),
    '#description' => t('Date that the poll opens'),
    '#default_value' => array('year' => date('Y', $date), 'month' => date('m', $date), 'day' => date('d', $date)),
  );

  $form['settings']['startdatejs'] = array(
    '#type' => 'hidden',
    '#default_value' => $date,
  );


  $form['settings']['runtime'] = array(
    '#type' => 'select',
    '#title' => t('Duration'),
    '#default_value' => ($node->runtime? $node->runtime : 0),
    '#options' => $_duration,
    '#description' => t('After this period, the poll will be closed automatically. This is relative to the start date if it is specified, otherwise the date the poll was created.')
  );


  $form['settings']['uselist'] = array(
    '#type' => 'checkbox',
    '#title' => t('Restrict voting to electoral list'),
    '#description' => t('If enabled, a list of eligible voters will be created and only that group will be able to vote in the poll.'),
    '#default_value' => isset($node->uselist)? $node->uselist : variable_get('advpoll_default_electoral_list', ADVPOLL_DEFAULT_ELECTORAL_LIST),
  );

  $form['settings']['showvotes'] = array(
    '#type' => 'checkbox',
    '#title' => t('Show individual votes'),
    '#description' => t('Users with the appropriate permissions will be able to see how each person voted.'),
    '#default_value' => isset($node->showvotes)? $node->showvotes : 1,
  );

  if (user_access('administer polls') && $node->nid) {
    $form['settings']['reset'] = array(
      '#type' => 'button',
      '#value' => t('Reset votes'),
    );
  }
  
  $form['format'] = filter_form($node->form);
  $form['#multistep'] = TRUE;
  return $form;
}


/**
 * Implementation of hook_help().
 */
function advpoll_help($section) {
  switch ($section) {
    case 'admin/modules#description':
      return t('A sophisticated polling module for voting, elections, and group decision-making.');
    default:
  }
}

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

  $poll->voted = FALSE;
  $poll->cancel_vote = FALSE;

  // See if user has voted
  if ($user->uid) {
    $poll->voted = (count(votingapi_get_user_votes('advpoll', $node->nid)) > 0);
    if ($poll->voted) {
      $poll->cancel_vote = TRUE;
    }
  }
  else {
    $result = db_query('SELECT uid, value FROM {votingapi_vote} '
      . 'WHERE content_id=%d AND content_type="advpoll" AND hostname="%s"',
      $node->nid, $_SERVER['REMOTE_ADDR']);
    if (db_num_rows($result) > 0) {
      $poll->voted = TRUE;
      $obj = db_fetch_object($result);
      if ($obj->uid == 0) {
        // Only allow cancelling if initial vote was also anonymous
        $poll->cancel_vote = TRUE;
      }
    }
  }

  return $poll;
}

/**
 * Implementation of hook_menu().
 *
 */
function advpoll_menu($may_cache) {
  global $user;

  // Load the modes in here instead of _init() toprofit from caching,
  // as recommended by http://api.drupal.org/api/head/function/hook_init
  $modes = _advpoll_list_modes();

  $items = array();

  if ($may_cache) {
    foreach ($modes as $mode) {
      $items[] = array(
        'path' => 'node/add/advpoll-' . $mode['name'],
        'title' => t('Advanced Poll - ' . $mode['name']),
        'access' => user_access('create polls'),
      );
    }

    $items[] = array(
      'path' => 'advpoll/cancel',
      'title' => t('Cancel'),
      'callback' => 'advpoll_cancel',
      'access' => user_access('cancel own vote'),
      'type' => MENU_CALLBACK
    );
    
    $items[] = array(
      'path' => 'admin/settings/advanced-poll',
      'title' => t('Advanced Poll'),
      'description' => t('Update settings for Advanced Poll'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('advpoll_admin_settings'),
      'access' => user_access('administer polls'),
    );

    $items[] = array(
      'path' => 'polls',
      'title' => t('Advanced Polls'),
      'callback' => 'advpoll_page',
      'access' => user_access('view polls'),
      'type' => MENU_SUGGESTED_ITEM,
    );
  }
  else {
    // need to be able to extract the nid
    if (arg(0) == 'node' && is_numeric(arg(1))) {
      $nid = arg(1);
      $node = node_load($nid);
      // Make sure we're on the actual poll node's page
      if (strstr($node->type, 'advpoll_') == 0) {
        // Show the results tab
        if ($node->active && !$node->voted
          && _advpoll_can_view_results($node)) {
          $items[] = array(
            'path' => 'node/' . $nid . '/results',
            'title' => t('Results'),
            'callback' => 'advpoll_results',
            'access' => user_access('view polls'),
            'weight' => 3,
            'type' => MENU_LOCAL_TASK,
          );
        }

        // Show the votes tab
        if ($node->showvotes) {
          $items[] = array(
            'path' => 'node/' . $nid . '/votes',
            'title' => t('Votes'),
            'callback' => 'advpoll_tab_votes',
            'access' => user_access('inspect all votes'),
            'weight' => 3,
            'type' => MENU_LOCAL_TASK,
          );
        }

        // Show electoral list tab if using the functionality
        if ($node->uselist) {
          $items[] = array(
            'path' => 'node/' . $nid . '/electoral_list',
            'title' => t('Electoral list'),
            'callback' => 'advpoll_tab_electoral_list',
            'access' => user_access('view polls'),
            'weight' => 3,
            'type' => MENU_LOCAL_TASK,
          );

          // Allow voters to be removed
          $items[] = array(
            'path' => 'node/' . $nid . '/remove',
            'callback' => 'advpoll_remove_voter',
            'access' => user_access('administer polls'),
            'weight' => 3,
            'type' => MENU_CALLBACK,
          );
        }

        // Allow votes to be reset
        $items[] = array(
          'path' => 'node/' . $nid . '/reset',
          'callback' => 'drupal_get_form',
          'callback arguments' => 'advpoll_reset_confirm',
          'access' => user_access('administer polls'),
          'weight' => 3,
          'type' => MENU_CALLBACK,
        );

      
      }
    }
  }

  return $items;
}

/**
 * Display the electoral list tab
 */
function advpoll_tab_electoral_list() {
  if ($node = node_load(arg(1))) {
    if (!$node->uselist) {
      drupal_not_found();
      return;
    }
    drupal_set_title(check_plain($node->title));
    
    if (user_access('administer polls')) {
      $output .= drupal_get_form('advpoll_electoral_list_form', $node->nid);
    }

    $output .= '<p>'
      . t('This table lists all the eligible voters for this poll.')
      . '</p>';

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

    $result = pager_query("SELECT u.uid, u.name FROM {advpoll_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 polls')) {
        $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();
  }
}

function advpoll_electoral_list_form($nid) {
  $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;        
}


/**
 * Remove an individual voter from the electoral list
 */
function advpoll_remove_voter() {
  $nid = arg(1);
  $uid = arg(3);
  if ($uid && $node = node_load($nid)) {
    $result = db_query('SELECT name FROM {users} WHERE uid=%d', $uid);
    if (db_num_rows($result) > 0) {
      $user = db_fetch_object($result);
      db_query('DELETE FROM {advpoll_electoral_list} WHERE nid=%d AND uid=%d',
        $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 advpoll_electoral_list_form_validate($form_id, $form_values) {
  if ($form_values['op'] == t('Reset electoral list')) {
    if (user_access('administer polls')) {
      db_query('DELETE FROM {advpoll_electoral_list} WHERE nid=%d', $form_values['nid']);
      drupal_set_message(t('Electoral list cleared.'));
      return;
    }
  }

  $add_user = $form_values['electoral_list']['add_user'];
  if ($add_user) {
    // Check that the user exists
    $result = db_query('SELECT uid FROM {users} WHERE name="%s"', $add_user);
    if (db_num_rows($result) == 0) {
      form_set_error('electoral_list][add_user', t('User %user does not exist.', array('%user' => $add_user)));
      return FALSE;
    }
  }
}

/**
 * Submit changes to the electoral list
 */
function advpoll_electoral_list_form_submit($form_id, $form_values) {
  $add_user = $form_values['electoral_list']['add_user'];
  if ($add_user) {
    db_query('REPLACE INTO {advpoll_electoral_list} (nid, uid) SELECT "%d", u.uid FROM users u WHERE u.name = "%s"', $form_values['nid'], $add_user);
    drupal_set_message(t('%user added to electoral list.', array('%user' => $add_user)));
  }
}

/**
 * Display the votes tab
 */
function advpoll_tab_votes() {
  if ($node = node_load(arg(1))) {
    if (!$node->showvotes) {
      // Advanced Poll 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 poll. 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'), '');

    $result = pager_query('SELECT v.value, v.uid, v.hostname, v.tag, u.name FROM {votingapi_vote} v LEFT JOIN {users} u ON v.uid = u.uid WHERE v.content_type="advpoll" AND v.content_id = %d' . tablesort_sql($header), 20, 0, NULL, $node->nid);
    $rows = array();
    while ($vote = db_fetch_object($result)) {
      $key = $vote->uid? $vote->uid : $vote->hostname;
      $rows[$key]['name'] = $vote->name ? theme('username', $vote) : check_plain($vote->hostname);
      if ($node->type == 'advpoll_ranking') {
        // Need two dimensional results (if equal rankings are allowed)
        $rows[$key]['votes'][$vote->value][] = check_plain($node->choice[$vote->tag]['label']);
      }
      else {
        // Just need one dimensional results
        $rows[$key]['votes'][] = check_plain($node->choice[$vote->tag]['label']);
      }
    }
    
    $separators = array('advpoll_ranking' => ' > ', 'advpoll_binary' => ', ');

    // create strings out of each vote
    $results = array();

    foreach ($rows as $key => $container) {
      $ranking = $container['votes'];
      asort($ranking);
      $rankings = array();
      if ($node->type == 'advpoll_ranking') {
        // Include support for multiple choices having the same ranking
        foreach ($ranking as $vote => $choices) {
          $rankings[$vote] = implode(' = ', $choices);
        }
      }
      else {
        // Just copy the previous array
        $rankings = $ranking;
      }
      ksort($rankings);
      $results[$key]['name'] = $rows[$key]['name'];
      $results[$key]['vote'] = implode($separators[$node->type], $rankings);
    }

    $output .= theme('table', $header, $results);
    $output .= theme('pager', NULL, 20, 0);
    print theme('page', $output);
  }
  else {
    drupal_not_found();
  }
}


/**
 * Helper function to abstract view results checking
 */
function _advpoll_can_view_results($node) {
  $view_results = variable_get('advpoll_view_results'
    , ADVPOLL_DEFAULT_VIEW_RESULTS);
  return (!$node->active  // node is closed
        || ($node->voted && $view_results == 'aftervote') // user voted
        || ($view_results == 'always')); // all can view
}

/**
 * Implementation of hook_node_info().
 */
function advpoll_node_info() {
  $modes = _advpoll_list_modes();
  $info = array();
  foreach ($modes as $mode) {
    $info['advpoll_' . $mode['name']] = array(
      'name' => t('Advanced Poll - ' . $mode['name']),
      'module' => 'advpoll',
      'description' => $mode['description'],
    );
  }
  return $info;
}

/**
 * Implementation of hook_perm().
 */
function advpoll_perm() {
  return array('create polls', 'delete polls', 'view polls', 'vote on polls', 'cancel own vote', 'administer polls', 'inspect all votes');
}

/**
 * Settings page for Drupal 5.0
 */
function advpoll_admin_settings() {
  $enabled = array(0 => t('Disabled'), 1 => t('Enabled'));

  $form['main']['advpoll_default_electoral_list'] = array(
    '#type' => 'radios',
    '#title' => t('Use electoral list by default'),
    '#description' => t('Use an electoral list by default for new advpoll.'),
    '#default_value' => variable_get('advpoll_default_electoral_list', ADVPOLL_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']['advpoll_view_results'] = array(
    '#type' => 'radios',
    '#title' => t('When should results be displayed'),
    '#description' => t('Determines when users may view the results of the poll.'),
    '#default_value' => variable_get('advpoll_view_results', ADVPOLL_DEFAULT_VIEW_RESULTS),
    '#options' => $view_results,
  );
  return system_settings_form($form);
}


/**
 * Helper function to display 'cancel vote' button if user has voted
 */
function advpoll_cancel_form($nid) {
  $form['#action'] = url("advpoll/cancel/$nid");
  $form['submit'] = array('#type' => 'submit', '#value' => t('Cancel your vote'));
  return $form;  
}

/**
 * Implementation of hook_update().
 *
 * This is called upon node edition.
 */
function advpoll_update($node) {
  if ($node->settings['usestart']) {
    $node->settings['active'] = _advpoll_calculate_active($node);
  }

  db_query("UPDATE {advpoll} SET active=%d, runtime=%d, maxchoices=%d, algorithm='%s', uselist=%d, showvotes=%d, startdate=%s WHERE nid = %d",
    $node->settings['active'], $node->settings['runtime'],
    $node->settings['maxchoices'], $node->settings['algorithm'],
    $node->settings['uselist'], $node->settings['showvotes'],
    $node->settings['usestart']? _advpoll_create_startdate($node): 'NULL',
    $node->nid);

  _advpoll_insert_choices($node);
  votingapi_recalculate_results('advpoll', $node->nid);
}


/**
 * Determine if node should be active for _insert and _update operations
 *
 * This function is needed when changing the startdate and/or duration
 */
function _advpoll_calculate_active($node) {
  $startdate = _advpoll_create_startdate($node);
  if ($node->settings['runtime']) {
    // Check that startdate is in the past and that the duration hasn't elapsed
    $active = time() >= $startdate
      && time() < $node->settings['runtime'] + $startdate;
  }
  else {
    // Just need to ensure that startdate is in the past
    $active = time() >= $startdate;
  }
  return $active? 1 : 0;
}

/*
 * Create a unix timestamp for startdate based on FormAPI inputs
 */
function _advpoll_create_startdate($node) {
  list($hour, $min) = explode(':', date('h:m', time()));
  return mktime($hour, $min, 0,
      $node->settings['startdate']['month'],
      $node->settings['startdate']['day'],
      $node->settings['startdate']['year']);
}

function _advpoll_insert_choices($node) {
  db_query('DELETE FROM {advpoll_choices} WHERE nid = %d', $node->nid);
  // Start at one rather than 0 due to Drupal FormAPI
  $i = 1;
  foreach ($_POST['choice'] as $choice) {
    if ($choice['label'] != '') {
      db_query("INSERT INTO {advpoll_choices} (nid, label, vote_offset) VALUES (%d, '%s', %d)", $node->nid, check_plain($choice['label']), $i++);
    }
  }
}

function _advpoll_get_mode($node) {
  if ($node->type) {
    $types = explode('_', $node->type, 2);
    return $types[1];
  }
  else {
    drupal_set_message(t('No type specified for node %nid', array('%nid' => $node->nid)), 'error');
    return '';
  }
}

/**
 * Implementation of hook_insert()
 *
 * This is called upon node creation
 */
function advpoll_insert($node) {
  $mode = _advpoll_get_mode($node);
  if ($node->settings['usestart']) {
    $node->settings['active'] = _advpoll_calculate_active($node);
  }

  db_query('INSERT INTO {advpoll} (nid, mode, uselist, active, runtime, '
    . 'maxchoices, algorithm, showvotes, startdate)'
    . ' VALUES (%d, "%s", %d, %d, %d, %d, "%s", %d, %s)',
    $node->nid, $mode, $node->settings['uselist'], $node->settings['active'],
    $node->settings['runtime'], $node->settings['maxchoices'],
    $node->settings['algorithm'], $node->settings['showvotes'],
    $node->settings['usestart']? _advpoll_create_startdate($node): 'NULL');

  // create the electoral list if desired

  if ($node->settings['uselist']) {
    // Check 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 advpoll', perm) AND role.name = 'authenticated user'"));
    if ($result->hit) {
      // Special case: any authenticated user can vote
      // Add all current users to electoral list
      db_query("INSERT INTO {advpoll_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
      db_query("INSERT INTO {advpoll_electoral_list} (nid, uid) SELECT '%d', u.uid FROM users_roles u, permission p WHERE FIND_IN_SET(' view advpoll', p.perm) AND u.rid = p.rid AND u.uid != 0", $node->nid);
    }
  }

  // Insert the choices
  _advpoll_insert_choices($node);
}

/**
 * Callback to display a reset votes confirmation form
 */ 
function advpoll_reset_confirm() {
  $edit = $_POST['edit'];
  $edit['nid'] = $edit['nid']? $edit['nid'] : arg(1);
  $node = node_load($edit['nid']);

  $form['nid'] = array('#type' => 'value', '#value' => $node->nid);
  $output = confirm_form($form,
    t('Are you sure you want to reset the votes for %title?',
    array('%title' => $node->title)),
    'node/' . $node->nid . '/edit',
    t('This action cannot be undone.'),
    t('Reset votes'),
    t('Cancel'));
  return $output;
}

/**
 * Reset votes once the confirmation is given
 */
function advpoll_reset_confirm_submit($form_id, $form_values) {
  if ($form_values['confirm']) {
    if ($node = node_load(array('nid' => arg(1)))) {
      // Delete any votes for the poll
      db_query('DELETE FROM {votingapi_vote} WHERE content_type="advpoll" AND content_id = %d', $node->nid);
      drupal_set_message('Votes have been reset.');
      drupal_goto('node/' . $node->nid . '/edit');
    }
  }

  return '';
}

/**
 * Implementation of hook_validate().
 */
function advpoll_validate(&$node) {
  if ($_POST['op'] == t('Reset votes')) {
    drupal_goto('node/' . $node->nid . '/reset');
  }
  else {
    // 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.'));
    }

    // Validate maxchoices since it has #DANGEROUS_SKIP_CHECK set to true

    if ($node->settings['maxchoices'] < 0) {
      form_set_error('settings][maxchoices]', t('Maximum choices must be a non-negative integer.'));
    }

    if ($node->settings['maxchoices'] > count($node->choice)) {
      form_set_error('settings][maxchoices]', t('Maximum choices cannot be larger than the number of choices submitted.'));
    }
  }
}

function advpoll_submit(&$node) {
  $node->choice = array_values($node->choice);
  // Start keys at 1 rather than 0
  array_unshift($node->choice, '');
  unset($node->choice[0]);
}

/**
 * Implementation of hook_view().
 */
function advpoll_view($node, $teaser = FALSE, $page = FALSE, $block = FALSE) {
  $mode = _advpoll_get_mode($node);

  if ($block) {
    // No 'readmore' link
    $node->readmore = FALSE;
    //$links = module_invoke_all('links', 'node', $node, 1);
    $links[] = array(
      'title' => 'Older polls',
      'href' => 'polls',
      'attributes' => array('title' =>
        t('View the list of polls on this site.')),
    );
    $node->links = $links;
  }

  // Previewing a node, so don't show results
  if ($node->in_preview) {
    // Show the voting form but don't let them vote
    $node->content['body'] = array(
      '#value' => drupal_get_form('advpoll_voting_' . $mode . '_form', $node, $teaser, $page, $block),
    );
  }
  else if (!$node->voted && arg(2) != 'results' && $node->active && advpoll_eligible($node)) {
    // User hasn't voted and we're not on the results tab

    if ($block) {
      $node->links[] = array(
        'title' => t('Results'),
        'href' => 'node/'. $node->nid .'/results',
        'attributes' => array('title' => t('View the current poll results.')),
      );
    }
    $node->content['body'] = array(
      '#value' => drupal_get_form('advpoll_voting_' . $node->mode . '_form',
        $node, $teaser, $page, $block)
      //. advpoll_view_electoral_list($node, $teaser),
    );
    static $addjs = TRUE;
    if ($addjs) {
      // Add javascript for posting voting forms with ajax
      drupal_add_js(drupal_get_path('module', 'advpoll') .'/advpoll-vote.js', 'module');
      drupal_add_js(drupal_get_path('module', 'advpoll') .'/jquery.form.js', 'module');
      $addjs = FALSE;
    }
  }
  else {
    // Show results only if the user has voted or poll is closed
    $node->content['body'] = array(
      '#value' => advpoll_view_results($node, $teaser, $page, $block)
    );  
  }

  return $node;
}

/**
 * Currently deprecated
 */
function advpoll_view_electoral_list($node, $teaser = FALSE) {
  $output = '';
  if ($node->uselist) {
     $result = db_query("SELECT COUNT(*) AS voters FROM {advpoll_electoral_list} WHERE nid=%d", $node->nid);
     $electoral_list = db_fetch_object($result);
  }
  $result = db_query("SELECT COUNT(DISTINCT uid) AS voters FROM {votingapi_vote} WHERE content_id=%d GROUP BY uid", $node->nid);
  $votes = db_num_rows($result);

  $output = '<div class="advpoll-electoral-list">';

  $output .= t('Total votes: %d', array('%d' => $votes));
  if ($node->uselist) {
     $output .= t(' (out of %v eligible voter' . 
      ($electoral_list->voters == 1? '' : 's') . ')',
        array('%v' => $electoral_list->voters));
  }
  $output .= '</div>';
  return $output;
}

/**
 * Render the voting form.
 */
function theme_advpoll_view_voting($form) {
  $output .= '<div class="advpoll">';
  $output .= '  <div class="choice-form">';
  $output .= '    <div class="choices">';
  $output .= drupal_render($form['choice']);
  $output .= '    </div>';
  $output .= drupal_render($form['nid']);
  $output .= drupal_render($form['vote']);
  $output .= '  </div>';
  $output .= drupal_render($form);
  $output .= '</div>';
  return $output;
}

function theme_advpoll_results($title, $results, $votes, $links, $block, $nid, $voted, $cancel_vote) {
  if ($block) {
    $output .= '<div class="poll">';
    $output .= '<div class="title">'. $title .'</div>';
    $output .= $results;
    $output .= '<div class="total">'. t('Total votes: %votes', array('%votes' => $votes)) .'</div>';
    $output .= '</div>';
    $output .= '<div class="links">'. theme('links', $links) .'</div>';
  }
  else {
    $output .= '<div class="poll">';
    $output .= $results;
    $output .= '<div class="total">'. t('Total votes: %votes', array('%votes' => $votes)) .'</div>';
    $output .= '</div>';
  }
  return $output;
} 

function _advpoll_show_cancel_form($node, $block) {
  $output = '';
  if ($node->voted && $node->cancel_vote && user_access('cancel own vote')
    && !$block) {
    $output .= drupal_get_form('advpoll_cancel_form', $node->nid);
  }
  return $output;
}

function theme_advpoll_bar($title, $percentage, $votes, $block) {
  if ($block) {
    $output  = '<div class="text">'. $title .'</div>';
    $output .= '<div class="bar"><div style="width: '. $percentage .'%;" class="foreground"></div></div>';
    $output .= '<div class="percent">'. $percentage .'%</div>';
  }
  else {
    $output  = '<div class="text">'. $title .'</div>';
    $output .= '<div class="bar"><div style="width: '. $percentage .'%;" class="foreground"></div></div>';
    $output .= 