modules/planet/planet.module

<?php
// $Id: planet.module Exp $

 /**
 * @file
 * The planet module.
 *
 * Planet is an aggregator that allows you to aggregate the blogs for
 * users in a given role (e.g. staff) and associate content with the
 * users rather than as a detached feed. This provides the benefit of
 * showing avatars with content, providing per-user aggregation of
 * planet content in addition to blog content, etc.
 * 
 */

/**
 * Implementation of hook_node_info.
 * 
 * @return An array of information on the module's node types.
 *
 * @ingroup planet_node
 */
function planet_node_info() {
  return array(
    'planet' => array(
      'name' => t('Planet Entry'),
      'module' => 'planet',
      'description' => t('Node to contain posts aggregated from various blogs.'),
    )
  );
}

/**
 * Implementation of hook_perm - Defines user permissions.
 * The suggested naming convention for permissions is "action_verb modulename".
 *
 * @return An array of permissions strings.
 *
 * @ingroup base
 */
function planet_perm() {
  return array('administer planet', 'administer own planet feeds', 'view all planet nodes');
}

/**
 * Implementation of hook_help - Provides online user help.
 * 
 * @param $path A Drupal menu router path the help is being requested for
 * @param $arg
 * @return A localized string containing the help text. 
 *
 * @ingroup base
 */
function planet_help($path, $arg) {
  switch ($path) {
    case 'admin/help#planet':
      // The module's help text, displayed on the admin/help page and through the module's individual help link. 
      $output = '<p>Planet is an aggregator that allows you to aggregate your users blogs and to display them in a "planet" fashion. Associating content with the users rather than as a detached feed.</p>';
      $output .= '<p>To use planet, go to admin/settings/planet and note the following sections:</p>';
      $output .= '<ul>';
      $output .= '<li><strong>General Settings</strong>. The filter format drop down will allow you to select the filter format that will be used to show planet entry nodes.</li>';
      $output .= '<li><strong>Feeds</strong>. This section lets you add a new feed. Give it a title, select an author, provide the feed url, and you\'re off. You\'ll have to manually refresh it or wait for a cron run for items to be imported.</li>';
      $output .= '<li><strong>Feeds</strong>. This section lists current feeds, when they were last updated, how many items they have, and it allows you to edit, refresh, or freeze them. Freezing is a quick way to temporarily suspend updates from the given feed.</li>';
      // @DIFFGROUP output syntax
      $output .= '</ul>';
      return $output;
      // @DIFFINFO in D6, admin/modules#description is moved to .info file
  }
}

/**
 * Implementation of hook_view() - Displays a planet node.
 * 
 * @param $node  The node to be displayed.
 * @param $teaser  Whether to generate only a summary ("teaser") of the node.
 * @param $page  Whether the node is being displayed as a standalone page.
 * @return The modified $node parameter, properly presented for output. 
 * 
 * @ingroup planet_node
 * @CRUD{variables,R}
 * @CRUD{planet_items,R}
 */
function planet_view($node, $teaser = FALSE, $page = FALSE) {
  // @DIFFINFO removed $link param to match D6 hook definition
  if ($page === true && variable_get('planet_redirect_page', 0) == 1) {
    // @DIFFINFO only 'link' field is used, so I restricted the query 
    $obj = db_fetch_object(db_query('SELECT link FROM {planet_items} WHERE nid = %d', $node->nid));
    // @DIFFINFO if the query succeeds, $obj->nid == $node->nid , otherwise, $obj==FALSE,
    if ($obj && $obj->link != '') {
      header('Location: '. $obj->link);
      exit;
    }
  }
  else {
    return node_prepare($node, $teaser);
  }
}

/**
 * Implementation of hook_access() - Define access permissions for planet nodes  (aka CRUD) .
 * @param $op  The operation to be performed: 'create', 'view', 'update', 'delete'
 * @param $node  The node on which the operation is to be performed, or, if it does not yet exist, the type of node to be created.
 * @param $account  A user object representing the user for whom the operation is to be performed.
 * @return true if the user is allowed to perform operation, false otherwise.
 * 
 * @ingroup planet_node
 */
function planet_access($op, $node, $account) {
  // @DIFFINFO using planet-dedicated permissions
  // Planet administrator has all permissions related to planet module
  if (user_access('administer planet', $account)) 
    return TRUE;
  // Users allowed to edit their own planet nodes, are also allowed to create them, others are not.
  $author = user_access('edit own planet feeds', $account);
  if ($op == 'create') {
    return $author;
  }
 
  // Does current user own requested node ?
  $own = $account->uid == $node->uid;
  if ($op == 'view')
    return $own || user_access('view all planet nodes');
  if ($op == 'update' || $op == 'delete') {
    return $author && $own;    // ok if $author owns the node
  }
  trigger_error("Unknown operation requested: $op");
  return FALSE;
}

