modules/nf_handshake/nf_handshake.module

<?php
/**
 * This is the nf_handshake module. The nodeprofile module is required as the handshakes involve the CCK fields from the content types
 * so designated by nodeprofile as lonely nodes.
 *
 * @version $Id$;
 * @package Handshake
 * @category NeighborForge
 * @author Ryan Constantine
 * @filesource
 * @license http://www.gnu.org/licenses/gpl.txt GNU_GENERAL_PUBLIC_LICENSE
 * @link none yet
 * TODO fix date presentation
 * TODO remove all handshake menu items/user profile items from user 1 and other 'administer handshake' people if the settings match
 * TODO allow admin to designate some fields as always viewable (handshake not needed); display above handshake/contact option if have permission to view this
 * TODO allow users to designate some fields as always viewable (handshake not needed); display above handshake/contact option
 * TODO user search - by address, by ???; allow admin to specify fields that are searchable; make as a separate,
 * companion module like nf_handshake_user_search.module; if search field is 'always viewable' then results would include everyone who meets
 * the criteria, otherwise, only those where a handshake exists and that data is exposed.
 * TODO Add tab in admin UI so admin can selectively place sub-fields of complex CCK fields into either a separate effective field
 * (for info trade purposes only) or make that sub-field out-of-bounds. For example, people may wish to share their birth year
 * separate from their birth month and day.
 * TODO ??? flag admin: make a block for this?
 * TODO ??? CRON Although users can see their initiated handshakes' status, add a cron job for sending emails/private messages upon update of status(?)
 */

/**
 * Constants to define the status of the handshake transaction
 */
define('NFHANDSHAKE_REJECTED', 0);
define('NFHANDSHAKE_ACCEPTED', 1);
define('NFHANDSHAKE_PENDING', 2);
define('NFHANDSHAKE_REVIEWED', 3);
define('NFHANDSHAKE_FLAGGED', 4);
define('NFHANDSHAKE_EXPIRED', 5);
define('NFHANDSHAKE_EXTENSION_REQUESTED', 6);
define('NFHANDSHAKE_UPGRADE_REQUESTED', 7);

/**
 * Constants to define user flags that fit into a 3 digit int
 */
define('NFHANDSHAKE_NONE', 0);
define('NFHANDSHAKE_AGE_INAPPROPRIATE', 1);
define('NFHANDSHAKE_SPAM', 2);
define('NFHANDSHAKE_HARASSMENT', 3);
define('NFHANDSHAKE_QUESTIONABLE_PURPOSE', 4);
define('NFHANDSHAKE_OTHER', 5);

/**
 * Constants to define admin flags that fit into a 3 digit int
 */
define('NFHANDSHAKE_NONE', 0);
define('NFHANDSHAKE_FURTHER_REVIEW', 10);
define('NFHANDSHAKE_VIOLATION_OF_TS', 20);
define('NFHANDSHAKE_WARNING_1', 30);
define('NFHANDSHAKE_WARNING_2', 40);
define('NFHANDSHAKE_SUSPEND_USER', 50);
define('NFHANDSHAKE_ALERT_PARENTS', 60);
define('NFHANDSHAKE_IUID_COMMENT', 70);
define('NFHANDSHAKE_AUID_COMMENT', 80);

//-----------------------------------------Various Drupal Hooks-----------------------------------------
//-----------------------------------------Various Drupal Hooks-----------------------------------------
//-----------------------------------------Various Drupal Hooks-----------------------------------------

/**
 * Implementation of hook_help
 *
 * Display help and module information
 * @param string $section Which section of the site we're displaying help
 * @return string $output Help text.
 */
