modules/competition/competition.module

<?php
// $Id: competition.module,v 1.33 2008/07/09 22:15:40 colan Exp $

/**
 * @file
 * Allows you to run competitions on your site.
 *
 * This module supports the creation of competitions.  It provides tools
 * necessary for managing a continuous cycle of competitions that run on
 * your site.
 *
 * Copyright (C) 2008 Openject Consulting (http://www.openject.com/)
 * Written by Colan Schwartz (http://drupal.org/user/58704)
 */

/****************************************************************************
 ** CONSTANT DEFINITIONS ****************************************************
 ****************************************************************************/
define('COMPETITION_PHASE_NOT_SET',     0);
define('COMPETITION_PHASE_SUBMISSION',  1);
define('COMPETITION_PHASE_VOTING',      2);
define('COMPETITION_PHASE_POST_VOTING', 3);

define('COMPETITION_VOTING_DAYS_DEFAULT', 14);

/****************************************************************************
 ** DRUPAL HOOKS ************************************************************
 ****************************************************************************/

/**
 * Implementation of hook_help().
 */
function competition_help($section) {
  switch ($section) {

    case 'admin/help#competition':
      // Return the brief help text.
      return t('<p>Allows you to run competitions on your site.</p>');

    case 'admin/settings/competition':
      // Return a longer help text.
      return t('<p>This module supports the creation of competitions.  It provides tools necessary for managing a continuous cycle of competitions that run on your site.</p>');
  }
}

/**
 * Implementation of hook_perm().
 */
function competition_perm() {
  return array('administer competitions');
}

/**
 * Implementation of hook_menu().
 */