/**
 * Implementation of hook_menu() - Defines menu items and page callbacks.
 * 
 * @return An array of menu items. 
 * Each menu item has a key corresponding to the Drupal path being registered. 
 * 
 * @ingroup base
 *
 * This diagram shows how requests are handled.
 * Each arrow is labeled with the permission required to access link.
 * The menu item colors reflect the item type.
 * @dotfile menu-links.dot "Menus and Pages"
 */
function planet_menu() {
  $items['admin/settings/planet'] = array(
    'title' => 'Planet Settings',
    'description' => 'Configure settings for the planet module.',
    'page callback' => '_planet_settings',
    'access arguments' => array('administer nodes'),
    'type' => MENU_NORMAL_ITEM);
  
  $items['user/%user/planet'] = array(
    'title' => 'Planet Feeds',
    'page callback' => 'planet_user_feeds',
    'page arguments' => array(1),
    'access arguments' => array('administer own planet feeds'),
    'type' => MENU_LOCAL_TASK,
  );
  
  //  if (arg(0) == 'planet' && is_numeric(arg(1))) {
  // FIXME access denied http://localhost/drupal/?q=planet/1
  $items['planet/'. '%'] = array(
    'title' => 'planet',
    'page callback' => 'planet_page_user',
    'page arguments' => array(arg(1))
  );

  //   if (arg(3) == 'refresh' && is_numeric(arg(4))) {
  $items['admin/settings/planet/refresh/%'] = array(
    'title' => 'planet refresh',
    'page callback' => 'planet_call_refresh',
    'access arguments' => array('administer nodes'),
    'type' => MENU_CALLBACK
  );

  //  if (is_numeric(arg(4)) && (arg(3) == 'freeze' || arg(3) == 'unfreeze')) {
  $items['admin/settings/planet/'. arg(3) .'/%'] = array(
    'title' => 'planet freeze',
    'page callback' => 'planet_toggle_frozen',
    'access arguments' => array('administer nodes'),
    'type' => MENU_CALLBACK
  );

  $items['planet'] = array(
    'title' => 'Planet',
    'description' => 'Planet Page',
    'page callback' => 'planet_page_last',
    'access arguments' => array('access content'),
    'type' => MENU_NORMAL_ITEM
  );
    
  $items['planet/feed'] = array(
    'title' => 'Planet',
    'page callback' => 'planet_feed',
    'access arguments' => array('access content'),
    'type' => MENU_CALLBACK
  );  
      
  return $items;
}


/**
 * Page callback for 'admin/settings/planet/refresh/%' ("planet refresh")
 *
 * @ingroup page
 */
function planet_call_refresh() {  
  $title = planet_refresh();
  watchdog('planet', 'Feed "'. $title .'" refreshed.');
  drupal_set_message('Feed "'. $title .'" refreshed.');
  drupal_goto('admin/settings/planet');
}

/**
 * Page callback for 'admin/settings/planet/(un|)freeze/%' ("planet freeze")
 *
 * @ingroup page
 * @CRUD{planet_feeds,U}
 */
function planet_toggle_frozen() {
  
  $fid = intval(arg(4));
  db_query('UPDATE {planet_feeds} SET frozen = %d WHERE fid = %d', arg(3) == 'unfreeze' ? 0 : 1, $fid);
  drupal_set_message('Feed '. (arg(3) == 'unfreeze' ? 'un' : '') .'frozen.');
  drupal_goto('admin/settings/planet');
}


/**
 * Deletes a feed and related items
 * @param $fid the feed identifier key (integer)
 * @param $path the drupal path for redirection after user confirmed.
 * 
 * @internal
 * @ingroup planet_feed
 * @CRUD{planet_items,R}
 * @invoke{drupal_get_form,planet_multiple_delete_confirm}
 */
function planet__drop_feed($fid, $path) {
  // @DIFFINFO documented $path param, removed unused $edit param
  
      $result = db_query('SELECT nid FROM {planet_items} WHERE fid = %d', $fid);
      $nodes = array(); // @DIFFINFO needs to be defined even empty (@FIXME it shouldn't be !)
      while ($node = db_fetch_object($result)) {
        $nodes[$node->nid] = TRUE;
      }
      return drupal_get_form('planet_multiple_delete_confirm', $nodes, 
                             $fid, $path);
}

/**
 * Page callback for 'user/%user/planet' ("Planet Feeds")
 * 
 * @ingroup page
 * @CRUD{planet_feeds,R}
 * @invoke{drupal_get_form,planet_multiple_delete_confirm_submit}
 * @invoke{drupal_get_form,planet_feed_form}
 */