function nf_handshake_help($section='') {
  $output = '';
  switch ($section) {
    case "admin/help#nf_handshake":
      $output = '<p>' . t("Changes the way users contact each other and what they can know about each other.
Implements a handshake routine where one user offers to expose certain profile fields to another in exchange
for the same consideration."). '</p>';
      break;
  }

  return $output;
} // function nf_handshake_help()

/**
 * Implementation of hook_perm
 * 
 * Why is there separate 'initiate handshake' and 'accept handshake' permissions? In the case where you've used another module of mine
 * that allows sub-accounts and you want to allow sub-accounts to initiate handshakes but only the main account holder to accept them.
 * This would be the case where a parent is the primary account holder and a child is a sub-account holder. 'View own handshakes' is a
 * separate permission for the same reason. The admin may wish for children to see that someone is trying to shake hands so that they
 * can pester their parent to look into it. 'View handshakes' may or may not be used in the future.
 *
 * Valid permissions for this module
 * @return array $items An array of menu items
 */
function nf_handshake_perm() {
  return array('administer handshakes', 'intitiate handshake', 'accept handshake', 'view own handshakes', 'view handshakes', 'bypass handshakes');
} // function nf_handshake_perm()

/**
 * Implementation of hook_menu
 *
 * @return array An array of arrays, to add menu entries to the system menu.
 */
function nf_handshake_menu($may_cache) {
  $items = array();
  global $user;
  if ($may_cache) {
    //-----------------------admin ui menu items----------------------------------
    $items[] = array( //setup which data can be exchanged in the handshake process
    'path' => 'admin/user/nf_handshake',
    'title' => t('Handshake setup'),
    'callback' => 'nf_handshake_main',
    'access' => user_access('administer handshakes'),
    'description' => t('This is how you organize your nodeprofile CCK field types for user sharing. To begin, go to <em>
Choose CCK Fields</em>, then move on to <em>Make groupings</em>. Those in groups are
considered equivalent so that if a user has one field type in the group, but not another, they can still share that info with
someone that has another field type in the same group.'),
    'type' => MENU_NORMAL_ITEM,
    );
    
    $items[] = array( //tab to take us to main administer page
    'path' => 'admin/user/nf_handshake/overview',
    'title' => t('Overview'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/edit',
    'title' => t('Edit'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_edit'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/delete',
    'title' => t('Delete'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_confirm_delete'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/choose_cck_fields',
    'title' => t('Choose CCK fields'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_choose_cck_fields'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -8,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/delete_cck_fields',
    'title' => t('Delete CCK field'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_confirm_cck_fields_delete'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/make_grouping',
    'title' => t('Make groupings'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_make_groupings'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -4,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/edit_group',
    'title' => t('Edit group'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_group_edit'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/delete_group',
    'title' => t('Delete group'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_confirm_group_delete'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake/settings',
    'title' => t('Misc settings'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_settings'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -2,
    );
    
    $items[] = array( //administer flags set by the users
    'path' => 'admin/user/nf_handshake_flags',
    'title' => t('Handshake flag admin'),
    'callback' => 'nf_handshake_flags',
    'access' => user_access('administer handshakes'),
    'description' => t('Users can flag handshake requests as SPAM and other things. The admin can mediate these instances here.'),
    'type' => MENU_NORMAL_ITEM,
    );
    
    $items[] = array( //tab to take us to main flag administer page
    'path' => 'admin/user/nf_handshake_flags/overview',
    'title' => t('Overview'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
    );
    
    $items[] = array( //tab to take us to main flag administer page
    'path' => 'admin/user/nf_handshake_flags/decisions',
    'title' => t('Decisions'),
    'callback' => 'nf_handshake_flag_decisions',
    'access' => user_access('administer handshakes'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -8,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_handshake_flags/view',
    'title' => t('Administer flag'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_view_flag'),
    'access' => user_access('administer handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'user/nf_handshake/initiate',
    'title' => t('Initiate handshake'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_initiate'),
    'access' => user_access('intitiate handshake'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'user/nf_handshake/revoke_confirm',
    'title' => t('Confirm handshake revoke'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_revoke_confirm'),
    'access' => user_access('view own handshakes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'user/nf_handshake/extend_duration',
    'title' => t('Extend handshake duration'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_extend_duration'),
    'access' => user_access('accept handshake'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'user/nf_handshake/request_extension',
    'title' => t('Extend handshake duration'),
    'callback' => 'nf_handshake_request_extention',
    'access' => user_access('intitiate handshake'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array(
    'path' => 'user/nf_handshake/flag_reply',
    'title' => t('Respond to flagging'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_flag_reply'),
    'access' => user_access('intitiate handshake')|| user_access('accept handshake'),
    'type' => MENU_CALLBACK,
    );
  }
  else {
    //-----------------------user-viewable menu itmes----------------------------------
    $admin_access = user_access('administer users');
    $access_access = user_access('administer access control');
    $view_access = user_access('access user profiles');
    if (arg(0) == 'user' && is_numeric(arg(1)) && arg(1) > 0) {
      $account = user_load(array('uid' => arg(1)));
      if ($user !== FALSE) {
        // Always let a user view their own account
        $view_access |= $user->uid == arg(1);
        // Only admins can view blocked accounts
        $view_access &= $account->status || $admin_access;
        
        $items[] = array( //reroute users away from standard user profile page
        'path' => 'user/' .arg(1),
        'title' => t('View a user'),
        'callback' => 'nf_handshake_view_user',
        'callback arguments' => array(arg(1)),
        'access' => $view_access,
        'type' => MENU_CALLBACK,
        );
        
        $items[] = array(
        'path' => 'user/' .arg(1). '/view',
        'title' => t('View'),
        'access' => $view_access,
        'type' => MENU_DEFAULT_LOCAL_TASK,
        'weight' => -10
        );
      }
    }
    
    //additions to user's own admin pages
    $new_handshakes = nf_handshake_get_new_handshake_requests($user->uid);
    $unanswered_handshakes = nf_handshake_get_read_handshake_requests($user->uid);
    $flags_to_attend = nf_handshake_get_read_handshake_flags_iuid($user->uid);
    $flags_to_attend += nf_handshake_get_read_handshake_flags_auid($user->uid);
    $new = $new_handshakes + $flags_to_attend;
    $items[] = array(
    'path' => 'user/' .$user->uid. '/nf_handshake',
    'title' => t('Handshakes'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_view_contacts'),
    'access' => user_access('view own handshakes'),
    'type' => MENU_LOCAL_TASK,
    );
    //view handshake list
    $items[] = array(
    'path' => 'user/' .$user->uid. '/nf_handshake/view_contacts',
    'title' => t('Contacts'),
    'access' => user_access('view own handshakes'),
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
    );
    $items[] = array(
    'path' => 'user/' .$user->uid. '/nf_handshake/inbox',
    'title' => t('Handshake inbox'). ($new ? ' (' .$new. ')' : ' -') . ($unanswered_handshakes ? ' (' .$unanswered_handshakes. ')' : ' -'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_inbox'),
    'access' => user_access('accept handshake'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -6,
    );
    $items[] = array(
    'path' => 'user/' .$user->uid. '/nf_handshake/search',
    'title' => t('User search'),
    'callback' => 'nf_handshake_search_view',
    'access' => user_access('access user profiles'),
    'type' => MENU_LOCAL_TASK,
    'weight' => -4,
    );
    
    //view a handshake request
    $items[] = array(
    'path' => 'user/' .$user->uid. '/nf_handshake/view_hsr',
    'title' => t('View request'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_handshake_view_hsr'),
    'access' => user_access('view own handshakes'),
    'type' => MENU_CALLBACK,
    );
  }
  return $items;
} // function nf_handshake_menu()

/**
 * CRON to reject requests automatically if the user doesn't respond within a week (or a set time by the admin).
 * CRON to expire old rejected requests; this will allow people to reinitiate handshakes with those that have rejected them.
 */
function nf_handshake_cron() {
  $settings = variable_get('nf_handshake_settings', array('initiate_expire_unit' => 'Weeks', 'initiate_expire_number' => 1, 'reject_expire_unit' => 'Months', 'reject_expire_number' => 6));
  //Set unanswered handshake requests to rejected after the expiration date
  $number = $settings['reject_expire_number'];
  $unit = $settings['reject_expire_unit'];
  switch ($unit) {
    case 'Days':
      $unit = 60*60*24;
      break;
    case 'Weeks':
      $unit = 60*60*24*7;
      break;
    case 'Months':
      $unit = 60*60*24*30;
      break;
    case 'Years':
      $unit = 60*60*24*365;
      break;
  }
  
  $sql = "SELECT auid, iuid, datestamp, duration FROM {nf_handshake} WHERE (hstatus = %d OR hstatus = %d) AND duration < %d";
  $results = db_query($sql, NFHANDSHAKE_PENDING, NFHANDSHAKE_REVIEWED, time());
  while ($result = db_fetch_object($results)) {
    $entries['auid'][] = $result->auid;
    $entries['iuid'][] = $result->iuid;
    $entries['datestamp'][] = $result->datestamp;
  }
  $sql1 = "UPDATE {nf_handshake} SET duration = %d, hstatus = %d WHERE iuid= %d AND auid = %d";
  $sql2 = "DELETE FROM {nf_handshake_manage} WHERE iuid= %d AND auid = %d";
  if (!empty($entries['auid'])) {
    foreach ($entries['auid'] as $key => $value) {
      $duration = $entries['datestamp'][$key] + ($unit*$number);
      $success1 = db_query($sql1, $duration, NFHANDSHAKE_REJECTED, $entries['iuid'][$key], $entries['auid'][$key]);
      $success2 = db_query($sql2, $entries['iuid'][$key], $entries['auid'][$key]);
    }
  }
  //Expire rejected handshakes NFHANDSHAKE_EXPIRED
  $sql3 = "UPDATE {nf_handshake} SET hstatus = %d WHERE duration < %d AND hstatus = %d";
  $success3 = db_query($sql3, NFHANDSHAKE_EXPIRED, time(), NFHANDSHAKE_REJECTED);
} // function nf_handshake_cron()

/**
 * Implementation of hook_form_alter.
 * 
 * Intercept the removal of a CCK field from a content type and make sure we get a change to react to it.
 * 
 * @param string $form_id The ID of the form we need to adjust.
 * @param array &$form A reference to the form to adjust so that we change the actual form.
 */
function nf_handshake_form_alter($form_id, &$form) {
  if ($form_id == '_content_admin_field_remove') {
    $form['#submit'] = array('nf_handshake_remove_field_submit' => array(), '_content_admin_field_remove_submit' => array());
  }
} // function nf_handshake_form_alter()

/**
 * Our submit function so we can deal with removal of CCK fields from content types.
 * 
 * @param sting $form_id The ID of the form to process.
 * @param array $form_values The fields to process.
 */
function nf_handshake_remove_field_submit($form_id, $form_values) {
  if ($form_id == '_content_admin_field_remove') {
    //first update references in the handshakes themselves
    $sql = "SELECT * FROM {nf_handshake} ORDER BY iuid";
    $results = db_query($sql);
    while ($result = db_fetch_object($results)) {
      $sql2 = "UPDATE {nf_handshake} SET hfields = '%s' WHERE iuid = %d and auid = %d";
      $hfields = unserialize($result->hfields);
      foreach ($hfields as $field => $val) {//test to see if this entry is from the affected content type
        $exp_val = explode('::', $field);
        $type_name = $exp_val[0];
        $field_name = $exp_val[1];
        if ($type_name == $form_values['type_name'] && $field_name == $form_values['field_name']) {
          unset($hfields[$field]);
        }
      }
      ksort($hefields);
      $hfields = serialize($hfields);
      $success = db_query($sql2, $hfields, $result->iuid, $result->auid);
    }
    //then update the variables stored in the variables table
    $field_names_var = _nf_handshake_get_cckfieldnames();
    $group_names_var = _nf_handshake_get_groupnames();
    foreach ($field_names_var as $type => $the_rest) {
      if ($type == $form_values['type_name']) {
        foreach ($the_rest as $key => $value) {
          if ($key == $form_values['field_name']) {
            unset($field_names_var[$type][$key]);
          }
        }
      }
    }
    ksort($field_names_var);
    variable_set('nf_handshake_cckfieldnames', $field_names_var);
    foreach ($group_names_var as $group => $the_rest) {
      foreach ($the_rest as $type_field1 => $type_field2) {
        $exp_val = explode('::', $type_field1);
        $type = $exp_val[0];
        $field = $exp_val[1];
        if ($type == $form_values['type_name'] && $field == $form_values['field_name']) {
          unset($group_names_var[$group][$type_field1]);
        }
      }
    }
    ksort($group_names_var);
    variable_set('nf_handshake_groupnames', $group_names_var);
    drupal_set_message(t('Handshake module has updated its references to the content type you changed.'));
  }
  return;
}

/**
 * Respond to changes in content types.
 * 
 * We don't do anything upon insertion of a new content type as we don't know if the user will turn it into a nodeprofile type or not.
 * We must delete references to fields in content types that are deleted. We must update fields we use from content types we use if they
 * are changed. Since we add a capital 'X' to the end of fieldnames that are part of an upgrade request, leave them intact.
 * 
 * @param string $op The operation on the node type. Possibilities are 'insert', 'delete', and 'update'.
 * @param object The node type object on which $op is being performed.
 */
function nf_handshake_node_type($op, $info) {
  switch ($op){
    case 'delete':
      //first update references in the handshakes themselves
      $sql = "SELECT * FROM {nf_handshake} ORDER BY iuid";
      $results = db_query($sql);
      while ($result = db_fetch_object($results)) {
        $hfields = array();
        $sql2 = "UPDATE {nf_handshake} SET hfields = '%s' WHERE iuid = %d and auid = %d";
        $hfields = unserialize($result->hfields);
        foreach ($hfields as $field => $val) {//test to see if this entry is from the affected content type
          $exp_val = explode('::', $field);
          $type_name = $exp_val[0];
          $field_name = $exp_val[1];
          if ($type_name == $info->type) {
            unset($hfields[$field]);
          }
        }
        ksort($hfields);
        $hfields = serialize($hfields);
        $success = db_query($sql2, $hfields, $result->iuid, $result->auid);
      }
      //then update the variables stored in the variables table
      $field_names_var = _nf_handshake_get_cckfieldnames();
      $group_names_var = _nf_handshake_get_groupnames();
      foreach ($field_names_var as $type => $the_rest) {
        if ($type == $info->type) {
          unset($field_names_var[$type]);
        }
      }
      ksort($field_names_var);
      variable_set('nf_handshake_cckfieldnames', $field_names_var);
      foreach ($group_names_var as $group => $the_rest) {
        foreach ($the_rest as $type_field1 => $type_field2) {
          $exp_val = explode('::', $type_field1);
          $type = $exp_val[0];
          $field = $exp_val[1];
          if ($type == $info->type) {
            unset($group_names_var[$group][$type_field1]);
          }
        }
      }
      ksort($group_names_var);
      variable_set('nf_handshake_groupnames', $group_names_var);
      drupal_set_message(t('Handshake module has updated its references to the content type you changed.'));
      break;
    case 'update':
      if (!empty($info->old_type) && $info->old_type != $info->type) {
        //first update references in the handshakes themselves
        $sql = "SELECT * FROM {nf_handshake} ORDER BY iuid";
        $results = db_query($sql);
        while ($result = db_fetch_object($results)) {
          $sql2 = "UPDATE {nf_handshake} SET hfields = '%s' WHERE iuid = %d and auid = %d";
          $hfields = unserialize($result->hfields);
          foreach ($hfields as $field => $val) {//test to see if this entry is from the affected content type
            $exp_val = explode('::', $field);
            $type_name = $exp_val[0];
            $field_name = $exp_val[1];
            if ($type_name == $info->old_type) {//switch out the old name with the new
              $old_type_field = $info->old_type. '::' .$field_name;
              $new_type_field = $info->type. '::' .$field_name;
              $temp_val = $hfields[$old_type_field];
              unset($hfields[$old_type_field]);
              if ($temp_val !== 0) {//leave any 'X' values intact.
                $exp_val2 = explode('::', $temp_val);
                $hfields[$new_type_field] = $info->type. '::' .$exp_val2[1];
              }
              else {
                $hfields[$new_type_field] = 0;
              }
            }
          }
          ksort($hefields);
          $hfields = serialize($hfields);
          $success = db_query($sql2, $hfields, $result->iuid, $result->auid);
        }
        //then update the variables stored in the variables table
        $field_names_var = _nf_handshake_get_cckfieldnames();
        $group_names_var = _nf_handshake_get_groupnames();
        foreach ($field_names_var as $type => $the_rest) {
          if ($type == $info->old_type) {
            $temp_data = $field_names_var[$type];
            unset($field_names_var[$type]);
            $field_names_var[$info->type] = $temp_data;
          }
        }
        ksort($field_names_var);
        variable_set('nf_handshake_cckfieldnames', $field_names_var);
        foreach ($group_names_var as $group => $the_rest) {
          foreach ($the_rest as $type_field1 => $type_field2) {
            $exp_val = explode('::', $type_field1);
            $type = $exp_val[0];
            $field = $exp_val[1];
            if ($type == $info->old_type) {
              unset($group_names_var[$group][$type_field1]);
              $group_names_var[$group][$info->type. '::' .$field] = $info->type. '::' .$field;
            }
          }
        }
        ksort($group_names_var);
        variable_set('nf_handshake_groupnames', $group_names_var);
        drupal_set_message(t('Handshake module has updated its references to the content type you changed.'));
      }
      break;
  }
}

/**
 * Implementation of hook_user. We need to respond to users being deleted and delete their entries from our tables
 * in order to prevent orphan handshakes.
 *
 * @param string $op What kind of action is being performed.
 * @param array $edit The array of form values submitted by the user.
 * @param array $account The user object on which the operation is being performed.
 * @param string $category The active category of user information being edited.
 */
function nf_handshake_user($op, &$edit, &$account, $category = NULL) {
  switch($op) {
    case 'delete':
      $uid = $account->uid;
      $sql = "DELETE FROM {nf_handshake} WHERE auid = %d OR iuid = %d";
      $sql2 = "DELETE FROM {nf_handshake_manage} WHERE auid = %d OR iuid = %d";
      dq_query($sql, $uid);
      dq_query($sql2, $uid);
      break;
  }
}
//-----------------------------------------Administrative Hooks and Functions-----------------------------------------
//-----------------------------------------Administrative Hooks and Functions-----------------------------------------
//-----------------------------------------Administrative Hooks and Functions-----------------------------------------

/**
 * Callback function: Add options for the .
 *
 * @return string $output The HTML to be displayed.
 */
function nf_handshake_main() {
  $all_nodeprofiles = nodeprofile_get_types('names');
  $all_groups = _nf_handshake_get_groupnames();
  $selected_cck_fields = _nf_handshake_get_cckfieldnames();
  ksort($selected_cck_fields);
  ksort($all_groups);
  $output = '';
  $header = array(t('Content type'), t('Selected CCK fields'));
  if (!empty($selected_cck_fields)) {
    if (!empty($all_groups)) {
      foreach ($all_groups as $key => $val) {
        $rows = array();
        foreach ($val as $set => $value) {
          $split_value = explode('::', $value);
          $type = $split_value[0];
          $type_name = $all_nodeprofiles[$type];
          $field_name = $split_value[1];
          if ($type == 'Users table') {
            $rows[] = array('<strong><em>' .$type. '</em><strong>', $field_name);
            unset($selected_cck_fields['Users_table'][$field_name]);
          }
          else {
            $rows[] = array('<em>' .$type_name. '</em>', $field_name);
            unset($selected_cck_fields[$type][$field_name]);
          }
          if (empty($selected_cck_fields[$type])) {
            unset($selected_cck_fields[$type]);
          }
        }
        $fieldset = array(
        '#type' => 'fieldset',
        '#value' => theme('table', $header, $rows),
        '#title' => t('Group: ') .$key,
        '#description' => t('Fields that can be exchanged as equivalent.'),
        '#collapsible' => TRUE,
        '#collapsed' => FALSE,
        '#weight' => 0,
        );
        $output .= theme('fieldset', $fieldset);
      }
      if (!empty($selected_cck_fields)) {
        $rows = array();
        foreach ($selected_cck_fields as $type => $set) {
          if ($type == 'Users_table') {
            foreach ($set as $key => $value) {
              $rows[] = array('<strong><em>Users table</em></strong>', $value);
            }
          }
          else {
            $type_name = $all_nodeprofiles[$type];
            foreach ($set as $key => $value) {
              $rows[] = array('<em>' .$type_name. '</em>', $value);
            }
          }
        }
      $output .= theme('table', $header, $rows);
      }
    }
    else {
      $rows = array();
      foreach ($selected_cck_fields as $type => $set) {
        if ($type == 'Users_table') {
          foreach ($set as $key => $value) {
            $rows[] = array('<strong><em>Users table</em></strong>', $value);
          }
        }
        else {
          $type_name = $all_nodeprofiles[$type];
          foreach ($set as $key => $value) {
            $rows[] = array('<em>' .$type_name. '</em>', $value);
          }
        }
      }
    $output .= theme('table', $header, $rows);
    }
  }
  else {
    $output = t('You first need to select CCK fields that users can share, then make groups of those fields if you wish.');
  }
  return $output;
} // function nf_handshake_main()

/**
 * Present the admin with a drop down of nodeprofile-related cck fields and allow him/her to select those that users may share.
 * 
 * @return array $form The form to be rendered.
 */
function nf_handshake_choose_cck_fields() {
  $all_cck_fields = array();
  $all_nodeprofiles = nodeprofile_get_types('names');
  ksort($all_nodeprofiles);
  $added_cck_fields = _nf_handshake_get_cckfieldnames();
  $sql = "SELECT type_name, field_name FROM {node_field_instance} WHERE type_name = '%s' ORDER BY field_name";
  foreach ($all_nodeprofiles as $key => $value) {
    $results = db_query($sql, $key);
    while ($result = db_fetch_object($results)) {
      if (!(key_exists($result->type_name, $added_cck_fields) && key_exists($result->field_name, $added_cck_fields[$result->type_name]))) {
        $all_cck_fields[$value][$result->type_name. '::' .$result->field_name] = $result->field_name;
      }
    }
  }
  //add user photo and email address from users table to $all_cck_fields
  if (!(key_exists('Users_table', $added_cck_fields) && key_exists('mail', $added_cck_fields['Users_table']))) {
    $all_cck_fields['Users_table']['mail'] = 'mail';
  }
  if (!(key_exists('Users_table', $added_cck_fields) && key_exists('picture', $added_cck_fields['Users_table']))) {
    $all_cck_fields['Users_table']['picture'] = 'picture';
  }
  $form['cck_fields'] = array(
    '#type' => 'select',
    '#title' => t('Add profile-related CCK fields'),
    '#options' => $all_cck_fields,
  );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Add CCK field'),
  );
  $form['options'] = array(
    '#type' => 'value',
    '#value' => $all_cck_fields,
  );
  $form['info'] = array(
    '#type' => 'item',
    '#value' => t('Select the CCK fields that you would like to allow users to share with each other.'),
  );
  return $form;
} // function nf_handshake_choose_cck_fields()

/**
 * Submit the table name to be saved to the table list.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string The path to send the user to.
 */
function nf_handshake_choose_cck_fields_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Add CCK field')) {
    $selection = explode('::', $form_values['cck_fields']);
    $added_cck_fields = _nf_handshake_get_cckfieldnames();
    if (isset($selection[1])) {
      $added_cck_fields[$selection[0]][$selection[1]] = $selection[1];
    }
    else {
      $added_cck_fields['Users_table'][$selection[0]] = $selection[0];
    }
    variable_set('nf_handshake_cckfieldnames', $added_cck_fields);
    drupal_set_message(t('The CCK field list has been updated.'));
  }
  return 'admin/user/nf_handshake/choose_cck_fields';
} // function nf_handshake_choose_cck_fields_submit()

/**
 * Theme for the cck field chooser.
 * 
 * @param array $form The form to render.
 * @return string $output The HTML to be displayed.
 */
function theme_nf_handshake_choose_cck_fields($form) {
  $all_nodeprofiles = nodeprofile_get_types('names');
  $header = array(t('Content type'), array('data' => t('Selected CCK fields'), 'colspan' => 2));
  $selected_cck_fields = _nf_handshake_get_cckfieldnames();
  ksort($selected_cck_fields);
  $rows = array();
  if (!empty($selected_cck_fields)) {
    foreach ($selected_cck_fields as $type => $set) {
      if ($type == 'Users_table') {
        foreach ($set as $key => $value) {
          $delete = l(t('delete'), 'admin/user/nf_handshake/delete_cck_fields/' .$type. '::' .$value);
          $rows[] = array('<strong><em>Users table</em></strong>', $value, $delete);
        }
      }
      else {
        $type_name = $all_nodeprofiles[$type];
        foreach ($set as $key => $value) {
          $delete = l(t('delete'), 'admin/user/nf_handshake/delete_cck_fields/' .$type. '::' .$value);
          $rows[] = array('<em>' .$type_name. '</em>', $value, $delete);
        }
      }
    }
  }
  $rows[] = array(drupal_render($form['cck_fields']), drupal_render($form['submit']), '');
  $output = drupal_render($form['info']);
  $output .= theme('table', $header, $rows);
  $output .= drupal_render($form);

  return $output;
} //function theme_nf_handshake_choose_cck_fields()

/**
 * Returns a confirmation page for deleting a cck field from the list (not the actual field).
 *
 * @param integer $name Name of cck field to be deleted; passed in from path.
 * @return array $form The name is passed to the submit.
 */
function nf_handshake_confirm_cck_fields_delete($name = NULL) {
  if ($name == NULL) {
    drupal_goto('admin/user/nf_handshake/choose_cck_fields');
    return;
  }
  if ($admin = user_access('administer handshakes')) {
    $type_and_field = explode('::', $name);
    $form['type'] = array(
      '#type' => 'value',
      '#value' => $type_and_field[0],
    );
    $form['name'] = array(
      '#type' => 'value',
      '#value' => $type_and_field[1],
    );
    $return_address = 'admin/user/nf_handshake/choose_cck_fields';
    $form = confirm_form($form, t('Are you sure you want to delete the CCK field %name from the admin list?',
      array('%name' => $type_and_field[1])), $return_address,
      t('Deleting a CCK field from the list here will not delete the actual field. This action cannot be undone.'), t('Delete'), t('Cancel'));
      return $form;
  }
} // function nf_handshake_confirm_cck_fields_delete()

/**
 * Implementation of forms api _submit call. Deletes a cck field from the variable list after confirmation.
 *
 * @param string $form_id
 * @param mixed $form_values
 * @return string $return_address The path to return to after we've deleted the table.
 */
function nf_handshake_confirm_cck_fields_delete_submit($form_id, $form_values) {
  $added_cck_fields = _nf_handshake_get_cckfieldnames();
  unset($added_cck_fields[$form_values['type']][$form_values['name']]);
  if (empty($added_cck_fields[$form_values['type']])) {
    unset($added_cck_fields[$form_values['type']]);
  }
  variable_set('nf_handshake_cckfieldnames', $added_cck_fields);
  if (!isset($added_cck_fields[$form_values['name']][$form_values['name']])) {
    drupal_set_message(t('The cck field %name has been removed from the administration list.', array('%name' => $form_values['name'])));
    watchdog('nf_handshake', t('nf_handshake: deleted %name from nf_handshake_cckfieldnames list.', array('%name' => $form_values['name'])));
  }
  $return_address = 'admin/user/nf_handshake/choose_cck_fields';
  return $return_address;
} // function nf_handshake_confirm_cck_fields_delete_submit()

/**
 * Allow the admin to group fields together.  
 * 
 * If there are two fields that are related that may
 * not be in common between two nodeprofile sets, but which users should be able to share, they can be grouped together. For example, say
 * that nodeprofile A is set up for businesses and nodeprofile B is set up for customers and they each have addresses in their profile nodes,
 * but in a different format; without groupings, you would have to name one address field with one name and the other address field with another name.
 * Users would check the box stating they want to share their address with the other user, but would be unable to because the second user's field
 * had a different name. By grouping them together, an association is made such that this problem is overcome.
 * 
 * @return array $form The form to be rendered.
 */
function nf_handshake_make_groupings() {
  $all_groups = _nf_handshake_get_groupnames();
  $added_cck_fields = _nf_handshake_get_cckfieldnames();
  $form['note'] = array(
    '#type' => 'item',
    '#title' => t('Group similar fields together'),
    '#description' => t('This allows you to group logical fields together for exchange as a group. See the README for details.'),
  );
  $not_field_options = array();
  $field_options = array();
  foreach ($all_groups as $group => $types) {
    if (!empty($types)) {
      foreach ($types as $type => $field) {
        $not_field_options[$type] = $field;
      }
    }
  }
  $all_nodeprofiles = nodeprofile_get_types('names');
  foreach ($added_cck_fields as $type => $the_rest) {
    if (!empty($the_rest)) {
      foreach ($the_rest as $field => $val) {
        if (!key_exists($type. '::' .$val, $not_field_options)) {
          if ($type == 'Users_table') {
            $field_options[$type. '::' .$val] = 'Users table::' .$val;
          }
          else {
            $field_options[$type. '::' .$val] = $all_nodeprofiles[$type]. '::' .$val;
          }
        }
      }
    }
  }
  foreach ($all_groups as $group => $types) {
    $form[$group] = array(
      '#tree' => TRUE,
    );
    $form[$group]['new_field'] = array(
      '#type' => 'select',
      '#title' => t('fields'),
      '#options' => $field_options,
      '#default' => NULL,
    );
    $form[$group]['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Add fieldname to ') .$group,
    );  
  }
  $form['groupname'] = array(
    '#type' => 'textfield',
    '#size' => 20,
    '#maxlength' => 64,
  );
  $form['gsubmit'] = array(
    '#type' => 'submit',
    '#value' => t('Add group'),
  );
  return $form;
} // function nf_handshake_make_groupings()

/**
 * Submit the group name and any field associations.
 *
 * @param string $form_id
 * @param mixed $form_values
 * @return string The path to send the user to.
 */
function nf_handshake_make_groupings_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Add group')) {
    $all_groups = _nf_handshake_get_groupnames();
    $all_groups[$form_values['groupname']] = array();
    variable_set('nf_handshake_groupnames', $all_groups);
    drupal_set_message(t('The group name has been added.'));
  }
  else {
    $op = substr($form_values['op'], 17);
    $all_groups = _nf_handshake_get_groupnames();
    if (!in_array($form_values[$op]['new_field'], $all_groups[$op])) {
      $all_groups[$op][$form_values[$op]['new_field']] = $form_values[$op]['new_field'];
    }
    ksort($all_groups[$op]);
    variable_set('nf_handshake_groupnames', $all_groups);
    drupal_set_message(t('The group list has been updated.'));
  }
    
  return 'admin/user/nf_handshake/make_grouping';
} // function nf_handshake_make_groupings_submit()

/**
 * Theme for the group maker.
 *
 * <p>The purpose of groups was explained elsewhere. Here we add new groups via a textfield and associated button. Groups are presented as fieldsets
 * and fields can be added to them. Also, the groups can be deleted. Fields not in a group are in the 'no_group' group.</p>
 * @param array $form The form to render.
 * @return string $output The HTML to render the page.
 */
function theme_nf_handshake_make_groupings($form) {
  $output = '';
  $output_array = array();
  $all_groups = _nf_handshake_get_groupnames();
  $all_nodeprofiles = nodeprofile_get_types('names');
  $header = array(array('data' => t('Selected fieldnames'), 'colspan' => 2));
  $output .= drupal_render($form['note']);
  if (!empty($all_groups)) {
    foreach ($all_groups as $group => $name) {
      $rows = array();
      if (!empty($name)) {
        foreach ($name as $key => $value) {
          $exp_val = explode('::', $value);
          $type = $exp_val[0];
          $val = $exp_val[1];
          if ($exp_val[0] == 'Users table') {
            $delete = l(t('delete'), 'admin/user/nf_handshake/delete_group/' .$group. '/Users_table::' .$val);
            $rows[] = array('Users table::' .$val, $delete);
          }
          else {
            $delete = l(t('delete'), 'admin/user/nf_handshake/delete_group/' .$group. '/' .$value);
            $rows[] = array($all_nodeprofiles[$type]. '::' .$val, $delete);
          }
        }
      }
      $edit = l(t('edit group'), 'admin/user/nf_handshake/edit_group/' .$group);
      $delete = l(t('delete group'), 'admin/user/nf_handshake/delete_group/' .$group);
      $rows[] = array($edit, $delete);
      if ($form[$group]['new_field']['#options'] == array()) {
        unset($form[$group]['new_field']);
        unset($form[$group]['submit']);
      }
      else {
        $rows[] = array(drupal_render($form[$group]['new_field']), drupal_render($form[$group]['submit']));
      }
      $fieldset = array(
      '#type' => 'fieldset',
      '#value' => theme('table', $header, $rows),
      '#title' => t('Group: ') .$group,
      '#description' => t('Place fields into this group that should be exchanged together.'),
      '#collapsible' => TRUE,
      '#collapsed' => TRUE,
      '#weight' => 0,
      );
      $output_array[] = theme('fieldset', $fieldset);
    }
    ksort($output_array);
    foreach ($output_array as $out) {
      $output .= $out;
    }
  }
  $last_row[] = array(drupal_render($form['groupname']), drupal_render($form['gsubmit']));
  $output .= theme('table', array(), $last_row);
  $output .= drupal_render($form);
  return $output;
} //function theme_nf_handshake_make_groupings()

/**
 * Edit the group name
 * 
 * @param string $name The group to edit
 * @return mixed Blank if no group name specified, $form if specified
 */
function nf_handshake_group_edit($name = NULL) {
  if ($name == NULL) {
    drupal_goto('admin/user/nf_handshake/make_grouping');
    return;
  }
  if ($admin = user_access('administer handshakes')) {
    $added_groups = _nf_handshake_get_groupnames();
    $form['name'] = array(
        '#type' => 'textfield',
        '#title' => t('Group name'),
        '#default_value' => $name,
        '#size' => 20,
        '#required' => TRUE,
        '#maxlength' => 64,
      );
      $form['old_name'] = array(
        '#type' => 'value',
        '#value' => $name,
      );
      $form['submit'] = array(
        '#type' => 'submit',
        '#value' => t('Save group name'),
      );
      return $form;
  }
} // function nf_handshake_group_edit()

/**
 * Validate the group name before saving it
 * 
 * @param string $form_id
 * @param mixed $form_values
 */
function nf_handshake_group_edit_validate($form_id, $form_values) {
  if ($form_values['name']) {
    if ($form_values['op'] == t('Save group name')) {
      if (!$form_values['name']) {
        form_set_error('name', t('You must specify a valid group name.'));
      }
    }  
  }
  else {
    form_set_error('name', t('You must specify a valid group name.'));
  }
} // function nf_handshake_group_edit_validate()

/**
 * Submit the group name to be saved, to the variable.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string The path to se