modules/versus/versus.module

<?php
// $Id: versus.module,v 1.16 2008/06/10 02:31:17 colan Exp $

/**
 * @file
 * Allows users to pick a winner of two nodes of the same type.
 *
 * This module allows users to vote on pairs of nodes for each content type.
 * After a user votes on a random pair by picking a winner, he or she will be
 * directed to vote on the next random pair.
 *
 * Versus is a rewrite of the Smackdown module that doesn't create any nodes.
 * Smackdown views each X vs. Y pair as a "smackdown" node. This doesn't scale
 * well when users are required to vote on large numbers of pairs. An example
 * is all possible combinations of nodes for a given content type. For each
 * content type, n choose 2 nodes need to be created, and this grows very large
 * very quickly.
 *
 * CRUD is handled by the Voting API module, which is required as a dependency.
 *
 * Copyright (C) 2008 Openject Consulting (http://www.openject.com/).
 * Originally written by Colan Schwartz (http://drupal.org/user/58704)
 * with theming help from William Roboly (http://drupal.org/user/48120).
 */

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

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

    case 'admin/help#versus':
      // Return the brief help text.
      return t('
        <p>Allows users to pick a winner of two nodes of the same type.</p>
      ');

    case 'admin/settings/versus':
      // Return a longer help text.
      return t("
<p>This module allows users to vote on pairs of nodes for each content type.
After a user votes on a random pair by picking a winner, he or she will be
directed to vote on the next random pair.</p>

<p>Versus is a rewrite of the Smackdown module that doesn't create any nodes.
Smackdown views each X vs. Y pair as a \"smackdown\" node. This doesn't scale
well when users are required to vote on large numbers of pairs. An example is
all possible combinations of nodes for a given content type. For each content
type, n choose 2 nodes need to be created, and this grows very large very
quickly.</p>

<p>CRUD is handled by the Voting API module, which is required as a
dependency.</p>
      ");
  }
}
 
/**
 * Implementation of hook_menu().
 */
function versus_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/versus',
      'title'              => t('Versus settings'),
      'description'        => t('Global settings for the Versus module.'),
      'callback'           => 'drupal_get_form',
      'callback arguments' => array('versus_settings'),
      'access'             => user_access('administer versus'),
    );

    // Add the main menu item to the navigation list.
    $items[] = array(
      'path'     => 'versus',
      'title'    => t('Voting Options'),
      'callback' => 'versus_voting_options', 
      'type'     => MENU_NORMAL_ITEM,
      'access'   => (
        user_access('vote with versus') || user_access('view versus results')
      ),
    );

    // Add the "Vote" option to the Voting menu.
    $items[] = array(
      'path'     => 'versus/vote',
      'title'    => t('Cast Votes'),
      'callback' => 'versus_vote_request',
      'type'     => MENU_ITEM_GROUPING,
      'access'   => user_access('vote with versus'),
      'weight'   => -5,
    );

    // Add callbacks for each content type.
    foreach (versus_types_enabled() as $type) {
      if ($type) {
        $items[] = array(
          'path'   => 'versus/vote/'. $type,
          'title'  => node_get_types('name', $type),
          'access' => user_access('vote with versus'),
        );
      }
    }
  }
  
  // Return the defined items.
  return $items;
}

/**
 * Implementation of hook_perm
 *
 * @todo
 *   Implement 'view versus results'.  This can't be done in any good way
 *   right now as Views 1 doesn't support Drupal permissions. It only
 *   supports role-based permissions, which will differ on each site.
 */
function versus_perm() {
  return array('administer versus', 'vote with versus', 'view versus results');
}

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

/**
 * Define the settings form.
 *
 * @return array
 *   The form.
 */
function versus_settings() {

  $form['versus_voting_enabled'] = array(
    '#type'          => 'radios',
    '#title'         => t('Voting status'),
    '#default_value' => variable_get('versus_voting_enabled', 0),
    '#options'       => array(t('Disabled'), t('Enabled')),
    '#description'   => t('If voting is disabled, users cannot vote.  Select "Enabled" to allow it, or select "Disabled" to take it off-line.  Other modules (e.g. <a href="http://drupal.org/project/competition">Competition</a>) may (un)set this.'),
  );

  $form['versus_types_enabled'] = array(
    '#type'          => 'checkboxes',
    '#title'         => t('Enabled content types'),
    '#description'   => t('Select the content types whose nodes can be voted on.'),
    '#default_value' => versus_types_enabled(),
    '#options'       => versus_node_get_types(),
  );

  return system_settings_form($form);
}