function planet_user_feeds() {
  global $user;
  if ($_POST) {  
    return planet__update($_POST, 'user/'. $user->uid .'/planet');
  }
  else { // no $_POST    
    $fid = intval(arg(3));      // @deprecated: arg()
    if ($fid > 0) {      
      $edit = db_fetch_array(db_query('SELECT * FROM {planet_feeds} WHERE fid = %d', $fid));
      $output .= drupal_get_form('planet_feed_form', $edit, true, $user);
    }
    else {
    
      $output .= drupal_get_form('planet_feed_form', $edit, false, $user);
    
      $output .= '<h2>Feeds</h2>';
      $output .= planet__build_user_feeds_table();
    }
    print theme('page', $output);    
  }
}

// Note: I use 'planet__' prefix to name internal functions
// TODO: apply the same naming convention (this one or another) in whole module
/**
 * @todo merge with planet__build_admin_feeds_table()
 * 
 * @ingroup planet_feed
 * @internal
 * @CRUD{planet_feeds,R}
 * @CRUD{planet_items,R}
 */
function planet__build_user_feeds_table() {
  // @DIFFINFO renamed planet__build_feeds_table1
  global $user;
      $feeds = db_query('SELECT  fid, title, checked FROM {planet_feeds} '
                        . ' WHERE uid = %d;', $user->uid);
      $rows = array();
      $headers = array('Feed', 'Items', 'Edit', 'Last checked');
      $now = time();
      $items_statement = 'SELECT count(*) FROM {planet_items}'
        . ' WHERE fid=%d';
      // TODO: change this to prepared statement when supported by drupal DB abstraction layer.
      while ($feed = db_fetch_object($feeds)) {
        $_checked = $now - $feed->checked;
        $checked = intval($_checked / 60) .' minutes';
        if ($_checked % 60 > 0) {
          $checked .= ', '. $feed->_checked % 60 .' seconds';
        }
        $checked .= ' ago';
        $items = db_query($items_statement, $feed->fid);
        if (!$items) trigger_error('ERROR while counting feed items.');
        $cnt = db_result($items);
        array_push($rows, array(
          $feed->title,
          $cnt,
          l('edit', 'user/'. $user->uid .'/planet/'. intval($feed->fid)),
          $checked,
          )
        );
      }
      return theme('table', $headers, $rows);      
}

/**
 * Updates a feed
 */
function planet__update($edit, $path) {
    // @DIFFINFO Username can change, so we need to store the ID, not the username.
    $edit['uid'] = db_result(db_query("SELECT uid from {users} WHERE name = '%s'", $edit['username']));
    unset($edit['username']);
    $fid = intval($edit['fid']);
    if (($edit['op'] == 'Delete') && ($fid != 0)) {
      return planet__drop_feed($fid, $path);
    }
    else if ($edit['op'] == 'Delete all' && $edit['confirm'] == 1) {      
      $edit['fid'] = intval(arg(3)); // @deprecated arg()
      $edit['redirect'] = $path;
      return drupal_get_form('planet_multiple_delete_confirm_submit', $edit);
    } 
    else {    
      planet__submit_feed_data($edit);
    }  
    drupal_goto($path); 
}

/**
 * Submit the feed's data to the appropriate update or add function
 */
function planet__submit_feed_data($data) {
  if (isset($data['fid'])) {
    if (intval($data['fid']) == 0) {
      planet__add_feed($data);
    } else {
      planet__update_feed($data);
    }
  } else {
      // TODO if user needs to click separately for each fieldset,
      //  why not using different forms ?
      // or conversely, allow setting everything at once ?
      planet__update_vars($data);
  }  
}

/**
 * Adds a new feed to planet_feeds table.
 * @param $data associative array with keys 
 *        'uid' (optional), 'title', 'link', 'image' (optional)
 * @return success status
 * 
 * @ingroup planet_feed
 * @internal
 * @CRUD{planet_feeds,C}
 */
function planet__add_feed($data) {
  $data['checked'] = 0;
  $data['frozen']  = 0;
  // @DIFFINFO Removed debugging block. Internal function is supposed to receive clean arguments. Checking will be left to planet_feed class

  $rslt = drupal_write_record('planet_feeds', $data);
  if ($rslt==SAVED_NEW) {
    $title = planet_refresh(intval($data['fid']));
    drupal_set_message('Added new feed: ' . $title);    
    return TRUE;
  }
  trigger_error('Failed to add new feed');
  return FALSE;
}