function competition_menu($may_cache) {

  // Initialize the list of menu items.
  $items = array();

  if ($may_cache) {
    // Define cacheable menu items.

    // Add an item for the admin settings.
    $items[] = array(
      'path' => 'admin/settings/competition',
      'title' => t('Competition settings'),
      'description' => t('Make changes to your competition configuration.'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('competition_admin_settings'),
      'access' => user_access('administer competitions'),
    );

    // Add an item for phase shifting.
    $items[] = array(
      'path' => 'admin/settings/competition/phase_shift',
      'title' => t('Shift to next competition phase'),
      'description' => t('Move the site to the next phase in the competition cycle.'),
      'type' => MENU_CALLBACK,
      'callback' => 'drupal_get_form',
      'callback arguments' => array('competition_phase_shift'),
      'access' => user_access('administer competitions'),
    );
  }

  // Return the defined items.
  return $items;
}

/**
 * Implementation of hook_user
 */
function competition_user($op, &$edit, &$account, $category = NULL) {
  switch ($op) {

    case 'view':

      // Display the competitions that the user has entered.
      $category = t('Competitions Entered');
      $value = theme('competition_views_display_entered', $account);
      if (sizeof($value)) {
        return array($category => $value);
      }

      break;
  }
}

/**
 * Implementation of hook_nodeapi().
 *
 * @todo
 *   Fix the viewing of each competition's voting period.  The 'view' code
 *   below doesn't actually work.
 */
function competition_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) {
  global $user;

  switch ($op) {
    case 'prepare':

      // If this node has been entered into a competition, and the competition
      // has closed, we don't want the owner to edit it.  Otherwise, he/she
      // would be able to make changes to his/her submission during the voting
      // phase.
      if ($node->nid) {
        $is_entry = ($node->type == 'competition_entry');
        $is_entry_content = db_result(db_query("
          SELECT n.type FROM {node} n INNER JOIN {relativity} r
          ON r.parent_nid = n.nid WHERE r.nid = %d
        ", $node->nid)) == 'competition_entry';
        if ($is_entry || $is_entry_content) {

          // We don't need to block edits if any of the following are true:
          // (1) The node is just being created now (obviously not entered yet)
          // (2) The user is allowed to administer competitions.
          if (($node->nid) && (!user_access('administer competitions'))) {

            // Get the competition that this node is associated with.
            if ($is_entry) {
              $competition = $node->field_competition_entry_comp[0]['nid'];
            }
            else /* $is_entry_content */ {
              $competition = db_result(db_query("
                SELECT field_competition_entry_comp_nid
                FROM {content_type_competition_entry}
                WHERE nid = (SELECT parent_nid FROM {relativity} WHERE nid = %d)
              ", $node->nid));
            }

            // If the associated competition is closed, we can't allow the user
            // to edit this node.  Display a message and redirect to the node
            // view.
            if ($competition && competition_is_closed($competition)) {
              drupal_set_message(t('Your entry has been entered into a competition that has closed so it cannot be edited at this time.'), 'error');
              drupal_goto('node/' . $node->nid);
            }
          }
        }
      }

      break;
    case 'view':

      // If a competition's voting period hasn't been set, show the default.
      if ($node->type == 'competition') {
        if (!$node->field_competition_voting_days[0]['value']) {
          $node->field_competition_voting_days[0]['value'] =
            competition_voting_get_days();
        }
      }

      break;
    case 'insert':

      // If this is a competition entry, we need to set the parent to the
      // selected competition.  Also, we need to unset the GET & POST
      // variables in order to override relativity's behaviour of setting
      // the parent from the URL.
      if ($node->nid && ($node->type == 'competition_entry')) {
        $node->parent_node = $node->field_competition_entry_comp[0]['nid'];
        $_GET['parent_node']  = NULL;
        $_POST['parent_node'] = NULL;
      }

      break;
    case 'update':

      // If this is a competition entry, update the parent.
      if ($node->nid && ($node->type == 'competition_entry')) {
        if ($node->parent_node) {
          db_query('UPDATE {relativity} SET parent_nid = %d WHERE nid = %d',
            $node->parent_node, $node->nid);

          // If there's no record for this yet, create one.
          if (!db_affected_rows()) {
            db_query(
              'INSERT INTO {relativity} (nid, parent_nid) VALUES (%d, %d)',
              $node->nid, $node->parent_node
            );
          }
        }
        else /* !$node->parent_node */ {
          // Rather than setting a zero, we should just remove the record.
          db_query('DELETE FROM {relativity} WHERE nid = %d', $node->nid);
        }
      }

      break;
    case 'submit':

      // If this is a competition entry, set the parent to the competition.
      if ($node->type == 'competition_entry') {
        $node->parent_node = $node->field_competition_entry_comp[0]['nid'];
      }

      break;
  }
}

/**
 * Implementation of hook_form_alter().
 */
function competition_form_alter($form_id, &$form) {

  // Alter the competition entry node form.
  if ($form_id == 'competition_entry_node_form') {

    // Don't show the log message textfield.
    unset($form['log']);
  }
}

/**
 * Implementation of hook_link().
 */
function competition_link($type, $node = 0, $main = 0) {
  $links = array();

  // Add links to competition nodes.
  if ($type == 'node' && $node->type == 'competition') {

    // Fetch all of the content types allowed for this competition.
    $types = competition_get_content_types($node);

    // Figure out if we should show the voting links.
    $competition_round = $node->field_competition_round[0]['value'];
    $show_voting_links = user_access('vote with versus') &&
      ($competition_round == competition_round_get_current()) &&
      (competition_phase_get_current() == COMPETITION_PHASE_VOTING);

    // Figure out if we should show the standings links.
    $show_standings_links = user_access('administer competitions') ||
                            (!variable_get('competition_standings_private', 0));

    // Add any links for each allowed content type.
    foreach ($types as $type) {
      $name = node_get_types('name', $type);

      // Show voting links if applicable.
      if ($show_voting_links) {
        $links['competition_voting_' . $type] = array(
          'title' => t('Vote on @type', array('@type' => $name)),
          'href'  => "versus/vote/$type/" . $node->nid,
        );
      }

      // Show standings links if applicable.
      if ($show_standings_links) {
        $links['competition_standings_' . $type] = array(
          'title' => t('@name Standings', array('@name' => $name)),
          'href'  => "versus/standings/$type/" . $node->nid,
        );
      }
    }
  }

  // Return them all.
  return $links;
}

/****************************************************************************
 ** FORMS *******************************************************************
 ****************************************************************************/

/**
 * Define the admin settings form.
 *
 * @return array
 *   The form.
 */
function competition_admin_settings() {
  $form = array();

  // Display/edit the current phase.
  $form['competition_state'] = array(
    '#type' => 'fieldset',
    '#title' => t('Competition state'),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
    '#description' => t('
<table>
  <tr>
    <td>Current state:</td>
    <td>Round %current_round, %current_phase phase</td>
  </tr>
  <tr>
    <td>Next state:</td>
    <td>Round %next_round, %next_phase phase</td>
  </tr>
</table>
<p>You may update the state of the site by <a href="/admin/settings/competition/phase_shift">moving to the next phase</a>.  This will only work if the transition you are attempting makes sense.  For example, you cannot move to the next phase if any competitions are live or you are in a voting period.</p>
    ', array(
      '%current_round' => competition_round_get_current(),
      '%current_phase' => competition_phase_get_name(),
      '%next_round' => (competition_phase_get_next(
        competition_phase_get_current() + 1
      ) == 1) ?
        competition_round_get_next() : competition_round_get_current(),
      '%next_phase' => competition_phase_get_name(competition_phase_get_next()),
    )),
  );

  // Display/edit the default number of voting days for each competition.
  $form['competition_voting_days'] = array(
    '#type'          => 'textfield',
    '#title'         => t('Default number of days in voting period'),
    '#description'   => t('Set the default number of days users are allowed to vote on each round\'s content.  This can be overridden by individual competitions on their node edit forms.'),
    '#size'          => 3,
    '#maxlength'     => 3,
    '#default_value' => competition_voting_get_days(),
  );

  // Determine if the standings links should be publically available.
  $form['competition_standings_private'] = array(
    '#type' => 'checkbox',
    '#title' => t('Keep standings links private'),
    '#default_value' => variable_get('competition_standings_private', 0),
    '#description' => t('If this box is checked, competition nodes will only show the standings links to Competition administrators.'));

  // Define a validation function.
  $form['#validate'] = array(
    'competition_admin_settings_validate' => array()
  );

  return system_settings_form($form);
}

/**
 * Validate the competition settings.
 */
function competition_admin_settings_validate($form_id, $form_values) {

  // Make sure that the default number of voting days submitted is valid.
  $days = $form_values['competition_voting_days'];
  if (!is_numeric($days) || ($days <= 0)) {
    form_set_error(
      'competition_voting_days',
      t('Please enter a positive number.')
    );
  }

  // Any other validation checks go here.
}

/**
 * Callback function for phase shifting.
 */
function competition_phase_shift() {
  return confirm_form(
    $form, t(
      'Are you sure you want to shift the site\'s state from <em>%phase_current</em> to <em>%phase_next</em>?',
      array(
        '%phase_current' => competition_phase_get_name(),
        '%phase_next' => competition_phase_get_name(
          competition_phase_get_next()
        )
      )
    ),
    'admin/settings/competition', '', t('Shift'), t('Cancel')
  );
}

/**
 * Submit function for phase shifting.
 *
 * @param $form_id
 *   The form ID.
 * @param $form_values
 *   The form values that were submitted.
 */
function competition_phase_shift_submit($form_id, $form_values) {
  competition_phase_set_next();
  return 'admin/settings/competition';
}

/****************************************************************************
 ** INTERNAL FUNCTIONS ******************************************************
 ****************************************************************************/

/**
 * Return the current competition round.
 *
 * @return integer
 *   The current round number.
 */
function competition_round_get_current() {
  return variable_get('competition_round', 1);
}

/**
 * Return the next competition round.
 *
 * @return integer
 *   The next round number.
 */
function competition_round_get_next() {
  return (competition_round_get_current() + 1);
}

/**
 * Return the current competition phase.
 *
 * @return integer
 *   The current phase number.
 */
function competition_phase_get_current() {
  return variable_get('competition_phase', 1);
}

/**
 * Return the name of a competition phase.
 *
 * The name of the specified phase is returned.  If no phase is specified,
 * the name of the current phase is returned.
 *
 * @param integer
 *   The phase number who's name is being requested.
 * @return string
 *   The name of the provided phase.
 */
function competition_phase_get_name($phase = NULL) {

  // Set the current phase if one hasn't been set.
  $phase = $phase ? $phase : competition_phase_get_current();

  // Return its name.
  $phases = competition_phase_get_phases();
  return $phases[$phase];
}

/**
 * Return the phase following a given phase.
 *
 * The next phase number is returned.  If no phase number is specified,
 * the current one is assumed.
 *
 * @param integer
 *   The phase number.
 * @return integer
 *   The phase number of the following phase.
 */
function competition_phase_get_next($phase = NULL) {

  // Set the current phase if one hasn't been set.
  $phase = $phase ? $phase : competition_phase_get_current();

  // If there is a next phase, return it.
  $phases = competition_phase_get_phases();
  if (isset($phases[$phase + 1])) {
    return ($phase + 1);
  }
  else /* there is no next phase so start over */ {
    return 1;
  }
}

/**
 * Return information on the available competition phases.
 *
 * @return array
 *   An ordered list of competition phases.
 */
function competition_phase_get_phases() {
  return array(
    COMPETITION_PHASE_NOT_SET     => '[PHASE NOT SET]',
    COMPETITION_PHASE_SUBMISSION  => 'submission',
    COMPETITION_PHASE_VOTING      => 'voting',
    COMPETITION_PHASE_POST_VOTING => 'post-voting',
  );
}

/**
 * Move the site's state into the next phase.
 */
function competition_phase_set_next() {
  $state_changed = FALSE;

  drupal_set_message(t(
    'Attempting to shift the site from <em>@phase_name</em> to the next competition phase...',
    array('@phase_name' => competition_phase_get_name())
  ));

  // We need to know where we are to know where we're going.
  // For each of these, make sure that we can move on to the next state.
  // If we can, do it.
  switch (competition_phase_get_current()) {

    case COMPETITION_PHASE_SUBMISSION:
      if (competition_phase_pass_submission()) {
        competition_phase_set_voting();
        $state_changed = TRUE;
      }
      break;

    case COMPETITION_PHASE_VOTING:
      if (competition_phase_pass_voting()) {
        competition_phase_set_post_voting();
        $state_changed = TRUE;
      }
      break;

    case COMPETITION_PHASE_POST_VOTING:
      if (competition_phase_pass_post_voting()) {
        competition_phase_set_submission();
        $state_changed = TRUE;
      }
      break;

    default:
      drupal_set_message(t('The competition phase has not been set!'), 'error');
      break;
  }

  // Timestamp the state change and report status.
  if ($state_changed) {
    competition_state_set_changed(time());
    drupal_set_message(t('The site is now in the <em>@phase_name</em> phase.',
      array('@phase_name' => competition_phase_get_name())
    ));
  }
}

/**
 * Determine if the submission phase can be passed.
 *
 * @return boolean
 *   TRUE if we can move on to the next phase, FALSE otherwise.
 */
function competition_phase_pass_submission() {

  // Check for open competitions.  If there are any, we can't move forward yet.
  // All competitions associated with the current round need to be wrapped up.
  if (db_result(db_query("
    SELECT COUNT(*) FROM {content_type_competition}
    WHERE (field_competition_round_value = %d)
    AND (field_competition_period_value2 > UNIX_TIMESTAMP())
  ", competition_round_get_current()))) {

    // Report the problem.
    drupal_set_message(t('Could not leave the <em>@phase_name</em> phase yet.  There are still active competitions in the current round.',
      array('@phase_name' => competition_phase_get_name())
    ), 'error');
    return FALSE;
  }

  // No problems.
  return TRUE;
}

/**
 * Determine if the voting phase can be passed.
 *
 * @return boolean
 *   TRUE if we can move on to the next phase, FALSE otherwise.
 */
function competition_phase_pass_voting() {

  // Check for any competitions with voting periods that extend past the
  // current time.  If there are any, we can't move forward yet.  All of
  // the voting periods must end first.
  if (db_result(db_query("
    SELECT COUNT(*) FROM {content_type_competition}
    WHERE (field_competition_round_value = %d)
    AND ( ( (
      IF(
        field_competition_voting_days_value,
        field_competition_voting_days_value,
        %d
      ) * 86400
    ) + %d) >= UNIX_TIMESTAMP())
  ", competition_round_get_current(), competition_voting_get_days(),
      competition_state_get_changed()))) {

    // Report the problem.
    drupal_set_message(t('Could not leave the <em>@phase_name</em> phase yet.  There are still competitions in the voting period.',
      array('@phase_name' => competition_phase_get_name())
    ), 'error');
    return FALSE;
  }

  // No problems.
  return TRUE;
}

/**
 * Determine if the post-voting phase can be passed.
 *
 * @return boolean
 *   TRUE if we can move on to the next phase, FALSE otherwise.
 */
function competition_phase_pass_post_voting() {
  $current_round = competition_round_get_current();

  // Make sure that there is at least one winner declared for each
  // competition in the current round,
  if (db_result(db_query("
    SELECT (
      SELECT COUNT(*) FROM {content_field_competition_winners} w
      INNER JOIN {content_type_competition} c ON w.nid = c.nid
      WHERE (w.delta = 0)
      AND w.field_competition_winners_nid
      AND (c.field_competition_round_value = %d)
    ) <> (
      SELECT COUNT(*) FROM {content_type_competition}
      WHERE field_competition_round_value = %d
    )
  ", $current_round, $current_round))) {

    // Report the problem.
    drupal_set_message(t('Could not leave the <em>@phase_name</em> phase yet.  There are still competitions that have no winners set.',
      array('@phase_name' => competition_phase_get_name())
    ), 'error');
    return FALSE;
  }

  // No problems.
  return TRUE;
}

/**
 * Move the site into the voting phase.
 *
 * Pre: The site is in the submission phase, and is ready to move to voting.
 * Post: The site is now in the voting phase.
 */
function competition_phase_set_voting() {

  // Enable voting.
  versus_set_voting_status(TRUE);

  // Set the new phase appropriately.
  variable_set('competition_phase', COMPETITION_PHASE_VOTING);
}

/**
 * Move the site into the post-voting phase.
 *
 * Pre: The site is in the voting phase, and is ready to move to post-voting.
 * Post: The site is now in the post-voting phase.
 */
function competition_phase_set_post_voting() {

  // Disable voting.
  versus_set_voting_status(FALSE);

  // Set the new phase appropriately.
  variable_set('competition_phase', COMPETITION_PHASE_POST_VOTING);
}
 
/**
 * Move the site into the submission phase.
 *
 * Pre: The site is in the post-voting stage, and is ready to move to8
 *      submission.
 * Post: The site is now in the submission phase.
 */
function competition_phase_set_submission() {

  /*
   * If you'd like to delete any content at the end of the round, do it here.
   * Just make sure that it is actually associated with the current round
   * before deleting it. ;)  You will probably want to keep winning content,
   * as competitions with winners will link to them.
   */
   

  /*
   * If you'd like to delete any votes at the end of the round, do it here.
   * Otherwise, the Voting API votes table will continue to grow.
   */


  // Move to the next round.
  variable_set('competition_round', competition_round_get_next());

  // Set the new phase appropriately.
  variable_set('competition_phase', COMPETITION_PHASE_SUBMISSION);
}

/**
 * Get the length of the voting period.
 *
 * Returns the length of the voting period, in days, for a particular
 * competition.  If no competition is specified, the site-wide default is
 * returned.
 *
 * @param $nid
 *   The node ID of the competition we're interested in.
 * @return
 *   The number of days in the voting period.
 */
function competition_voting_get_days($nid = NULL) {

  // If it's defined for this nid, return it.
  if ($nid && ($days = db_result(db_query("
    SELECT field_competition_voting_days_value FROM {content_type_competition}
    WHERE (nid = %d)
  ", $nid)))) {
    return $days;
  }

  // Otherwise, return the default.
  return variable_get(
    'competition_voting_days', COMPETITION_VOTING_DAYS_DEFAULT
  );
}

/**
 * Set the timestamp for a state change.
 *
 * @param $time
 *   The time to which the timestamp should be set.
 */
function competition_state_set_changed($time) {
  variable_set('competition_state_changed', $time);
}

/**
 * Get the timestamp for the last state change.
 *
 * @return
 *   The timestamp of the last state change, a number of seconds since the
 *   UNIX epoch.
 */
function competition_state_get_changed() {
  return variable_get('competition_state_changed', 0);
}

/**
 * Get the list of content types valid for entry into a competition.
 *
 * @param $competition object
 *   The competition node in question.
 * @return
 *   The array of content types.
 */
function competition_get_content_types($competition) {

  // Initialize a list of items to return.
  $types = array();

  // Get the types allowed for this competition & add them to the list.
  $type_array = $competition->field_competition_content_types;
  if ($type_array) {
    foreach ($type_array as $value) {
      $types[] = $value['value'];
    }
  }

  // Return it.
  return $types;
}

/**
 * Determines if a competition has closed.
 *
 * @param $competition
 *   The node ID of the competition.
 * @return
 *   TRUE if the competition has closed, FALSE otherwise.
 */
function competition_is_closed($competition) {

  // Get the competition's closing date.
  $closing_date = date_make_date(db_result(db_query("
    SELECT field_competition_period_value2 FROM {content_type_competition}
    WHERE nid = %d
  ", $competition)), NULL, DATE_ISO);

  // Determine if it was in the past.
  return (time() > date_format($closing_date, 'U'));
}

/**
 * Helper function that caches node types.
 * 
 * This code was originally taken from _relatedlinks_node_get_types(),
 * in the Related Links module (http://drupal.org/project/relatedlinks).
 *
 * @param $keys
 *   A boolean variable that decides whether an associative array of node
 *   types is to be returned (or not).
 * 
 * @return
 *   An associative or non-associative array of node types.
 */
function competition_node_get_types($keys = FALSE) {
  static $node_types = NULL, $key_array = NULL;

  // Check if there's anything in the cache.
  if (!isset($node_types)) {

    // There's nothing in the cache so we need to get content type information.
    $node_types = node_get_types('names');
    foreach ($node_types as $type => $name) {
      $node_types[$type] = check_plain($name);
    }

    // Set the list of keys.
    $key_array = array_keys($node_types);
  }

  // Either return the key list, or key/value pairs.
  return $keys ? $key_array : $node_types;
}

/**
 * Get the subquery resulting in a node's competition ID from within Views.
 *
 * @return string
 *   The subquery resulting in the competition ID.
 */
function competition_views_get_associated_id() {

  // Get the node ID and the node's parent ID.
  $nid = "node.nid";
  $parent_nid = "(SELECT parent_nid FROM {relativity} WHERE nid = $nid)";

  // Set the subquery for fetching the competition ID.
  $subquery = "(SELECT field_competition_entry_comp_nid FROM {content_type_competition_entry} WHERE nid = ";

  // Set the queries for both the node and its parent.
  $query_nid    = $subquery . $nid        . ")";
  $query_parent = $subquery . $parent_nid . ")";

  // If the node has a competition ID, return it.  Otherwise, the parent's.
  return "(SELECT IF($query_nid, $query_nid, $query_parent))";
}

/****************************************************************************
 ** VIEWS HOOKS *************************************************************
 ****************************************************************************/

/**
 * Implementation of hook_views_tables().
 */
function competition_views_tables() {
  $tables['competition'] = array(
    'name'   => 'competition',
    'fields' => array(
      'id' => array(
        'name'          => t('Competition: ID'),
        'help'          => t('The associated competition for this node.'),
        'sortable'      => TRUE,
        'notafield'     => TRUE,
        'query_handler' => 'competition_query_handler_competition_id',
      ),
    ),
    'filters' => array(
      'winner' => array(
        'name'     => t('Competition: Winner'),
        'help'     => t('Filters entry nodes based on whether they were winners in a competition.'),
        'operator' => 'views_handler_operator_eqneq',
        'handler'  => 'views_handler_filter_competition_winner',
        'value'    => array(
          '#type'    => 'select',
          '#options' => array(0 => t('False'), 1 => t('True'),),
        ),
      ),
      'round' => array(
        'name'     => t('Competition: Round'),
        'help'     => t('Filters entry nodes based on their round.  Enter a round number in the value field, or "current round" to specify the current round.'),
        'operator' => 'views_handler_operator_gtlt',
        'handler'  => 'views_handler_filter_competition_round',
        'value'    => array(
          '#type'          => 'textfield',
          '#default_value' => "current round",
          '#size'          => "15",
          '#maxlength'     => "15",
        ),
      ),
    ),
  );
  return $tables;
}

/**
 * Views filter handler to filter nodes based on their round.
 */
function views_handler_filter_competition_round($op, $filterdata, $filterinfo,
                                                &$query) {
  switch ($op) {
    case 'handler':

      // Get the operator.
      $operator = $filterdata['operator'];

      // Set the value that we're comparing to.  If it's the curernt round,
      // fetch it.  Otherwise, use the value provided.
      if ($filterdata['value'] == "current round") {
        $value = competition_round_get_current();
      }
      else /* filter based on a specific round, not the current one */ {
        $value = intval($filterdata['value']);
      }

      // Check if this is one of the nodes in the list of those that
      // match the conditions specified.
      $query->add_where("node.nid IN (
        SELECT ce.nid FROM {content_type_competition_entry} ce
        INNER JOIN {content_type_competition} c
        ON ce.field_competition_entry_comp_nid = c.nid
        WHERE c.field_competition_round_value $operator $value
      )");

      break;
  }
}

/**
 * Views filter handler to determine if a node was a winner.
 */
function views_handler_filter_competition_winner($op, $filterdata, $filterinfo,
                                                 &$query) {

  // Declare a subquery that will return a list of winners.
  $winners_list = "(
    SELECT field_competition_winners_nid
    FROM {content_field_competition_winners}
  )";

  switch ($op) {
    case 'handler':

      // Set the value and operator.
      $value  = $filterdata['value'];
      $equals = ($filterdata['operator'] == '=');

      switch (TRUE) {

        case (($equals) && (!$value)):
        case ((!$equals) && ($value)):
          // The node should not be in the winners list.
          $query->add_where("node.nid NOT IN $winners_list");
          break;

        case ((!$equals) && (!$value)):
        case (($equals) && ($value)):
          // The node should be in the winners list.
          $query->add_where("node.nid IN $winners_list");
          break;
      }
      break;
  }
}

/**
 * Views query handler to define the associated competition for a node.
 */
function competition_query_handler_competition_id($field, $fieldinfo, &$query) {
  $query->add_field(
    competition_views_get_associated_id(), '', 'competition_id'
  );
}

/**
 * Implementation of hook_views_arguments().
 */
function competition_views_arguments() {

  // Add the "Competition: ID" argument.
  $arguments['competition_id'] = array(
      'name'    => t('Competition: ID'),
      'help'    => t('The competition ID argument allows users to filter a view by specifying an associated competition.'),
      'handler' => 'views_handler_arg_competition_id',
  );

  // Return all of the defined arguments.
  return $arguments;
}

/**
 * Views argument handler to define the associated competition for a node.
 */
function views_handler_arg_competition_id($op, &$query, $argtype, $arg = '') {
  switch ($op) {
    case 'summary':
      $fieldinfo['field'] = competition_views_get_associated_id();
      $fieldinfo['fieldname'] = 'competition_id';
      $query->add_field('parent_nid', 'relativity');
      return $fieldinfo;
      break;
    case 'sort':
      $query->add_orderby(NULL, competition_views_get_associated_id(),
        $argtype, 'competition_id');
      break;
    case 'filter':
      $query->add_where(competition_views_get_associated_id() . " = $arg");
      break;
    case 'link':
      $title = check_plain(db_result(db_query("
        SELECT title FROM {node} WHERE nid = %d
      ", $query->competition_id)));
      return l($title, "$arg/$query->competition_id");
    case 'title':
      return check_plain(db_result(db_query("
        SELECT title FROM {node} WHERE nid = %d
      ", $query)));
  }
}

/**
 * Implementation of hook_views_default_views().
 */
function competition_views_default_views() {

  // Create an array to hold the defined views.
  $views = array();

  /*
   * Display only open competitions.
   */
  $view = new stdClass();
  $view->name = 'competition_open';
  $view->description = 'A view of all open competitions';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = FALSE;
  $view->page_title = '';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = '';
  $view->page_empty_format = '1';
  $view->page_type = 'node';
  $view->url = '';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '10';
  $view->sort = array (
  );
  $view->argument = array (
  );
  $view->field = array (
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'competition',
),  
    ),
    array (
      'tablename' => 'node_data_field_competition_period',
      'field' => 'field_competition_period_value_default',
      'operator' => '<=',
      'options' => 'now',
      'value' => '',
    ),
    array (
      'tablename' => 'node_data_field_competition_period',
      'field' => 'field_competition_period_value_to|default',
      'operator' => '>=',
      'options' => 'now',
      'value' => '',
    ),
  );
  $view->exposed_filter = array (
  );   
  $view->requires = array(node, node_data_field_competition_period);
  $views[$view->name] = $view;

  /*
   * Display the latest competitions.
   */
  $view = new stdClass();
  $view->name = 'competition_latest';
  $view->description = 'A teaser listing of the latest competitions';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'Latest Competitions';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = 'There are no competitions available at this time.';
  $view->page_empty_format = '1';
  $view->page_type = 'teaser';
  $view->url = 'competition/latest';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '5';
  $view->menu = TRUE;
  $view->menu_title = '';
  $view->menu_tab = TRUE;
  $view->menu_tab_weight = '0';
  $view->menu_tab_default = TRUE;
  $view->menu_tab_default_parent = NULL;
  $view->menu_tab_default_parent_type = 'normal';
  $view->menu_parent_tab_weight = '0';
  $view->menu_parent_title = 'Competitions';
  $view->block = TRUE;
  $view->block_title = 'Latest Competitions';
  $view->block_header = '';
  $view->block_header_format = '1';
  $view->block_footer = '';
  $view->block_footer_format = '1';
  $view->block_empty = '';
  $view->block_empty_format = '1';
  $view->block_type = 'teaser';
  $view->nodes_per_block = '5';
  $view->block_more = TRUE;
  $view->block_use_page_header = FALSE;
  $view->block_use_page_footer = FALSE;
  $view->block_use_page_empty = TRUE;
  $view->sort = array (
    array (
      'tablename' => 'node_data_field_competition_period',
      'field' => 'field_competition_period_value',
      'sortorder' => 'DESC',
      'options' => '',
    ),
  );
  $view->argument = array (
  );
  $view->field = array (
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'competition',
),
    ),
  );
  $view->exposed_filter = array (
  );
  $view->requires = array(node_data_field_competition_period, node);
  $views[$view->name] = $view;

  /**
   * List all competitions.
   */
  $view = new stdClass();
  $view->name = 'competition_all';
  $view->description = 'A list of all competitions on the site';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'All Competitions';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = 'There are no competitions on the site at this time.';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'competition/all';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '100';
  $view->menu = TRUE;
  $view->menu_title = '';
  $view->menu_tab = TRUE;
  $view->menu_tab_weight = '5';
  $view->menu_tab_default = FALSE;
  $view->menu_tab_default_parent = NULL;
  $view->menu_tab_default_parent_type = 'existing';
  $view->menu_parent_tab_weight = '0';
  $view->menu_parent_title = '';
  $view->sort = array (
  );
  $view->argument = array (
  );
  $view->field = array (
    array (
      'tablename' => 'node',
      'field' => 'title',
      'label' => 'Title',
      'handler' => 'views_handler_field_nodelink',
      'sortable' => '1',
      'options' => 'link',
    ),
    array (
      'tablename' => 'node_data_field_competition_period',
      'field' => 'field_competition_period_value',
      'label' => 'Period',
      'handler' => 'content_views_field_handler_group',
      'sortable' => '1',
      'options' => 'default',
    ),
    array (
      'tablename' => 'node_data_field_competition_round',
      'field' => 'field_competition_round_value',
      'label' => 'Round',
      'handler' => 'content_views_field_handler_group',
      'sortable' => '1',
      'defaultsort' => 'DESC',
      'options' => 'default',
    ),
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'competition',
),
    ),
  );
  $view->exposed_filter = array (
  );
  $view->requires = array(node, node_data_field_competition_period, node_data_field_competition_round);
  $views[$view->name] = $view;

  /**
   * List all entries from which winners can be chosen.
   */
  $view = new stdClass();
  $view->name = 'competition_entries_list';
  $view->description = 'A list of all competition entries from which winners can be chosen';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = FALSE;
  $view->page_title = '';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = '';
  $view->page_empty_format = '1';
  $view->page_type = 'node';
  $view->url = '';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '10';
  $view->sort = array (
  );
  $view->argument = array (
  );
  $view->field = array (
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
    array (
      'tablename' => 'node',
      'field' => 'type',
      'operator' => 'OR',
      'options' => '',
      'value' => array (
  0 => 'competition_entry',
),
    ),
  );
  $view->exposed_filter = array (
  );
  $view->requires = array(node);
  $views[$view->name] = $view;

  /**
   * Output an array of nodes which have been submitted by the user 
   */
  $view = new stdClass();
  $view->name = 'competition_user_entered';
  $view->description = 'All competitions entered by a user';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'Competitions Entered by %1';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = '';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'competition/list/$arg';
  $view->use_pager = FALSE;
  $view->nodes_per_page = '0';
  $view->sort = array (
    array (
      'tablename' => 'node',
      'field' => 'created',
      'sortorder' => 'DESC',
      'options' => 'day',
    ),
  );
  $view->argument = array (
    array (
      'type' => 'uid',
      'argdefault' => '2',
      'title' => '',
      'options' => '',
      'wildcard' => '',
      'wildcard_substitution' => '',
    ),
  );
  $view->field = array (
    array (