/**
 * Define the voting form on a ballot.
 *
 * @param $winner
 *   The node ID of the left voting option.
 * @param $loser
 *   The node ID of the right voting option.
 * @param $type
 *   The node type of the vote combination.
 * @return array
 *   The form.
 */
function versus_voting_form($winner, $loser, $type) {

  // Create the submit button.
  $form['op'] = array(
    '#type'  => 'submit',
    '#value' => $winner,
    '#theme' => 'versus_vote_button',
  );

  // Set up some information that we'll need after processing the form.
  // This includes the winner, loser and the type.
  $form['vote_refs'] = array(
    '#type'  => 'value',
    '#value' => array(
      'versus_winner' => $winner, 
      'versus_loser'  => $loser, 
      'node_type'     => $type,
    ),
  );

  // Return our form.
  return $form;
}

/**
 * Process a voting form submission.
 */
function versus_voting_form_submit($form_id, $form_values) {

  // Figure out who won & who lost.
  $winner = $form_values['vote_refs']['versus_winner'];
  $loser  = $form_values['vote_refs']['versus_loser'];

  // Record the vote in the database.
  $result = votingapi_add_vote('node', $loser, $winner, 'option', 'versus');

  // Take the user to the next voting ballot.
  drupal_goto('versus/vote/'. arg(2) . (arg(3) ? '/'. arg(3) : ''));
  return;
}

/****************************************************************************
 ** PRIVATE FUNCTIONS *******************************************************
 ****************************************************************************/

/**
 * Get a list of content types that are enabled for voting.
 *
 * @return
 *   The array of content types.
 */
function versus_types_enabled() {
  return variable_get('versus_types_enabled', array());
}

/**
 * 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 versus_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;
}

/**
 * Display voting options to users.
 *
 * @return
 *   The themed output.
 */
function versus_voting_options() {
  
  // Declare a list of options and some header info.
  $options      = array();
  $instructions = t('Choose the appropriate item from the list:');

  // Present a voting option if the correct permissions exist.
  if (user_access('vote with versus')) {
    $options[] = array(
      'title'       => t('Cast Votes'),
      'path'        => 'versus/vote',
      'description' => t('Vote on items within a particular content type.'),
    );
  }

  // Present a link to the standings if the correct permissions exist.
  if (user_access('view versus results')) {
    $options[] = array(
      'title'       => t('View Standings'),
      'path'        => 'versus/standings',
      'description' => t('Look at the current standings for a particular content type.'),
    );
  }

  // Return the themed output.
  return theme('versus_voting_options', $instructions, $options);
}

/**
 * Receive a voting request.
 *
 * Either validate a voting request for a particular type, or show a list
 * of types that can voted on.
 *
 * @param $type
 *   The content type to vote on.
 * @param $competition
 *   The competition that the voting content should be part of,
 *   if the Competition module is enabled.
 * @return
 *   The content type's voting page, or a list of content type options
 *   if no valid type is provided.
 * @todo
 *   Set up a hook so that code for other modules doesn't have to be
 *   in here.  It'll keep things cleaner & nicer.
 */