/**
 * Updates an existing feed in planet_feeds table.
 * @param $data associative array with keys 
 *        'fid' (mandatory, primary key), 
 *         other fields as needed:
 *        'uid', 'title', 'link', 'image', 'checked', 'frozen'
 * @return success status
 * 
 * @ingroup planet_feed
 * @internal
 * @CRUD{planet_feeds,U}
*/
function planet__update_feed($data) {
  $rslt = drupal_write_record('planet_feeds', $data, 'fid');

  if ($rslt==SAVED_UPDATED) { 
    drupal_set_message('Edited "'. $data['title'] .'" feed.');
    return TRUE;
  }
  if ($rslt==SAVED_NEW) // @DEBUGGING
    trigger_error('Feed {$data->fid} didn\'t exist. Record added.', E_ERROR);
  else 
    trigger_error('Failed to edit feed');
  return FALSE;
}      

/**
 * Updates an planet settings persistent variables.
 * @param $data associative array with all optional keys 
 *        'planet_filter_formats', 'planet_redirect_page'.
 * 
 * @ingroup isettings
 * @internal
 * @CRUD{variables,CUD}
*/
function planet__update_vars($data) {
  if ($data['planet_filter_formats']) {
    variable_set('planet_filter_formats', $data['planet_filter_formats']);
  }
  if ($data['planet_redirect_page'] == 1) {
    variable_set('planet_redirect_page', $data['planet_redirect_page']);
  } else {
    variable_del('planet_redirect_page');
  }
  drupal_set_message('Edited general planet settings.');              
}

/**
 * Page callback for 'admin/settings/planet' ("Planet Settings")
 * 
 * @ingroup page
 * @CRUD{planet_items,R}
 * @CRUD{planet_feeds,R}
 * @invoke{drupal_get_form,planet_multiple_delete_confirm}
 * @invoke{drupal_get_form,planet_multiple_delete_confirm_submit}
 * @invoke{drupal_get_form,planet_feed_form}
 * @invoke{drupal_get_form,planet_settings_form}
 */
function _planet_settings() {
  if ($_POST) {  
    return planet__update($_POST, 'admin/settings/planet');
  } else {    
    $fid = intval(arg(3)); // @deprecated arg()
    if ($fid > 0) {      
      $edit = db_fetch_array(db_query('SELECT * FROM {planet_feeds} WHERE fid = %d', $fid));
      $output .= drupal_get_form('planet_feed_form', $edit, true);
    }
    else {
    
      $output .= drupal_get_form('planet_settings_form');  

      $output .= drupal_get_form('planet_feed_form', $edit);
    
      $output .= '<h2>Feeds</h2>';
      $output .= planet__build_admin_feeds_table();
    }
    print theme('page', $output);    
  }
}

/**
 * builds an HTML table of feeds for administrator interaction.
 * 
 * @return 
 * 
 * @ingroup planet_feed
 * @internal
 * @CRUD{planet_feeds,R}
 * @CRUD{planet_items,R}
 */
function planet__build_admin_feeds_table() {
  // @DIFFINFO renamed planet__build_feeds_table() {
  // @DIFFINFO the admin section is supposed to let you administer everyone not just the admin.. ;P  
  $feeds = db_query('SELECT  fid, title, checked, frozen FROM {planet_feeds}');
  $rows = array();
  $headers = array('Feed', 'Items', 'Edit', 'Last checked', 'Refresh', 'Freeze');
  $now = time();
  $items_statement = 'SELECT count(*) FROM {planet_items} WHERE fid=%d';
  // TODO: change this to prepared statement when supported by drupal DB Abstraction Layer.
  while ($feed = db_fetch_object($feeds)) {
    $_checked = $now - $feed->checked;
    $checked = intval($_checked / 60) .' minutes';
    if ($_checked % 60 > 0) {
      $checked .= ', '. $feed->_checked % 60 .' seconds';
    }
    $checked .= ' ago';
    $items = db_query($items_statement, $feed->fid);
    if (!$items) trigger_error('ERROR while counting feed items.');
    $cnt = db_result($items);
    $fid = strval($feed->fid);
    array_push($rows, array(
                            $feed->title,
                            $cnt,
                            l('edit', 'admin/settings/planet/'. $fid),
                            $checked,
                            l('refresh', 'admin/settings/planet/refresh/'. $fid),
                            l($feed->frozen ? 'unfreeze' : 'freeze', 'admin/settings/planet/'. ($feed->frozen ? 'unfreeze/' : 'freeze/') . $fid)          
                            )
               );
  }
  return theme('table', $headers, $rows);      
}

/**
 * TODO.
 * 
 * @param &$form_state  
 * @param $nodes  
 * @param $fid  
 * @param $redirect  
 * @return 
 * 
 * @ingroup iforms
 * @CRUD{node,R}
 */
