modules/nf_registration_mod/nf_registration_mod.module

<?php
/**
 * This is the nf_registration_mod module for use with nodeprofiles and which will override some
 * of the standard operations of registration and nodeprofiles. Additionally, this establishes
 * a framework for sub-accounts and the managing of them by users. The actual management is done
 * in another module.

 * @version $Id$;
 * @package Registration_Mod
 * @category NeighborForge
 * @author Ryan Constantine
 * @filesource
 * @license http://www.gnu.org/licenses/gpl.txt GNU_GENERAL_PUBLIC_LICENSE
 * @link none yet
 * TODO add flag to users' data field to track whether they've completed the required pages or not; this should cut down
 * on the time it takes to verify they've done it and will eliminate some DB queries.
 */

//-----------------------------------------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 help text for section
 */
function nf_registration_mod_help($section='') {
  $output = '';
  switch ($section) {
    case "admin/help#nf_registration_mod":
      $output = '<p>' . t("Changes the registration page to allow for multiple kinds of accounts and directs each to a unique pageroute.
See the pageroute module as well as the nodeprofiles module for more details."). '</p>';
      break;
  }

  return $output;
} // function nf_registration_mod_help()

/**
 * Implementation of hook_perm
 *
 * Valid permissions for this module
 * @return array An array of valid permissions for the onthisdate module
 */
function nf_registration_mod_perm() {
  return array('administer registration pageroutes');
} // function nf_registration_mod_perm()

/**
 * Implementation of hook_menu
 *
 * @return array An array of arrays, to add menu entries to the system menu.
 */
function nf_registration_mod_menu($may_cache) {
  global $_menu, $user;
  $items = array();
  if ($may_cache) {
    $items[] = array( //adminster
    'path' => 'admin/user/nf_registration_mod',
    'title' => t('Registration Membership Types'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_main'),
    'access' => user_access('administer registration pageroutes'),
    'description' => t('Create membership types, associate them with pageroutes, and update permissions.'),
    'type' => MENU_NORMAL_ITEM,
    );
    
    $items[] = array( //tab to take us to main administer page
    'path' => 'admin/user/nf_registration_mod/overview',
    'title' => t('Overview'),
    'access' => user_access('administer registration pageroutes'),
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
    );
    
    $items[] = array(
    'path' => 'admin/user/nf_registration_mod/ct_adjustments',
    'title' => t('Content type adjustments'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_content_type_adjustments'),
    'access' => user_access('administer registration pageroutes'),
    'type' => MENU_LOCAL_TASK,
    );
    
    $items[] = array( //delete a membership type and its pageroute
    'path' => 'admin/user/nf_registration_mod/delete',
    'title' => t('Delete'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_confirm_delete'),
    'access' => user_access('administer registration pageroutes'),
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array( //edit a membership type's name or pageroute tie
    'path' => 'admin/user/nf_registration_mod/edit',
    'title' => t('Edit'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_edit'),
    'access' => user_access('administer registration pageroutes'),
    'type' => MENU_CALLBACK,
    );
    $mem_select_access = ($user->uid == 0 ? TRUE : FALSE) || ($user->uid == 1? TRUE : FALSE) || user_access('administer users');
    $items[] = array( //select a membership type as first step for registration
    'path' => 'user/membership_select',
    'title' => t('Select desired Membership'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_select_membership'),
    'access' => $mem_select_access,
    'type' => MENU_CALLBACK,
    );
    
    $items[] = array( //edit a membership type's name or pageroute tie
    'path' => 'admin/user/nf_registration_mod/set_access',
    'title' => t('Set access'),
    'callback' => 'drupal_get_form',
    'callback arguments' => array('nf_registration_mod_access'),
    'access' => user_access('administer registration pageroutes'),
    'type' => MENU_LOCAL_TASK,
    );
  }
  elseif (!$may_cache) {
    $admin_access = user_access('administer users');
    $user_access = $user->uid == arg(1);
    $user_access3 = $user->uid == arg(3);
    if ($accounttypes = module_exists('accounttypes')) {
      $items[] = array(
      'path' => 'admin/user/nf_registration_mod/account_type',
      'title' => t('Tie account type to membership'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('nf_registration_mod_tie_account_type'),
      'access' => user_access('administer registration pageroutes'),
      'type' => MENU_LOCAL_TASK,
      );
    }
    
    if (arg(0) == 'user' && arg(2) == 'edit') {
      $edit_user = user_load(array('uid' => arg(1)));
      $membership_type = $edit_user->mem_choice;
      $mem_pageroutes = _nf_registration_mod_get_added();
      $all_routes = _nf_registration_mod_get_pageroutes();
      $all_pages = _nf_registration_mod_get_pageroute_pages();
      $user_route = $all_routes[$mem_pageroutes[$membership_type]];
      $user_pages = $all_pages[$mem_pageroutes[$membership_type]];
      $sql = "SELECT nid FROM {node} WHERE uid = %d AND type = '%s'";
      $weight = -10;
      $path = $user_route .'/0/'. arg(1);
      //TODO for other modules that may add a link to 'Account settings' unset it from $_menu
      $items[] = array(
        'path' => 'user/'. arg(1) .'/edit/pageroute',
        'title' => t('Personal data'),
        'callback' => 'drupal_goto',
        'callback arguments' => array($path, 'destination=user/'. arg(1) .'/edit'),
        'access' => $admin_access || $user_access,
        'type' => MENU_LOCAL_TASK,
        'weight' => $weight,
        );
      $items[] = array(
        'path' => 'user/'. arg(1) .'/edit/settings',
        'title' => t('General settings'),
        'access' => $admin_access || $user_access,
        'type' => MENU_DEFAULT_LOCAL_TASK,
        'weight' => -20,
        );
    }
    if (is_numeric(arg(2)) && is_numeric(arg(3))) {
      //this isn't working. pageroute is thwarting this - I had to patch pageroute and this still doesn't work - the callback never fires.
      $edit_user = user_load(array('uid' => arg(3)));
      $membership_type = $edit_user->mem_choice;
      $mem_pageroutes = _nf_registration_mod_get_added();
      $all_routes = _nf_registration_mod_get_pageroutes();
      $user_route = $all_routes[$mem_pageroutes[$membership_type]];
      if (arg(0) == $user_route) {
        $return_path = 'user/'. arg(3) .'/edit';
        global $_SESSION;
        $_SESSION['myarg'] = arg(3);
        $items[] = array(
          'path' => $user_route .'/return',
          'title' => t('Back to "My account"'),
          'callback' => 'drupal_goto',
          'callback arguments' => array($return_path),
          'access' => $admin_access || $user_access3,
          'type' => MENU_LOCAL_TASK,
          'weight' => 100,
          );
      }
    }
    $_menu['callbacks']['node/add']['callback'] = 'nf_registration_mod_node_add';
    if (isset($_SESSION['no_browse']) && ($_SESSION['no_browse'] == 1)) {
      if ($user->uid == 1) {
        return $items;
      }
      $required_types = variable_get('nf_registration_mod_req_types', array());
      if (empty($required_types)) {
        return $items;
      }
      else {
        //get all of the data we need to determine which types correspond to the user
        $membership_type = $user->mem_choice;
        $mem_pageroutes = _nf_registration_mod_get_added();
        $all_routes = _nf_registration_mod_get_pageroutes();
        $all_pages = _nf_registration_mod_get_pageroute_pages();
        $user_route = $all_routes[$mem_pageroutes[$membership_type]];
        $user_pages = $all_pages[$mem_pageroutes[$membership_type]];
        //now check the route content types against those that are required
        $completed_requirements = array();
        $incomplete_requirements = array();
        $sql = "SELECT nid FROM {node} WHERE uid = %d AND type = '%s'";
        foreach ($required_types as $type => $val) {
          if ($page_name = array_search($type, $user_pages)) {
            if ($result = db_fetch_object(db_query($sql, $user->uid, $type))) {
              $completed_requirements[$type] = $result->nid;
            }
            else {
              $incomplete_requirements[] = $page_name;
            }
          }
        }
        //Construct a string of the page names
        $output = implode(', ', $incomplete_requirements);
        //if the user hasn't met the requirements, send them to the right spot
        if (!empty($incomplete_requirements) && (arg(0) != $user_route) && (arg(0) != 'logout') && (arg(0) != 'user') && (arg(1) != 'activeselect')) {
          drupal_set_message(t('You still have some mandatory data to enter before you can use this website.
                              You need to complete: ') .$output);
          unset($_REQUEST['destination']);
          $_SESSION['no_browse'] = 1;
          drupal_goto($user_route. '/' .$incomplete_requirements[0]);
          return $items;
        }
        elseif (empty($incomplete_requirements)) {
          unset($_SESSION['no_browse']);
        }
      }
    }
  }
  return $items;
} // function nf_registration_mod_menu()

//-----------------------------------------Administrative Hooks and Functions-----------------------------------------
//-----------------------------------------Administrative Hooks and Functions-----------------------------------------
//-----------------------------------------Administrative Hooks and Functions-----------------------------------------

/**
 * Callback function: Add options for the .
 *
 * @return mixed
 */
function nf_registration_mod_main() {
  if ($admin = user_access('administer registration pageroutes')) {
    $form['memberships'] = array(
      '#type' => 'textfield',
      '#size' => 20,
      '#maxlength' => 64,
      '#description' => t('Should not contain spaces'),
    );
    $form['msubmit'] = array(
      '#type' => 'submit',
      '#value' => t('Add membership type'),
    );
    $pageroutes = _nf_registration_mod_get_pageroutes();
    $form['tie'] = array(
      '#type' => 'select',
      '#options' => $pageroutes,
    );
    $form['tsubmit'] = array(
      '#type' => 'submit',
      '#value' => t('Add pageroute tie'),
    );
    $form['secret_value'] = array(
      '#type' => 'value',
      '#value' => '',
    );
    $added_names = _nf_registration_mod_get_added();
    if (!empty($added_names)) {
      foreach ($added_names as $name => $tie) {
        if (empty($tie) && ($form['secret_value']['#value'] == '')) {
          $form['secret_value']['#value'] = $name;
        }
      }
    }
    $form['user_instructions'] = array(
      '#type' => 'textarea',
      '#title' => t('User instructions'),
      '#description' => t('Write instructions to your users so they know how to choose their membership type.'),
      '#default_value' => variable_get('nf_registration_mod_instructions', ''),
    );
    $form['usubmit'] = array(
      '#type' => 'submit',
      '#value' => t('Save message'),
    );
  }
  return $form;
} // function nf_registration_mod_main()

/**
 * Validate the membership name before adding or saving it
 *
 * @param string $form_id
 * @param mixed $form_values
 */
function nf_registration_mod_main_validate($form_id, $form_values) {
  //make sure the user isn't injecting something already on the list.
  if ($form_values['op'] == t('Add membership type')) {
    if (!$form_values['memberships']) {
      form_set_error('memberships', t('You must specify a valid membership name.'));
    }
    $check_options = _nf_registration_mod_get_added();
    if (empty($check_options)) {
      $check_options = array();
    }
    if (array_key_exists($form_values['memberships'], $check_options)) {
      form_set_error('memberships', t('The membership name %name is already added. Please choose another name.', array('%name' => $form_values['memberships'])));
    }
  }
  elseif ($form_values['op'] == t('Add pageroute tie')) {
    if (!$form_values['tie']) {
      form_set_error('tie', t('You must specify a valid pageroute.'));
    }
    $pageroutes = _nf_registration_mod_get_pageroutes();
    if (!array_key_exists($form_values['tie'], $pageroutes)) {
      form_set_error('tie', t('The pageroute %name is not valid. You must choose from the dropdown list.', array('%name' => $form_values['tie'])));
    }
  }
} // function nf_registration_mod_main_validate()

/**
 * Submit the membership name to be added to the variable.
 *
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function nf_registration_mod_main_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Add membership type')) {
    $mem_nums = variable_get('nf_registration_mod_mem_num', array());
    $mem_nums[] = $form_values['memberships'];
    variable_set('nf_registration_mod_mem_num', $mem_nums);
    $added_names = _nf_registration_mod_get_added();
    $added_names[$form_values['memberships']] = '';
    variable_set('nf_registration_mod_memberships', $added_names);
    drupal_set_message(t('The membership name has been added.'));
  }
  elseif ($form_values['op'] == t('Add pageroute tie')) {
    $added_names = _nf_registration_mod_get_added();
    $added_names[$form_values['secret_value']] = $form_values['tie'];
    variable_set('nf_registration_mod_memberships', $added_names);
    drupal_set_message(t('The pageroute tie has been added.'));
  }
  elseif ($form_values['op'] == t('Save message')) {
    variable_set('nf_registration_mod_instructions', $form_values['user_instructions']);
  }
  return 'admin/user/nf_registration_mod';
} // function nf_registration_mod_main_submit()

/**
 * Theme for the add page of the main function.
 *
 * <p>This lists all of the current membership option names with links to edit them or their assigned pageroute, followed with
 * a field and button to add a new membership options name to the list.</p>
 * @param mixed $form
 * @return mixed
 */
function theme_nf_registration_mod_main($form) {
  $header = array(t('Membership title'), array('data' => t('Pageroute'), 'colspan' => 2), array('data' => t('Operations'), 'colspan' => 2));
  $added_names = _nf_registration_mod_get_added();
  $pageroutes = _nf_registration_mod_get_pageroutes(); 
  if (!empty($added_names)) {
    foreach ($added_names as $name => $tie) {
      if (empty($tie)) {
        $admin = l(t('edit'), 'admin/user/nf_registration_mod/edit/' .$name);
        $delete = l(t('delete'), 'admin/user/nf_registration_mod/delete/' .$name);
        $rows[] = array($name, drupal_render($form['tie']), drupal_render($form['tsubmit']), $admin, $delete);
      }
      else {
        $route = $pageroutes[$tie];
        $admin = l(t('edit'), 'admin/user/nf_registration_mod/edit/' .$name);
        $delete = l(t('delete'), 'admin/user/nf_registration_mod/delete/' .$name);
        $rows[] = array($name, $route, '', $admin, $delete);
      }
    }
    unset($form['tie']);
    unset($form['tsubmit']);
  }
  else {
    unset($form['tie']);
    unset($form['tsubmit']);
  }
  $rows[] = array(drupal_render($form['memberships']), array('data' => drupal_render($form['msubmit']), colspan => 4));

  $output = theme('table', $header, $rows);
  $output .= drupal_render($form);

  return $output;
} //function theme_nf_registration_mod_main()

/**
 * Returns a confirmation page for deleting a membership.
 *
 * @param integer $name Name of membership to be deleted; passed in from path.
 * @return array $form The name is passed to the submit.
 */
function nf_registration_mod_confirm_delete($name = NULL) {
  if ($name == NULL) {
    drupal_goto('admin/user/nf_registration_mod');
    return;
  }
  if ($admin = user_access('administer registration pageroutes')) {
    $added_names = _nf_registration_mod_get_added();
    $form['name'] = array(
      '#type' => 'value',
      '#value' => $name,
    );
    $return_address = 'admin/user/nf_registration_mod';
    $form = confirm_form($form, t('Are you sure you want to delete the membership type %name?',
      array('%name' => $name)), $return_address,
      t('Deleting a membership type here will not delete the pageroute it is tied to. You still do that through the pageroute administration. This action cannot be undone.'), t('Delete'), t('Cancel'));
      return $form;
  }
} // function nf_registration_mod_confirm_delete()

/**
 * Implementation of forms api _submit call. Deletes a membership 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 record.
 */
function nf_registration_mod_confirm_delete_submit($form_id, $form_values) {
  $added_names = _nf_registration_mod_get_added();
  unset($added_names[$form_values['name']]);
  variable_set('nf_registration_mod_memberships', $added_names);
  $mem_nums = variable_get('nf_registration_mod_mem_num', NULL);
  if (is_array($mem_nums)) {
    $key = array_keys($mem_nums, $form_values['name']);
    drupal_set_message('<pre>Form values: ' .print_r($form_values['name'], TRUE). '</pre>');
    drupal_set_message('<pre>Mem nums: ' .print_r($mem_nums, TRUE). '</pre>');
    drupal_set_message('<pre>Key: ' .print_r($key, TRUE). '</pre>');
    unset($mem_nums[$key[0]]);
    variable_set('nf_registration_mod_mem_num', $mem_nums);
  }
  if (!isset($added_names[$form_values['name']])) {
    drupal_set_message(t('The membership type %name has been removed from administration.', array('%name' => $form_values['name'])));
    watchdog('content', t('nf_registration_mod: deleted %name.', array('%name' => $form_values['name'])));
  }
  if ($added_accs = _nf_registration_mod_get_acc_types()) {
    unset($added_accs[$form_values['name']]);
    variable_set('nf_registration_mod_acc_types', $added_accs);
    if (!isset($added_accs[$form_values['name']])) {
      drupal_set_message(t('The account type %name has been untied from the membership type administration.', array('%name' => $form_values['name'])));
    }
  }
  $return_address = 'admin/user/nf_registration_mod';
  return $return_address;
} // function nf_registration_mod_confirm_delete_submit()

/**
 * Callback function: Add, edit, or delete account types.
 * 
 * <p>Here is where the admin interface is for creating new account types,editing their names, or deleting them.</p>
 * @param integer $name The name of the membership type.
 * @return mixed
 */
function nf_registration_mod_edit($name = NULL) {
  if ($name == NULL) {
    drupal_goto('admin/user/nf_registration_mod');
    return;
  }
  if ($admin = user_access('administer registration pageroutes')) {
    $added_names = _nf_registration_mod_get_added();
    $form['name'] = array(
        '#type' => 'textfield',
        '#title' => t('Membership type name'),
        '#default_value' => $name,
        '#size' => 20,
        '#required' => TRUE,
        '#maxlength' => 64,
      );
      $pageroutes = _nf_registration_mod_get_pageroutes();
      $form['tie'] = array(
        '#type' => 'select',
        '#title' => t('Pageroute'),
        '#required' => TRUE,
        '#default_value' => $added_names[$name],
        '#options' => $pageroutes,
      );
      $form['old_name'] = array(
        '#type' => 'value',
        '#value' => $name,
      );
      if (!module_exists('accounttypes')) {//accounttypes implements auto-roll assign; don't step on toes
        $roles = user_roles(TRUE);
        unset($roles['2']);
        $current_role = variable_get('nf_registration_mod_enhance_roles', array());
        $current_role = $current_role[$name];
        $form['nf_registration_mod_enhance_roles'] = array(
          '#type' => 'radios',
          '#title' => t('Select role to automatically assign to new users'),
          '#options' => $roles,
          '#default_value' => $current_role,
          '#description' => t('The selected role will be assigned to new registrants from now on.  Be sure this role does not have any privileges you fear giving out without reviewing who receives it.'),
        );
      }
      $form['submit'] = array(
        '#type' => 'submit',
        '#value' => t('Save membership type'),
      );
      return $form;
  }
} // function nf_registration_mod_edit()

/**
 * Validate the membership type name before saving it
 * 
 * @param string $form_id
 * @param mixed $form_values
 */
function nf_registration_mod_edit_validate($form_id, $form_values) {
  if ($form_values['name']) {
    if ($form_values['op'] == t('Save membership type')) {
      if (!$form_values['name']) {
        form_set_error('name', t('You must specify a valid membership name.'));
      }
      $check_options = _nf_registration_mod_get_added();
      if (empty($check_options)) {
        $check_options = array();
      }
      if (!$form_values['tie']) {
        form_set_error('tie', t('You must specify a valid pageroute.'));
      }
      $pageroutes = _nf_registration_mod_get_pageroutes();
      if (!array_key_exists($form_values['tie'], $pageroutes)) {
        form_set_error('tie', t('The pageroute %name is not valid. You must choose from the dropdown list.', array('%name' => $form_values['tie'])));
      }
    }  
  }
  else {
    form_set_error('name', t('You must specify a valid membership type name.'));
  }
} // function nf_registration_mod_edit_validate()

/**
 * Submit the membership type name to be saved, to the database.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function nf_registration_mod_edit_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Save membership type')) {
    //save membership-pageroute association
    $added_names = _nf_registration_mod_get_added();
    unset($added_names[$form_values['old_name']]);
    $added_names[$form_values['name']] = $form_values['tie'];
    variable_set('nf_registration_mod_memberships', $added_names);
    drupal_set_message(t('The membership type has been updated.'));
    //save accounttype tie
    if ($added_accs = variable_get('nf_registration_mod_acc_types', FALSE)) {
      $added_accs[$form_values['name']] = $added_accs[$form_values['old_name']];
      unset($added_accs[$form_values['old_name']]);
      variable_set('nf_registration_mod_acc_types', $added_accs);
    }
    if ($choices = variable_get('nf_registration_mod_mem_num', FALSE)) {
      if ($key = array_search($form_values['old_name'], $choices)) {
        $choices[$key] = $form_values['name'];
      }
      variable_set('nf_registration_mod_mem_num', $choices);
    }
    //for auto-role-assign
    if (!module_exists('accounttypes')) {//accounttypes implements auto-roll assign; don't step on toes
      $added_roles = variable_get('nf_registration_mod_enhance_roles', NULL);
      unset($added_roles[$form_values['old_name']]);
      $added_roles[$form_values['name']] = $form_values['nf_registration_mod_enhance_roles'];
      variable_set('nf_registration_mod_enhance_roles', $added_roles);
    }
  }
  return 'admin/user/nf_registration_mod';
} // function nf_registration_mod_edit_submit()

/**
 * Present an interface to allow tying account types to membership types
 */
function nf_registration_mod_tie_account_type() {
  if ($admin = user_access('administer registration pageroutes')) {
    $added_names = _nf_registration_mod_get_added();
    $added_account_types = _nf_registration_mod_get_acc_types();
    $account_types = get_accounttypes();
    foreach ($added_names as $name => $prid) {
      $form[$name] = array(
        '#type' => 'select',
        '#default_value' => $added_account_types[$name],
        '#options' => $account_types,
      );
    }
    $form['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Save assignments'),
    );
  }
  return $form;
} // function nf_registration_mod_tie_account_type()

/**
 * Validate the account type assignments before saving them
 * 
 * @param string $form_id
 * @param mixed $form_values
 */
function nf_registration_mod_tie_account_type_validate($form_id, $form_values) {
  if ($form_values['op'] == t('Save assignments')) {
    $added_names = _nf_registration_mod_get_added();
    $account_types = get_accounttypes();
    foreach ($added_names as $name => $prid) {
      if (!array_key_exists($form_values[$name], $account_types)) {
        form_set_error($name, t('The account type %name is not valid. You must choose from the dropdown list.', array('%name' => $form_values['atid'][$name])));
      }
    }
  }
} //function nf_registration_mod_tie_account_type_validate()

/**
 * Submit the membership/account type tie to be saved.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function nf_registration_mod_tie_account_type_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Save assignments')) {
    $added_names = _nf_registration_mod_get_added();
    $added_account_types = _nf_registration_mod_get_acc_types();
    foreach ($added_names as $name => $prid) {
      $added_account_types[$name] = $form_values[$name];
    }
    variable_set('nf_registration_mod_acc_types', $added_account_types);
    drupal_set_message(t('The membership/account type ties have been updated.'));
  }
  return 'admin/user/nf_registration_mod';
} // function nf_registration_mod_tie_account_type_submit()

/**
 * Theme for the account type tie function. Display in tabular format.
 *
 * <p>This presents a table with membership type names in one column. Each has a drop down selector in the next column. If an account type
 * has been selected for that membership type, it will be selected by default. Tying an account type to a membership type in this manner
 * will assign that account type to any person that signs up using that membership type.</p>
 * @param mixed $form
 * @return mixed
 */
function theme_nf_registration_mod_tie_account_type($form) {
  $header = array(t('Membership title'), t('Account types'));
  $added_names = _nf_registration_mod_get_added(); 
  if (!empty($added_names)) {
    foreach ($added_names as $name => $prid) {
      $rows[] = array($name, drupal_render($form[$name]));
    }
  }
  else {
    foreach ($added_names as $name => $prid) {
      unset($form[$name]);
    }
    unset($form['submit']);
  }
  $rows[] = array(array('data' => drupal_render($form['submit']), colspan => 2));

  $output = drupal_render($form);
  $output .= theme('table', $header, $rows);

  return $output;
} //function theme_nf_registration_mod_tie_account_type()

/**
 * Show menu items which were disabled from 'create content' menu. Also, show which pageroute menus were disabled.
 */
function nf_registration_mod_content_type_adjustments() {
  if ($admin = user_access('administer registration pageroutes')) {
    $types = _nf_registration_mod_group_pageroute_types();
    foreach ($types as $type => $prid) {
      $form[$type] = array(
        '#type' => 'checkbox',
      );
    }
    $form['info'] = array(
      '#type' => 'item',
      '#value' => t('This is to let you know which content types should be removed from the <em>Create content</em> menu and any OG menus if you\'ve got OG enabled.
It is advised that you check all items and then disable them as users should probably not be able to create these after the registration process.
That is of course, as long as you\'re using <em>Lonely Nodes</em> and the <em>Nodeprofile</em> module along with the <em>Pageroute</em> module.
You can set which of these content types are read-only and which can be edited and by which roles on the <em>Set access</em> tab.'),
    );
    $form['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Disable menu items'),
    );
    $form['submit_required'] = array(
      '#type' => 'submit',
      '#value' => t('Require for login'),
    );
  }
  return $form;
} // function nf_registration_mod_content_type_adjustments()

/**
 * Submit the content type menu items to be disabled. Items are diabled from the 'create content' menu and also added to the Organic
 * Groups list of omitted types if OG is present. We don't check for the presence of OG, because we're just setting a 'variable' from
 * the variable table. 
 * 
 * This is a different approach than that used by the og_content_type_admin module because the changes here affect all users and
 * aren't changed on a per-user basis.
 * 
 * Also, on this page, we can set which content types are mandatory in order for the user to use the site. At login, the hook_user
 * function will check to see if the user has created a node of each required type. If not, then they will be presented with the
 * pageroute page they need to complete. So even if they started filling out their pageroute, if they abandoned it at any point,
 * they cannot proceed.
 * 
 * This may be a clunky interface. We'll have to see. I am using the same checkboxes for disabling as for requiring. Consequently,
 * they cannot be set as default_values. However, a status column indicates their current settings. To keep a setting, it must be
 * checked for the operation you execute.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function nf_registration_mod_content_type_adjustments_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Disable menu items')) {
  //disable content type menu items
    $status = _nf_registration_mod_menu_status();
    $sql = "UPDATE {menu} SET type = 48 WHERE path = '%s'";
    $og_omitted = variable_get('og_omitted', array());
    foreach ($status as $type => $nums) {
      if (($form_values[$type] == 1) && ($nums[1] != 48)) {
        if ($result = db_query($sql, $nums[0])) {
          drupal_set_message(t('Successfully disabled content type menu item') .' <em>' .$nums[0]. '</em>');
        }
        else {
          drupal_set_message(t('Failed to disable content type menu item') .' <em>' .$nums[0]. '</em>', 'error');
        }
        $og_omitted[$type] = $type;
      }
    }
    variable_set('og_omitted', $og_omitted);
    
    //now disable pageroute menu items
    $sqls = "UPDATE {menu} SET type = 48 WHERE path = '%s'";
    $results = db_query("SELECT * FROM {pageroute_routes} ORDER BY path");
    while ($route = db_fetch_object($results)) {
      if ($resulta = db_query($sqls, $route->path)) {
        drupal_set_message(t('Successfully disabled pageroute menu item') .'<em>' .$route->path. '</em>');
      }
      else {
        drupal_set_message(t('Failed to disable pageroute menu item') .' <em>' .$route->path. '</em>', 'error');
      }
    }
    cache_clear_all(NULL, 'cache_menu', '*');
  }
  if ($form_values['op'] == t('Require for login')) {
    $content_types = _nf_registration_mod_group_pageroute_types();
    $required_types = array();
    foreach ($content_types as $type => $nums) {
      if ($form_values[$type] == 1) {
        $required_types[$type] = $type;
      }
    }
    variable_set('nf_registration_mod_req_types', $required_types);
    drupal_set_message(t('Required content types saved.'));
  }

return 'admin/user/nf_registration_mod';
} // function nf_registration_mod_content_type_adjustments_submit()

/**
 * Present the menu status for each content type
 */
function theme_nf_registration_mod_content_type_adjustments($form) {
  $pageroutes = _nf_registration_mod_get_pageroutes();
  $pagepages = _nf_registration_mod_get_pageroute_pages();
  $types = _nf_registration_mod_group_pageroute_types();
  $status = _nf_registration_mod_menu_status();
  $status2 = _nf_registration_mod_required_content_types();
  
  /*$header = array(t('Pageroute'), t('Page name'), t('Content type'));
  if (!empty($pagepages)) {
    foreach ($pagepages as $prid => $page) {
      $rows[] = array($pageroutes[$prid], '', '');
      foreach ($page as $name => $type) {
        $rows[] = array('', $name, $type);
      }
    }
  }
  $output = theme('table', $header, $rows);*/
  $output = drupal_render($form['info']);
  $header2 = array(array('data' => t('Content type'), 'colspan' => 2), t('Status'), t('Menu path'), t('Pageroute'), t('Page name'));
  if (!empty($types)) {
    foreach ($types as $type => $prid) {
      $sql = "SELECT name FROM {node_type} WHERE type = '%s'";
      $result = db_fetch_object(db_query($sql, $type));
      if ($status[$type][1] == 48) {
        $current_status = '<strong>'. t('disabled') .'</strong>';
        if ($status2[$type] == $type) {
          $current_status .= '<strong>/'. t('required') .'</strong>';
        }
      }
      else {
        $current_status = '<strong>'. t('enabled') .'</strong>';
        if ($status2[$type] == $type) {
          $current_status .= '<strong>/'. t('required') .'</strong>';
        }
      }
      $rows2[] = array(drupal_render($form[$type]), $result->name, $current_status, $status[$type][0], '', '');
      foreach ($prid as $id => $page) {  
        $rows2[] = array('', '', '', '', $pageroutes[$id], $page);
      }
    }
  }
  $rows2[] = array(array('data' => drupal_render($form['submit']), colspan => 6));
  $rows2[] = array(array('data' => drupal_render($form['submit_required']), colspan => 2),
                   array('data' => t('Prevent users from using the site until these content types are created for them. Login will route them to these pages.'), colspan => 4)
                   );
  $output .= theme('table', $header2, $rows2);
  $output .= drupal_render($form);

  return $output;
} // function theme_nf_registration_mod_content_type_adjustments()

/**
 * Interception of the node module's node_add function.
 * 
 * Present a node submission form or a set of links to such forms.
 */
function nf_registration_mod_node_add($type = NULL) {
  global $user, $_GET;
  
  if (module_exists('og_content_type_admin')) {
    exit();//let og_content_type_admin deal with this if it is enabled
  }
  $types = node_get_types();
  $pageroute_types = _nf_registration_mod_menu_status();
  foreach ($pageroute_types as $typea => $nums) {
    if ($nums[1] == 48) {
      if (isset($types[$typea])) {
        unset($types[$typea]);
      }
    }
  }
  $type = isset($type) ? str_replace('-', '_', $type) : NULL;
  
  // If a node type has been specified, validate its existence and output the form if authorized.
  if (isset($types[$type])) {
    // Initialize settings:
    $node = array('uid' => $user->uid, 'name' => $user->name, 'type' => $type);
    drupal_set_title(t('Submit @name', array('@name' => $types[$type]->name)));
    $output = drupal_get_form($type. '_node_form', $node);
  }
  else {
    // If no (valid) node type has been provided, display a node type overview.
    // Make sure to use the site-wide settings since we're on the node/add page in this case.
    foreach ($types as $type) {
      if (function_exists($type->module. '_form') && node_access('create', $type->type)) {
        $type_url_str = str_replace('_', '-', $type->type);
        $title = t('Add a new @s.', array('@s' => $type->name));
        $out = '<dt>' .l(drupal_ucfirst($type->name), "node/add/$type_url_str", array('title' => $title)). '</dt>';
        $out .= '<dd>' .filter_xss_admin($type->description). '</dd>';
        $item[$type->type] = $out;
      }
    }

    if (isset($item)) {
      uksort($item, 'strnatcasecmp');
      $output = t('Choose the appropriate item from the list:'). '<dl>' .implode('', $item). '</dl>';
    }
    else {
      drupal_set_title(t('Invalid Content Type'));
      $output = t('Either the content type you are trying to create does not exist, or you are not authorized to access the content type you have tried to create in the current context. \'Create\' a content type by selecting from either the group menu or the \'Create content\' menu instead.');
    }
  }

  return $output;
} // function nf_registration_mod_node_add()

/**
 * Allow the admin to set two permissions for each content type here instead/in addition to the regular interface.
 * 
 * The permissions that make sense to set here are the 'create' and 'edit own' permissions for each content type.
 * In the author's application, there are several content types that the user should fill out. The first several
 * contain required information and are also things that should never change. If the user wants to change these
 * items, the author wants them to contact the admin for assistance. Consequently, the user will be given the
 * 'create' permission for those content types, but not the 'edit own' permission. Other pages will contain info
 * that should change regularly. For these content types, the user is given both the 'create' and 'edit own'
 * permissions. This function deals not at all with the regular 'edit' permission allowing one to edit anybody's
 * posts of that content type.
 */
function nf_registration_mod_access() {
  if ($admin = user_access('administer registration pageroutes')) {
    $roles = user_roles();
    //TODO add permissions modification section; not sure how to do that; storage implies that I need to list all perms...
    $form['info'] = array(
        '#type' => 'item',
        '#value' => t('<p>In the future, you will be able to set the permissions that directly relate to the content types of your pageroutes here.
For now, proceed to the regular permissions page. I suggest you start by assigning the \'create [CONTENT TYPE] content\' to as many roles as will need it for each of the pageroute content types.
Then, if you were clever and designed a few content types that you\'d like users to NOT change after creation, make sure NOT to assign regular users\' roles the \'edit own [CONTENT TYPE] content\' permission.
For content types that are meant to be changed later or often, DO assign the \'edit own [CONTENT TYPE] content\' permissions. If you do things this way, make sure to also NOT use the \'Integrate into profile categories\' option.
For example, the author has a content type which holds a name and a birthdate. Clearly, these should (almost) never change and there is no reason the user should.
In this case, users can create the content but not edit it. Should a name need changing, the sys admin can do it.</p>
<p>Alternatively, use an access module like TAC to give your users view access without edit access.</p>'),        
        /*t('From here you can decide which content types will be read-only and which will be editable after creation.
Check the box in the appropriate column next to each content type where you would like to give the selected roles either the
<em>edit own CONTENT TYPE content</em> permission, or the <em>create CONTENT TYPE content</em> permission. Then click the corresponding button
to apply your changes. All other roles will be set to NOT have that permission. Remember, a user only needs one role with a 
given permission in order to use it. Plan accordingly. Set any other permissions related to these content types in the usual way.
Of course, you may choose not to use this page at all. It is simply here for convenience.'),*/
     );
  }
   return $form;
} // function nf_registration_mod_access()

/**
 * Present the menu status for each content type
 */
function theme_nf_registration_mod_access($form) {
  $output = drupal_render($form['info']);
  $output .= l(t('Set content type permissions in the node module section.'), 'admin/user/access');
  //$header2 = array(array('data' => t('Content type'), 'colspan' => 2), t('Status'), t('Menu path'), t('Pageroute'), t('Page name'));
  return $output;
} // function nf_registration_mod_access()

//-----------------------------------------Worker Hooks and Functions-----------------------------------------
//-----------------------------------------Worker Hooks and Functions-----------------------------------------
//-----------------------------------------Worker Hooks and Functions-----------------------------------------

/**
 * Implementation of hook_user
 * 
 * We need to intercept the user processes at a couple of places. First, at registration, we need to add the
 * membership selection to the user registration page so it will later be saved in the user's data field. Next,
 * because we're using a session variable to keep track of the rerouting of the registration page see
 * (hook_form_alter), we need to unset it when the user is inserted. Lastly, if we have required that certain
 * pages of the user's pageroute be filled out before they can be active on the site, we intercept the login
 * process and route the user where they need to go.
 * 
 * @param string $op The operation to be performed.
 * @param array $edit The data to be operated on.
 * @param mixed &$account The user's account.
 * @param string $category The category of the user account or registration page.
 */
function nf_registration_mod_user($op, &$edit, &$account, $category = NULL) {
  if (!$edit['mem_choice']) {
    if (isset($account->mem_choice)) {
      $membership_type = $account->mem_choice;
    }
  } 
  else {
    $membership_type = $edit['mem_choice'];
  }
  switch ($op) {
    case 'register':
      $form['mem_choice'] = array(
        '#type' => 'hidden',
        '#value' => $_SESSION['mem_choice'],
      );
      if (!module_exists('accounttypes')) {//accounttypes implements auto-roll assign; don't step on toes
        if (!empty($_SESSION['mem_choice']) && $rid = variable_get('nf_registration_mod_enhance_roles', '')) {
          $rid = $rid[$_SESSION['mem_choice']];
          $form['mem_choice_role'] = array(
          '#type' => 'hidden',
          '#value' => $rid,
          );
        }
      }
      return $form;
      
    case 'insert':
      unset($_SESSION['mem_choice']);
      if (!module_exists('accounttypes')) {//accounttypes implements auto-roll assign; don't step on toes
        if(!empty($edit['mem_choice_role'])){
          db_query('INSERT INTO {users_roles} (uid, rid) VALUES (%d, %d)', $account->uid, $edit['mem_choice_role']);
        }
      }
      break;
      
    case 'update': //copied and modified from nodeprofile.module
      if (($membership_type = $user->mem_choice) && node_access('create', $category)) {
        subform_element_submit();
        unset($edit[$category. '_node_form']);
      }
      break;
      
    case 'form': //copied and modified from nodeprofile.module
      if ($membership_type = $account->mem_choice) {
        $fields['membership_type'] = array(
          '#type' =>  'item',
          '#title' => t('Membership Type'),
          '#value' => $membership_type,
          '#weight' => -50,
        );
      }
      if (($membership_type = $account->mem_choice) && node_access('create', $category) && ($category != 'account')) {
        $type = $category;
        $node = node_load(array('type' => $type, 'uid' => $account->uid));
        if (empty($node)) {
          $node = (object)array('uid' => $account->uid, 'name' => $account->name, 'type' => $type);
        }
        elseif (!node_access('update', $node)) {
          break;
        }
        $fields[$category] = array(
          '#type' => 'subform',
          '#id' => $node->type. '_node_form',
          '#arguments' => array($node),
          '#subform_after_build' => array('nf_registration_mod_adapt_node_form'),//this doesn't work if the diff module is enabled, see form_alter for the fix
        );
      }
      return $fields;
      break;

    case 'login':
      global $user;
      if ($user->uid == 1) {
        break;
      }
      $required_types = variable_get('nf_registration_mod_req_types', array());
      if (empty($required_types)) {
        break;
      }
      //get all of the data we need to determine which types correspond to the user
      $membership_type = $user->mem_choice;
      $mem_pageroutes = _nf_registration_mod_get_added();
      $all_routes = _nf_registration_mod_get_pageroutes();
      $all_pages = _nf_registration_mod_get_pageroute_pages();
      $user_route = $all_routes[$mem_pageroutes[$membership_type]];
      $user_pages = $all_pages[$mem_pageroutes[$membership_type]];
      //now check the route content types against those that are required
      $completed_requirements = array();
      $incomplete_requirements = array();
      $sql = "SELECT nid FROM {node} WHERE uid = %d AND type = '%s'";
      foreach ($required_types as $type => $val) {
        if ($page_name = array_search($type, $user_pages)) {
          if ($result = db_fetch_object(db_query($sql, $user->uid, $type))) {
            $completed_requirements[$type] = $result->nid;
          }
          else {
            $incomplete_requirements[] = $page_name;
          }
        }
      }
      //Construct a string of the page names
      $output = implode(', ', $incomplete_requirements);
      //if the user hasn't met the requirements, send them to the right spot
      if (!empty($incomplete_requirements)) {
        drupal_set_message(t('You still have some mandatory data to enter before you can use this website.
                            You need to complete: ') .$output);
          unset($_REQUEST['destination']);
          $_SESSION['no_browse'] = 1;
          drupal_goto($user_route. '/' .$incomplete_requirements[0]);
          break;
        //}
      }
      else {
        unset($_SESSION['no_browse']);
      }
      break;
  }
  return;
} // function nf_registration_mod_user()

/**
 * Assign/change existing/old users' membership type
 * 
 * This is the only interface to change a user's membership type. This is useful for existing sites that want to add this module
 * but want to ensure that existing users have a memebership type and not just new users.
 * 
 * It is advised that admins take their site offline and update all existing users. I'm sure admins would do this anyway as they
 * will also have to construct the nodeprofiles and associated pageroutes. There aren't any checks for users that don't have a
 * membership type (except user 1), so if you leave off doing this, something may explode. :-)
 */
function nf_registration_mod_user_operations() {
  global $form_values;
  if (user_access('administer registration pageroutes')) {
    $allmemtypes = _nf_registration_mod_get_added();
    
    $change_memtypes = array();
    foreach ($allmemtypes as $key => $value) {
      $change_memtypes['change_membership_type@' .$key] = $key;
    }

    if (count($allmemtypes)) {
      $memtype_operations = array(
        t('Change the membership type of the selected users') => array(
          'label' => $change_memtypes,
        ),
      );

      $operations = $memtype_operations;
    }
  }
  // If the form has been posted, we need to insert the proper data for role editing if necessary.
  if ($form_values) {
    $operation_mid = explode('@', $form_values['operation']);
    $operation = $operation_mid[0];
    $mid = $operation_mid[1];
    if ($operation == 'change_membership_type') {
      if (user_access('