function versus_vote_request($type = NULL, $competition = NULL) {

  // Perform some checks for the Competition module.
  if (module_exists('competition')) {

    // Make sure that we're in a voting phase.
    if (!variable_get('versus_voting_enabled', FALSE)) {
      drupal_set_message(t("Sorry, but you can't vote now.  We're not currently in a voting phase."), 'error');
      drupal_goto();
    }

    // Make sure that we're getting a valid competition node ID.
    if ($competition) {

      // Check for SQL injection.
      if (!db_result(db_query(
          'SELECT COUNT(*) FROM {content_type_competition} WHERE (nid = %d)',
          $competition))) {
        watchdog('security', t('Detected possible SQL injection attempt.'),
          WATCHDOG_WARNING);
        drupal_goto();
      }

      // Make sure it exists & is in the current round.
      $round = db_result(db_query("
        SELECT field_competition_round_value FROM {content_type_competition}
        WHERE nid = %d
      ", $competition));
      if ($round != competition_round_get_current()) {
        drupal_set_message(t("You can only vote on a competition in the current round, round " . competition_round_get_current() . "."), 'error');
        drupal_goto();
      }
    }
    else /* !$competition */ {
      return versus_voting_competitions(competition_round_get_current());
    }
  }

  // Make sure that any provided type is valid.
  $types = versus_types_enabled();
  if (isset($types[$type])) {
    $output = versus_vote_process_type($type, $competition);
  }
  else /* no valid content type has been provided */ {
    $output = theme('versus_voting_types', $types);
  }

  return $output;
}

/**
 * Display current competitions that can be voted on.
 *
 * @param $round
 *   The current round.
 * @return
 *   HTML showing the current competitions and their content types
 *   that can be voted on.
 */
function versus_voting_competitions($round) {

  // Fetch the active competitions & their content types.
  $result = db_query(db_rewrite_sql("
    SELECT n.title, c.field_competition_round_value AS round, ct.nid,
           ct.delta, ct.field_competition_content_types_value AS type
    FROM {node} n
    INNER JOIN {content_type_competition} c ON n.nid = c.nid
    INNER JOIN {content_field_competition_content_types} ct ON c.nid = ct.nid
    WHERE c.field_competition_round_value = %d
    ORDER BY ct.nid, ct.vid, ct.delta
  "), $round);

  // Stick the fetched data into an array.
  $competitions = array();
  while ($db_object = db_fetch_object($result)) {
    $nid = $db_object->nid;
    $competitions[$nid]['nid']                      = $db_object->nid;
    $competitions[$nid]['title']                    = $db_object->title;
    $competitions[$nid]['types'][$db_object->delta] = $db_object->type;
  }

  // Set some instructions.
  $instructions = t('Which competition and content type would you like to vote on?');

  // Return the themed data.
  return theme('versus_voting_competitions', $instructions, $competitions);
}

/**
 * Process a voting request for a particular content type.
 *
 * @param $type
 *   The content type to vote on.
 * @param $competition
 *   The competition that the voting should be restricted to.
 *   This is irrelevant when the Competition module is not enabled.
 * @return
 *   Any output from the processing.
 * @todo
 *   Instead of containing code for other modules, this function should gather
 *   all conditions from modules that implement hook_versus_conditions(). The
 *   hook should return an array of conditions as strings.
 */
function versus_vote_process_type($type, $competition = NULL) {
  global $user;

  // Set any conditions that nodes must meet in order to become candidates.
  // By default, there are no conditions, and all nodes of a particular
  // type are candidates for voting.
  $conditions = array("TRUE");

  // Add conditions for the competition module.
  if (module_exists('competition')) {

    // Make sure that we're in the voting phase.
    if (competition_phase_get_current() != COMPETITION_PHASE_VOTING) {
      $conditions[] = "FALSE";
    }

    // Each node to be voted upon must belong to the current round.
    // We already check for SQL injection attempts, so we don't need to here.
    $conditions[] = "(
      SELECT (
        SELECT entry.field_competition_entry_comp_nid 
        FROM {content_type_competition_entry} entry 
        WHERE entry.nid = (
          SELECT r.parent_nid FROM {relativity} r WHERE r.nid = n.nid
        )
      ) = $competition
    )";
  }

  // Marshal the conditions.
  $conditions = implode(" AND ", $conditions);

  // Request the list of node IDs for the required type.
  $result = db_query(db_rewrite_sql("
    SELECT n.nid, n.type FROM {node} n WHERE n.type = '%s' AND $conditions
    ORDER BY RAND()
  "), $type);

  // Fetch them.
  $nids = array();
  while ($db_object = db_fetch_object($result)) {
    $nids[] = (object) array(
      'nid'  => $db_object->nid,
      'type' => $db_object->type,
    );
  }

  // Initialize some voting options.
  $left  = NULL;
  $right = NULL;
  $done  = FALSE;

  // If there's only one result, assign it to the left option.
  if (count($nids) == 1) {
    $left = $nids[0];
  }

  // There are more than two candidates, so we need to show a left & right
  // option for the user to vote on.
  if (count($nids) >= 2) {

    // Request the user's previous votes so we'll know what not to show
    // him/her again.  In Drupal 5, the Voting API doesn't provide a useful
    // function for returning all of the votes of a particular user.
    // Therefore, we need to go around the API and dig into the DB directly.
    // This won't be necessary in Drupal 6 because the Drupal 6 version of
    // the Voting API provides a much more general way of obtaining such
    // data through the two functions votingapi_select_votes() and
    // votingapi_select_results().  It appears as though the latter grabs
    // data from the cache while the former does not.  We can use one of
    // these in the Drupal 6 version of Versus, and do away with the
    // following query.
    $result = db_query("
      SELECT content_id AS loser, value AS winner FROM {votingapi_vote}
      WHERE (content_type = 'node')
      AND (value_type = 'option')
      AND (tag = 'versus')
      AND (uid = %d)
    ", $user->uid);

    // Marshal the data into an array.
    $votes = array();
    while ($db_object = db_fetch_object($result)) {
      $votes[] = (object) array(
        'loser'  => $db_object->loser,
        'winner' => $db_object->winner,
      );
    }

    // Cycle through each pair of nodes.
    foreach ($nids as $pos1 => $node1) {
      foreach ($nids as $pos2 => $node2) {
  
        // Don't compare nodes that have already been compared,
        // or nodes that are of different types.
        if (($pos2 <= $pos1) || ($node1->type != $node2->type)) {
          continue;
        }
  
        // Create a pair with the first node as the loser, and the second
        // as the winner.
        $order1 = (object) array(
          'loser'  => $node1->nid,
          'winner' => $node2->nid,
        );
  
        // Create a pair with the second node as the loser, and the first
        // as the winner.
        $order2 = (object) array(
          'loser'  => $node2->nid,
          'winner' => $node1->nid,
        );
  
        // Check to see if either of them are in the list of previous votes
        // for this user.  If either of them are, we need to skip this pair
        // and try to find another one.
        if (in_array($order1, $votes) || in_array($order2, $votes)) {
          continue;
        }
        else /* this pair hasn't been voted on yet */ {
  
          // Assign the current pair to the left and right options,
          // and then get off this roller coaster.
          $left  = $node1;
          $right = $node2;
          break;
        }
      }
    }
  }

  // If the left and right options haven't been set, we can only assume
  // that the user has voted on all possible pairs.  Therefore, the user
  // is done voting in this category.
  if (!($left || $right)) {
    $done = TRUE;
  }

  // Return a ballot based on what we've discovered above.
  return versus_voting_ballot(count($nids), $done, $left, $right);
}

/****************************************************************************
 ** THEME FUNCTIONS *********************************************************
 ****************************************************************************/

/**
 * Theme the general voting options.
 *
 * @param $instructions
 *   The instructions.
 * @param $options
 *   A list of  associate arrays containing the following elements:
 *     'title'       - the page title
 *     'path'        - the local Drupal path that the item links to
 *     'description' - a description of the item
 * @return
 *   The themed output as HTML.
 */
function theme_versus_voting_options($instructions, $options) {

  // Print the instructions.
  $output = "<p>$instructions</p>";

  // Present the options as a definition list.
  $output .= "<dl>";
  foreach ($options as $option) {
    $output .= "<dt>" . l($option['title'], $option['path']) . "</dt>";
    $output .= "<dd>" . $option['description'] . "</dd>";
  }
  $output .= "</dl>";

  // Return the HTML.
  return $output;
}

/**
 * Theme a display of the competitions and their content types that
 * can be voted on.
 *
 * @param $instructions
 *   The instructions.
 * @param $competitions
 *   A list of associated arrays representing competitions and their
 *   content types.  Each item contains the following elements:
 *     'nid'   - the node ID of the competition
 *     'title' - the title of the competition
 *     'types' - a list of content types accepted by the competition
 * @return
 *   The themed output as HTML.
 */
function theme_versus_voting_competitions($instructions, $competitions) {

  // Set the voting path.  Perhaps this should be an argument?
  $path = "versus/vote";

  // Print the instructions.
  $output = "<p>$instructions</p>";

  // Present the options as a definition list.
  $output .= "<dl>";
  foreach ($competitions as $competition) {

    // For each competition, we need the ID, title and types it supports.
    $nid   = $competition['nid'];
    $title = $competition['title'];
    $types = $competition['types'];

    // Display a link to each competition.
    $output .= "<dt>" . l($title, "node/$nid") . "</dt>";

    // Each definition is a list of available types.
    $output .= "<dd><ul>";
    foreach ($types as $type) {

      // Display a link for each type so that it can be voted on.
      $type_name = node_get_types('name', $type);
      $output .= "<li>" . l($type_name, "$path/$type/$nid")  . "</li>";
    }
    $output .= "</ul></dd>";
  }
  $output .= "</dl>";

  // Return the HTML.
  return $output;
}

/**
 * Theme a general voting request.
 *
 * @param $types
 *   The content types that can be voted on.
 * @return
 *   The themed output of the voting options.
 */
function theme_versus_voting_types($types) {

  // Get an overview of all content types that can be voted on.
  foreach ($types as $type => $name) {

    // Skip unset content types.
    if ((!$type) || (!$name) || ($type == 1)) {
      continue;
    }

    // Show a link for each thing that can be vored on.
    $title = t('Vote for an existing @s.', array('@s' => $name));
    $out = '<dt>'. l(
      node_get_types('name', $name),
      "versus/vote/". $type,
      array('title' => $title)
    ) .'</dt>';
    $item[$type] = $out;
  }

  // Add a title & format it.
  if (isset($item)) {
    uksort($item, 'strnatcasecmp');
    $output = t('Choose the type of content that you would like to vote on:') .
      '<dl>'. implode('', $item) .'</dl>';
  }
  else {
    $output = t('No content types available for voting.');
  }

  return $output;
}

/**
 * Prepare the output for the voting ballot.
 *
 * @param $candidates
 *   The size of the candidate pool.
 * @param $done
 *   TRUE if the user has finished voting, FALSE otherwise.
 * @param $left
 *   The node representing the choice on the left.
 * @param $right
 *   The node representing the choice on the right.
 * @return
 *   The themed output of whatever's on the voting ballot.
 */
function versus_voting_ballot($candidates, $done = FALSE,
                                    $left = NULL, $right = NULL) {

  // Check if there's nothing to vote on.
  if (!$candidates) {
    drupal_set_title(t('No voting for this content type'));
    return t('There are no candidates of this type to vote on.  Please select a different type of content for voting over at <a href="/versus/vote">the selection page</a>.');
  }

  // Check if we've only got one candidate.  It, clearly, is the winner,
  // so there's nothing to vote on.  However, we should say what the winner
  // is, and provide a link to it.
  if ($candidates < 2) {
    drupal_set_title(t('No voting for this content type'));
    return t('There is only one candidate of this type available, so it wins by default.  Take a look at it by clicking <a href="/node/@nid">here</a>.',
      array('@nid' => $left->nid));
  }

  // Check if the user is done voting.
  if ($done) {
    drupal_set_title(t('Thanks for voting!'));
    return t('You have already voting on all pairs of candidates.  If you haven\'t voted for all types of content, please do so from the <a href="/versus/vote">selection page</a>.');
  }

  // Get all of the information for each voting option.
  $left  = node_load($left->nid);
  $right = node_load($right->nid);

  // Set the page title.
  drupal_set_title(t('@left vs. @right', array(
    '@left'  => check_plain($left->title),
    '@right' => check_plain($right->title),
  )));

  return theme('versus_voting_ballot', $left, $right);
}

/**
 * Theme the voting ballot.
 *
 * @param $left
 *   The node representing the choice on the left.
 * @param $right
 *   The node representing the choice on the right.
 * @return
 *   The themed output of whatever's on the voting ballot.
 */
function theme_versus_voting_ballot($left = NULL, $right = NULL) {

  // Prepare the forms for each vote
  $input_left  = drupal_get_form('versus_voting_form',
                                  $left->nid, $right->nid, $left->type);
  $input_right = drupal_get_form('versus_voting_form',
                                  $right->nid, $left->nid, $left->type);

  // Show the teaser for each node side by side.
  $output  = '<table id="versus_box_choices" width="100%" border="0" cellspacing="0" cellpadding="0">';
  $output .= '  <tr>';
  $output .= '    <td>'. node_view($left, TRUE, FALSE, FALSE) .'</td>';
  $output .= '    <td>'. node_view($right, TRUE, FALSE, FALSE) .'</td>';
  $output .= '  </tr>';
  $output .= '  <tr>';
  $output .= '    <td>'. $input_left .'</td>';
  $output .= '    <td>'. $input_right .'</td>';
  $output .= '  </tr>';
  $output .= '</table>';

  // Return the ballot for display.
  return $output;
}

/**
 * Theme a voting button.
 *
 * @param $form
 *   The associated form.
 * @return
 *   The themed button.
 */
function theme_versus_vote_button($form) {
  return '<input type="submit" class="form-submit" value="Vote" id="edit-vote-ref-1" name="op"/>';
}

/****************************************************************************
 ** API FUNCTIONS ***********************************************************
 ****************************************************************************/

/**
 * Set the voting status.
 *
 * Other modules can use this function to enable or disable voting.
 *
 * @param $enabled
 *   TRUE to enable voting or FALSE to disable it.
 */
function versus_set_voting_status($enabled) {
  variable_set('versus_voting_enabled', $enabled);
}

/****************************************************************************
 ** VIEWS FUNCTIONS *********************************************************
 ****************************************************************************/

/**
 * Implementation of hook_views_tables().
 */
function versus_views_tables() {
  $tables['versus'] = array(
    'name'   => 'versus',
    'fields' => array(
      'votes' => array(
        'name'          => t('Versus: votes'),
        'help'          => t('Number of Versus votes for the node.'),
        'sortable'      => TRUE,
        'notafield'     => TRUE,
        'query_handler' => 'versus_query_handler_votes',
      ),
    ),
  );
  return $tables;
}

/**
 * Views query handler to define the number of Versus votes.
 */
function versus_query_handler_votes($field, $fieldinfo, &$query) {
  $query->add_field('(SELECT COUNT(value) AS votes FROM votingapi_vote WHERE value = node.nid)', '', 'versus_votes');
}

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

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

  // Define an exported view.
  $view = new stdClass();
  $view->name = 'versus_standings';
  $view->description = 'The Versus standings organized by content type (& competition if applicable)';
  $view->access = array (
);
  $view->view_args_php = '';
  $view->page = TRUE;
  $view->page_title = 'Standings by Content Type';
  $view->page_header = '';
  $view->page_header_format = '1';
  $view->page_footer = '';
  $view->page_footer_format = '1';
  $view->page_empty = 'As yet, no votes have been cast for this content type.';
  $view->page_empty_format = '1';
  $view->page_type = 'table';
  $view->url = 'versus/standings';
  $view->use_pager = TRUE;
  $view->nodes_per_page = '100';
  $view->menu = TRUE;
  $view->menu_title = 'View Standings';
  $view->menu_tab = FALSE;
  $view->menu_tab_weight = '0';
  $view->menu_tab_default = FALSE;
  $view->menu_tab_default_parent = NULL;
  $view->menu_tab_default_parent_type = 'tab';
  $view->menu_parent_tab_weight = '0';
  $view->menu_parent_title = '';
  $view->sort = array (
  );
  $view->argument = array (
    array (
      'type' => 'nodetype',
      'argdefault' => '4',
      'title' => '%1 Standings',
      'options' => '',
      'wildcard' => '',
      'wildcard_substitution' => '',
    ),
  );
  // This argument should only exist when the Competition module is enabled.
  if (module_exists('competition')) {
    $view->argument[] = array(
      'type' => 'competition_id',
      'argdefault' => '4',
      'title' => '%1 Standings for %2',
      'options' => '',
      'wildcard' => '',
      'wildcard_substitution' => '',
    );
  }
  $view->field = array (
    array (
      'tablename' => 'node',
      'field' => 'nid',
      'label' => 'Node ID',
    ),
    array (
      'tablename' => 'node',
      'field' => 'title',
      'label' => 'Name',
      'handler' => 'views_handler_field_nodelink',
      'options' => 'link',
    ),
    array (
      'tablename' => 'users',
      'field' => 'name',
      'label' => 'Author',
    ),
    array (
      'tablename' => 'versus',
      'field' => 'votes',
      'label' => 'Votes',
      'sortable' => '1',
      'defaultsort' => 'DESC',
    ),
  );
  $view->filter = array (
    array (
      'tablename' => 'node',
      'field' => 'status',
      'operator' => '=',
      'options' => '',
      'value' => '1',
    ),
  );
  $view->exposed_filter = array (
  );
  $view->requires = array(node, users, versus);
  $views[$view->name] = $view;

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