function planet_multiple_delete_confirm(&$form_state, $nodes, $fid, $redirect) {
  $form_state['values']['fid'] = $fid;
  $form_state['values']['redirect'] = $redirect;
  $form['nodes'] = array('#prefix' => '<ul>', '#suffix' => '</ul>', '#tree' => TRUE);
  // array_filter returns only elements with TRUE values
  foreach ($nodes as $nid => $value) {
    $title = db_result(db_query('SELECT title FROM {node} WHERE nid = %d', $nid));
    $form['nodes'][$nid] = array(
      '#type' => 'hidden',
      '#value' => $nid,
      '#prefix' => '<li>',
      '#suffix' => check_plain($title) ."</li>\n",
    );
  }
  $form['operation'] = array('#type' => 'hidden', '#value' => 'delete');
  $form['#submit'][] = 'planet_multiple_delete_confirm_submit';
  return confirm_form($form,
                      t('Are you sure you want to delete these items?'),
                      $redirect, t('This action cannot be undone.'),
                      t('Delete all'), t('Cancel'));
}

/**
 * TODO.
 * 
 * @param &$form_state  
 * @param $edit
 * @return 
 * 
 * @ingroup iforms
 * @CRUD{node,D}
 * @CRUD{planet_items,D}
 * @CRUD{planet_feeds,D}
 */
function planet_multiple_delete_confirm_submit(&$form_state, $edit) {
  $fid = $edit['fid'];
  if ($edit['confirm']) {
    foreach ($edit['nodes'] as $nid => $value) {
      node_delete($nid);
    }
    // @DIFFINFO inverted drop order to respect foreign keys
    db_query('DELETE FROM {planet_items} WHERE fid = %d', $fid);
    db_query('DELETE FROM {planet_feeds} WHERE fid = %d', $fid);
    drupal_set_message(t('The feed and items have been deleted.'));
  }
  drupal_goto($edit['redirect']);
}


/**
 * TODO.
 * 
 * @param &$form_state  
 * @return
 * @ingroup iforms 
 * @CRUD{role,R}
 * @CRUD{variables,R}
 */
function planet_settings_form(&$form_state) {
  $result = db_query('SELECT format, name FROM {filter_formats}');
  while ($format = db_fetch_object($result)) {
    $formats[$format->format] = $format->name;
  }

  $form = array();
  
  $form['general'] = array(
    '#type' => 'fieldset',
    '#title' => t('General Settings')
  );
  
  $form['general']['planet_filter_formats'] = array(
    '#type' => 'select',
    '#title' => t('Filter format for planet entry nodes'),
    '#options' => $formats,
    '#default_value' => variable_get('planet_filter_formats', 1),
    '#description' => t('Select the filter format that will be used to show planet entry nodes.')
  );
  
  $form['general']['planet_redirect_page'] = array(
    '#type' => 'checkbox',
    '#title' => t('Redirect node?'),
    '#return_value' => 1,
    '#value' => (variable_get('planet_redirect_page', 0) == 1) ? 1 : null,
    '#description' => t('Check this if you want the node view to redirect to the original content link; this is useful if you want the feed to forward through instead of showing the planet node.')
  );
  
  $form['general']['submit'] = array(
    '#type' => 'submit',
    '#value' => 'Save Configuration'
  );
  
  return $form;
}
    
/**
 * TODO.
 * 
 * @param &$form_state  
 * @param $edit  
 * @param $individual
 * @param $user
 * @return 
 * @ingroup iforms
 * @CRUD{users,R}
 * @CRUD{role,R}
 * @CRUD{users_roles,R}
 * @CRUD{variables,R}
 */
function planet_feed_form(&$form_state, $edit = array(), $individual = false, $user = NULL) {
  
  if ($individual) {
  $g_user = db_fetch_array(db_query('SELECT uid, name FROM {users} WHERE uid = %d', $edit['uid']));
  }
  
  $form = array();

  $form['feeds'] = array(
    '#type' => 'fieldset',
    '#title' => 'Feeds'
  );  

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

  $form['feeds']['title'] = array(
    '#type' => 'textfield',
    '#title' => t('Title'),
    '#value' => $edit['title'],
    '#size' => 40,
    '#maxlength' => 40
  );

  if ($user == NULL) {
    $form['feeds']['username'] = array(
      '#type' => 'textfield',
      '#title' => t('Original author'),    
      '#size' => 40,
      '#maxlength' => 60,
      '#default_value' => $g_user['name'],
      '#required' => TRUE,
      '#autocomplete_path' => 'user/autocomplete',
      '#description' => t('Select a user to associate this feed with')
    );
  }
  else {
    $form['feeds']['username'] = array(
      '#type' => 'hidden',
      '#value' => $user->name,
    );
  }
  $form['feeds']['link'] = array(
    '#type' => 'textfield',
    '#title' => t('URL'),
    '#value' => $edit['link'],
    '#size' => 40,
    '#maxlength' => 80
  );

  $form['feeds']['submit'] = array(
    '#type' => 'submit',
    '#value' => $edit['fid'] > 0 ? 'Save' : 'Add'.' Feed'
  );

  if ($individual) {
    $form['feeds']['delete'] = array(
      '#type' => 'submit',
      '#value' => 'Delete',
    );
  }

  return $form;
}

/**
 * Implementation of hook_cron - Perform periodic actions.
 * 
 * @return none
 * @ingroup system
 * @CRUD{planet_feeds,R}
 */
function planet_cron() {
  $result = db_query('SELECT fid FROM {planet_feeds} WHERE frozen = 0');
  while ($feed = db_fetch_object($result)) {
    $title = planet_refresh($feed->fid);
    watchdog('planet', 'Cron updated feed "'. $title .'".');
  }
}

 
/**
 * Private function; Checks a news feed for new items.
 * 
 * @param $fid  feed identifier (defaults to arg(4))
 * @return 
 * 
 * @private
 * @CRUD{planet_feeds,U}
 * @invoke{module_invoke,taxonomy_node_get_terms}
 */
function planet_refresh($fid = null) {
  if (!$fid) {
    $fid = intval(arg(4));
  }
  // initialize simplepie
  // we want to do this only once and not each time per feed, which would be slower
  include_once './'. drupal_get_path('module', 'planet') .'/simplepie.inc';
  
  $process_feed = db_fetch_object(db_query('SELECT * FROM {planet_feeds} WHERE fid = %d', $fid));
  
  $feed = new SimplePie();
  $feed->enable_cache(FALSE);
  $feed->set_timeout(15);
  // prevent SimplePie from using all of it's data santization since we use Drupal's input formats to handle this
  $feed->set_stupidly_fast(TRUE);
  $feed->set_feed_url($process_feed->link);
  // FeedBurner requires this check otherwise it won't work well with SimplePie
  // also performance improvement
  header('If-Modified-Since:'. $process_feed->checked);
  $success = $feed->init();
  
  if ($success && $feed->data) {
    // get a unique hash of the headers in the feed, fast and easy way to compare if this feed is updated or not
    $hash = md5(serialize($feed->data));

    // hashes don't match so likely the feed is updated
    if ($process_feed->hash != $hash) {
      // above we define hook_view() which then performs check_url() on the $url in the feed node
      // the problem is check_url() calls filter_xss_bad_protocol() which does it thing to prevent XSS
      // but it returns the string through check_plain() which calls htmlspecialchars()
      // this converts & in a url to &amp; and then causes SimplePie not to be able to parse it
      // because of this, we decode this URL since we are passing it directly to SimplePie
      // it is still encoded everywhere else it is output to prevent XSS
      $process_feed->link = htmlspecialchars_decode($process_feed->link, ENT_QUOTES);

      // turn each feed item into a node
      planet_item_feed_parse($process_feed, $feed);
    }

    // finished processing this feed so we can mark it checked
    db_query("UPDATE {planet_feeds} SET checked = %d, hash = '%s', error = 0 WHERE fid = %d", time(), $hash, $process_feed->fid);
  }
  else if (isset($feed->error)) {
    db_query("UPDATE {planet_feeds} SET error = 1 WHERE fid = %d", $process_feed->fid);
    watchdog('planet', 'The feed %feed could not be processed due to the following error: %error', array('%feed' => $process_feed->title, '%error' => $feed->error), WATCHDOG_ERROR, l('view', $process_feed->link));
  }
  else {
    watchdog('planet', 'You shouldn\'t be here. Something has gone terribly wrong.');
  }
  
  return $process_feed->title;
}

// @DIFFINFO removed orphaned doc-block

/**
 * Private function; Convert relative URLs
 * @ingroup rss
 * @private
 */
function planet_convert_relative_urls(&$data, $base_url) {
  $src = '%( href| src)="(?!\w+://)/?([^"]*)"%';
  $dst = '$1="'. trim($base_url, '/') .'/$2"';
  return preg_replace($src, $dst, $data);
}

/**
 * Page callback for 'planet' ("Planet").
 * @ingroup page
 * @CRUD{node,R}
 * @CRUD{variables,R}
 */
function planet_page_last() {
  global $user;

  $output = '<br />';

  $result = pager_query(db_rewrite_sql("SELECT n.nid, n.created FROM {node} n WHERE n.type = 'planet' AND n.status = 1 ORDER BY n.created DESC"), variable_get('default_nodes_main', 10));

  while ($node = db_fetch_object($result)) {
    $node = node_load($node->nid);
    $node->format = variable_get('planet_filter_formats', 1);
    $output .= node_view($node);
  }
  $output .= theme('pager', NULL, variable_get('default_nodes_main', 10));
  $output .= theme('xml_icon', url('planet/feed'));
  
  print theme('page', $output);
}

/**
 * Page callback for 'planet/feed' ("Planet").
 * @ingroup page
 * @CRUD{node,R}
 * @CRUD{menu_links,R}
 */
function planet_feed() {
  $result = db_query_range(db_rewrite_sql("SELECT n.nid, n.created FROM {node} n WHERE n.type = 'planet' AND n.status = 1 ORDER BY n.created DESC"), 0, 15);
  $title = db_fetch_array(db_query("SELECT link_title FROM {menu_links} WHERE link_path = 'planet'"));
  
  $channel['title'] = $title['link_title'];
  $channel['link'] = url('planet', array('absolute' => TRUE));
  $channel['description'] = 'Planet feed';
  
  $items = array();
  while ($row = db_fetch_object($result)) {
    $items[] = $row->nid;
  }
  // generate RSS feed from $items set of nodes.
  node_feed($items, $channel);
}

/**
 * Implementation of hook_user() - React when operations are performed on user accounts.
 * @ingroup system
 * @CRUD{planet_feeds,R}
 */
function planet_user($type, &$edit, &$user) {
  if ($type == 'view' && user_access('edit own blog', $user)) {
    $items[] = array('title' => t('Blog'),
      'value' => /* TODO
   Please manually fix the parameters on the l() or url() function on the next line.
   Typically, this was not changed because of a function call inside an array call like
   array('title' => t('View user profile.')).*/
l(t('view recent blog entries'), "planet/$user->uid", array('title' => t("Read %username's latest blog entries.", array('%username' => $user->name)))),
      'class' => 'blog',
    );
    return array(t('History') => $items);
  }
  if ($type == 'load') {
    $obj = db_fetch_object(db_query('SELECT link FROM {planet_feeds} WHERE uid = %d', $user->uid));
    $user->planet_feed = $obj->link;
  }
}

/**
 * Menu callback; displays a Drupal page containing recent planet entries.
 *
 * @todo remove orphan function, or reuse it
 * @ingroup page
 */
function planet_page($a = NULL, $b = NULL) {
  // @DIFFINFO I keep this for now to keep showing, in API doc, historic relation between called functions  
  if (is_numeric($a)) { // $a is a user ID
    if ($b == 'feed') {
      return planet_feed_user($a);
    }
    else {
      return planet_page_user($a);
    }
  }
  else if ($a == 'feed') {
    return planet_feed_last();
  }
  else {
    return planet_page_last();
  }
}

/**
 * Page callback for 'planet/%' ("planet").
 * @ingroup page
 *
 * @CRUD{node,R}
 * @CRUD{variables,R}
 */
function planet_page_user($uid) {
  global $user;

  $account = user_load(array((is_numeric($uid) ? 'uid' : 'name') => $uid, 'status' => 1));

  if ($account->uid) {
    drupal_set_title($title = t("%name's planet", array('%name' => $account->name)));

    if ($output) {
      $output = '<ul>'. $output .'</ul>';
    }
    else {
      $output = '';
    }
     $result = pager_query(db_rewrite_sql("SELECT n.nid, n.sticky, n.created FROM {node} n WHERE type = 'planet' AND n.uid = %d AND n.status = 1 ORDER BY n.sticky DESC, n.created DESC"), variable_get('default_nodes_main', 10), 0, NULL, $account->uid);
    while ($node = db_fetch_object($result)) {
      $output .= node_view(node_load($node->nid), 1);
    }
    $output .= theme('pager', NULL, variable_get('default_nodes_main', 10));
    $output .= theme('feed_icon', url("planet/$account->uid/feed"));

    drupal_add_link(array('rel' => 'alternate',
                          'type' => 'application/rss+xml',
                          'title' => t('RSS - %title', array('%title' => $title)),
                          'href' => url("planet/$account->uid/feed")));
    return $output;
  }
  else {
    drupal_not_found();
  }
}

/**
 * Implementation of hook_load - Load node-type-specific information.
 * 
 * @param $node  The node being loaded.
 * @return An object containing properties of the node being loaded.
 * @ingroup system
 * @CRUD{planet_items,R}
 */
function planet_load($node) {
  $additions = db_fetch_object(db_query('SELECT link, guid FROM {planet_items} WHERE nid = %d', $node->nid));
  return $additions;
}

/**
   * Implementation of hook_form - Display a node editing form.
   *
   * @param &$node The node being added or edited.
   * @param $form_state The form state array (unused). 
   * @return An array containing the form elements to be displayed in the node edit form.
   * @ingroup planet_node
   */
function planet_form(&$node, &$form_state) {
  $form = array();
  $form['title'] = array('#type' => 'textfield', '#title' => 'Title', '#value' => $node->title, '#size' => 30, '#maxlength' => 80);
  $form['body'] = array('#type' => 'textarea', '#title' => 'Body', '#value' => $node->body);
  return $form;
}

/**
 * Turn each feed item into a node.
 *
 * @param $process_feed
 *   Feed node object
 * @param $feed
 *   SimplePie feed object instaniated.
 */
function planet_item_feed_parse($process_feed, $feed) {
  // loop through all of the items in the feed, faster than foreach
  $max = $feed->get_item_quantity();
  $count = 0;
  module_load_include('inc', 'node', 'node.pages');
  module_load_include('inc', 'node', 'content_types');
  $node = node_get_types('type', 'feed_item');

  for ($i = 0; $i < $max; $i++) {
    $item = $feed->get_item($i);

    // we don't use $item->get_id(true) from SimplePie because it is slightly buggy
    // and requires a lot of overhead to compute each time (since it uses a gigantic array structure)
    // instead we opt for a much lighter weight comparison of just the title and body, eliminating the
    // possibility of any date changes or other tiny changes causing duplicate nodes that otherwise
    // appear to be the same
    // that is why the body and title processing appears out here, so we can check for duplicates
    // it is fast enough to not make much of a difference otherwise
    $body = $item->get_content();
    // this strips out any tags that may appear as <b> in the title, and makes sure &quot; -> " for display
    $title = strip_tags(decode_entities($item->get_title()));

    // some feeds don't provide titles so we construct one with the first 72 characters of the body
    if (!$title) {
      // remove any HTML or line breaks so these don't appear in the title
      $title = trim(str_replace(array("\n", "\r"), ' ', strip_tags($body)));
      $title = trim(substr($title, 0, 72));
      $lastchar = substr($title, -1, 1);
      // check to see if the last character in the title is a non-alphanumeric character, except for ? or !
      // if it is strip it off so you don't get strange looking titles
      if (preg_match('/[^0-9A-Za-z\!\?]/', $lastchar)) {
        $title = substr($title, 0, -1);
      }
      // ? and ! are ok to end a title with since they make sense
      if ($lastchar != '!' and $lastchar != '?') {
        $title .= '...';
      }
    }

    // unique id for each feed item, try and use item permalink, otherwise use feed permalink
    if (!$link = $item->get_permalink()) {
      $link = $feed->get_permalink();
    }
    // we don't need serialize() since we already have strings
    $iid = md5($title . $link);
    $guid = md5("$title - . " . $process_feed->fid);
    // make sure we don't already have this feed item
    $duplicate = db_result(db_query("SELECT COUNT(iid) FROM {planet_items} WHERE iid = '%s'", $iid));

    if (!$duplicate) {


    $entry = NULL;
    if ($guid && strlen($guid) > 0) {
      $entry = db_fetch_object(db_query("SELECT nid FROM {planet_items} WHERE guid = '%s' AND fid = %d", $guid, $process_feed->fid));
    }
    else if ($link && $link != $feed->link && $link != $feed->url) {
      $entry = db_fetch_object(db_query("SELECT nid FROM {planet_items} WHERE guid = '%s' AND fid = %d", $link, $process_feed->fid));
    }
    else {
      $entry = db_fetch_object(db_query("SELECT ai.nid AS nid FROM {node} n, {planet_items} ai WHERE ai.fid = %d AND ai.nid = n.nid AND n.title = '%s'", $process_feed->fid, $title));
    }

      $link = $item->get_permalink();
      // this is node created date format for Drupal
      $date = $item->get_date('Y-m-d H:i:s O');

      $entry->changed = $date;
      $entry->title = $title;
      $entry->body = $body;
      $entry->body = planet_convert_relative_urls($body, $link);
      $entry->teaser = node_teaser($entry->body);    
      $entry->revision = true;

      if (!isset($entry->nid)) {            
        //print "Planet item " . $entry->title . "<br />";
        $entry->type = 'planet';
 
        $options = variable_get('node_options_planet', array());

        $entry->uid = $process_feed->uid;
        $entry->status = 1;
        $entry->moderate = 0;
        $entry->promote = in_array('promote', $options) ? 1 : 0;
        $entry->sticky = in_array('sticky', $options) ? 1 : 0;
        $entry->comment = in_array('comment', $options) ? 2 : 0;
        $entry->format = variable_get('planet_filter_formats', 1);
        $entry->created = $date;
        $entry->revision = true;
   
      }  

      node_save($entry);
      $item_record = array('fid' => $process_feed->fid,
                           'nid' => $entry->nid,
                           'iid' => $iid,
                           'guid'=> $guid,
                           'link' =>$link,
                           'created' => time());
      drupal_write_record('planet_items', $item_record);            
      watchdog('planet', 'Adding '. $title);
      drupal_set_message('Adding '. $title);
    }

    // we unset $item each time to prevent any pass by reference memory leaks that PHP encounters with objects in foreach loops
    unset($item);
  }
  
}