modules/accounttypes/accounttypes.module

<?php
/**
 * This is the accounttypes module
 * 
 * <p>This file contains information on the accounttypes module. The module allows
 * a site admin to create account types which can be assigned roles and which will
 * make the administration of large role-sets easier.</p>
 *  
 * @version $Id$;
 * @package AccountTypes
 * @category NeighborForge
 * @author Ryan Constantine
 * @filesource
 * @license http://www.gnu.org/licenses/gpl.txt GNU_GENERAL_PUBLIC_LICENSE
 * @link none yet
 */
define('STD_ACCOUNT_TYPE', '1');

/**
 * 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 accounttypes_help($section='') {

  $output = '';

  switch ($section) {
    case "admin/help#accounttypes":
      $output = '<p>' . t("Allows the restriction of available roles based on admin-defined account types. For small sites with few roles, there is little chance of accidentally assigning the wrong role to a user. For larger sites with many defined roles, such a thing could happen, especially if assignment of roles has been delegated."). '</p>';
      break;
  }

  return $output;
} // function accounttypes_help()

/**
 * Implementation of hook_perm
 * 
 * Valid permissions for this module
 * @return array An array of valid permissions for the accounttypes module
 */
function accounttypes_perm() {
  
  return array('administer accounttypes', 'view accounttypes', 'assign accounttypes');
} // function accounttypes_perm()

/**
 * Implementation of hook_menu
 * 
 * The menu item(s) for this module.
 * @return array An array of arrays, to add menu entries to the system menu.
 */
function accounttypes_menu($may_cache) {
  $items = array();
  if ($may_cache) {
   $items[] = array( //view, add, delete, edit account types (names), admin roles, etc from this main page's tabs
     'path' => 'admin/user/accounttypes',
     'title' => t('Account Types'),
     'callback' => 'drupal_get_form',
     'callback arguments' => array('accounttypes_new_edit'),
     'access' => user_access('administer accounttypes'),
     'description' => t('Create and maintain Account Types to more easily manage large numbers of roles and users.'),
     'type' => MENU_NORMAL_ITEM,
   );
   
   $items[] = array(
     'path' => 'admin/user/accounttypes/overview',
     'title' => t('Overview'),
     'access' => user_access('administer accounttypes'),
     'type' => MENU_DEFAULT_LOCAL_TASK,
     'weight' => -10,
   );
      
     $items[] = array( //add new types, edit names of existing types, delete types
     'path' => 'admin/user/accounttypes/edit',
     'title' => t('Edit'),
     'callback' => 'drupal_get_form',
     'callback arguments' => array('accounttypes_edit'),
     'access' => user_access('administer accounttypes'),
     'type' => MENU_CALLBACK,
   );
   
   $items[] = array( //set default account type
     'path' => 'admin/user/accounttypes/default',
     'title' => t('Set Default'),
     'callback' => 'drupal_get_form',
     'callback arguments' => array('accounttypes_default'),
     'access' => user_access('administer accounttypes'),
     'type' => MENU_CALLBACK,
   );
   
   $items[] = array( //assign roles to account types
     'path' => 'admin/user/accounttypes/admin',
     'title' => t('Assign Roles'),
     'callback' => 'drupal_get_form',
     'callback arguments' => array('accounttypes_admin'),
     'access' => user_access('administer accounttypes'),
     'type' => MENU_LOCAL_TASK,
   );
   
   $items[] = array( //assign existing users to the default role if they don't have a role
     'path' => 'admin/user/accounttypes/assign_old_users',
     'title' => t('Manage Old Users'),
     'callback' => 'drupal_get_form',
     'callback arguments' => array('accounttypes_assign_old'),
     'access' => user_access('administer accounttypes'),
     'type' => MENU_LOCAL_TASK,
     'weight' => 10,
   );
  }

  return $items;
} // function accounttypes_menu()

  //-------------------------------setup the account type settings--------------------

/**
 * Callback function: Set the default account type for new users.
 * 
 * @return mixed
 */
function accounttypes_default($id = NULL) {
  if ($id == NULL) {
    $id = 1;
  }
  $acctype = get_accounttypes($id);
  $form['name'] = array(
    '#type' => 'textfield',
    '#title' => t('Account type name'),
    '#default_value' => $acctype[$id],
    '#disabled' => TRUE,
    '#description' => t('Are you sure you want to set this as the default <em>account type</em>?'),
  );
  $form['atid'] = array(
    '#type' => 'value',
    '#value' => $id,
  );
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Make default'),
  );
  return $form;
} //function accounttypes_default()

/**
 * Validate the account type ID before saving as default
 * 
 * @param string $form_id
 * @param mixed $form_values
 */
function accounttypes_default_validate($form_id, $form_values) {
  if ($form_values['atid']) { 
    if ($form_values['op'] == t('Make default')) {
      if (!db_result(db_query("SELECT * FROM {accounttypes} WHERE atid = %d", $form_values['atid']))) {
        form_set_error('atid', t('The account type id %atid does not exist. Please choose another account type id.', array('%atid' => $form_values['atid'])));
      }
    }
  }
  else {
    form_set_error('atid', t('Please choose a valid account type id.'));  
  }
} //function accounttypes_default_validate()

/**
 * Submit the account type to be set as default.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function accounttypes_default_submit($form_id, $form_values) {  
  if ($form_values['op'] == t('Make default')) {
    variable_set('accounttypes_default', $form_values['atid']);
  }
  drupal_set_message(t('Default account type set.'));
  
  return 'admin/user/accounttypes';
} //function accounttypes_default_submit()

/**
 * Callback function: Assign existing users to the default account type if they don't have a account type.
 * 
 * @return mixed
 */
function accounttypes_assign_old() {
  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Set users to default account type'),
    '#description' => t('Are you sure you want to set all existing users without account types to the default account type?'),
  );
  return $form;
} //function accounttypes_assign_old()

/**
 * Submit the account type to be set as default.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function accounttypes_assign_old_submit($form_id, $form_values) {
  $error = 0;  
  $results = db_query('SELECT uid FROM {users} ORDER BY uid');
  while ($result = db_fetch_object($results)) {
    $all_users[$result->uid] = $result->uid;
  }
  foreach ($all_users as $user => $uid) {
    if (!_accounttypes_user_exists($uid)) {
      $result1 = db_query("INSERT INTO {accounttypes_users} VALUES (%d, %d)", $uid, variable_get('accounttypes_default', STD_ACCOUNT_TYPE));
      if (!$result1) {
        $error = 1;
      }
    }
  }
  if ($error == 1) {
    drupal_set_message(t('Error setting one or more users to the default account type.'), 'error');
  }
  else {
    drupal_set_message(t('All existing users had their account type set to the current default.'));
  }
  
  return 'admin/user/accounttypes';
} //function accounttypes_assign_old_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 $id 
 *   The ID of the account type.
 * @return mixed
 */
function accounttypes_edit($id = NULL) {
  
  if ($admin = user_access('administer accounttypes')) {
    if ($id) {
      // Display the edit account type form.
      $result = db_query('SELECT * FROM {accounttypes} WHERE atid = %d', $id);
      $acctype = db_fetch_object($result);
      $form['name'] = array(
        '#type' => 'textfield',
        '#title' => t('Account type name'),
        '#default_value' => $acctype->name,
        '#size' => 20,
        '#required' => TRUE,
        '#maxlength' => 64,
        '#description' => t('The name for this account type. Example: "basic", "premium", "dev group", "management".'),
      );
      $form['atid'] = array(
        '#type' => 'value',
        '#value' => $id,
      );
      $form['submit'] = array(
        '#type' => 'submit',
        '#value' => t('Save account type'),
      );
      $form['delete'] = array(
        '#type' => 'submit',
        '#value' => t('Delete account type'),
      );
    }
    else {
      $form['name'] = array(
        '#type' => 'textfield',
        '#size' => 20,
        '#maxlength' => 64,
      );
      $form['submit'] = array(
        '#type' => 'submit',
        '#value' => t('Add account type'),
      );
      $form['#base'] = 'accounttypes_edit';
    }
    return $form;
  }
} //function accounttype_admin()

/**
 * Validate the account type name before adding or saving it
 * 
 * @param string $form_id
 * @param mixed $form_values
 */
function accounttypes_edit_validate($form_id, $form_values) {
  if ($form_values['name']) {
    if ($form_values['op'] == t('Save account type')) {
      if (db_result(db_query("SELECT COUNT(*) FROM {accounttypes} WHERE name = '%s' AND atid != %d", $form_values['name'], $form_values['atid']))) {
        form_set_error('name', t('The account type name %name already exists. Please choose another account type name.', array('%name' => $form_values['name'])));
      }
    }
    else if ($form_values['op'] == t('Add account type')) {
      if (db_result(db_query("SELECT COUNT(*) FROM {accounttypes} WHERE name = '%s'", $form_values['name']))) {
        form_set_error('name', t('The account type name %name already exists. Please choose another account type name.', array('%name' => $form_values['name'])));
      }
    }
  }
  else {
    form_set_error('name', t('You must specify a valid account type name.'));
  }
}//function accounttypes_edit_validate()

/**
 * Submit the account type name to be saved, deleted, or added to the database.
 *  
 * @param string $form_id
 * @param mixed $form_values
 * @return string
 */
function accounttypes_edit_submit($form_id, $form_values) {
  if ($form_values['op'] == t('Save account type')) {
    if (db_query("UPDATE {accounttypes} SET name = '%s' WHERE atid = %d", $form_values['name'], $form_values['atid'])) {
      drupal_set_message(t('The account type has been renamed.'));
    }
    else {
      drupal_set_message(t('The account type has NOT been renamed.'), 'error');
    }
  }
  else if ($form_values['op'] == t('Delete account type')) {
    if ($form_values['atid'] != STD_ACCOUNT_TYPE) {
      $default_acctype = variable_get('accounttypes_default', STD_ACCOUNT_TYPE);
      if ($form_values['atid'] == $default_acctype) {
        variable_set('accounttypes_default', STD_ACCOUNT_TYPE);
        $default_acctype = STD_ACCOUNT_TYPE;        
      }
      //grab the user ids that need to be changed and update them to the default account type (roles included)
      $result = db_query("SELECT uid FROM {accounttypes_users} WHERE atid = %d", $form_values['atid']);
      while ($uids = db_fetch_object($result)) {
        $account = user_load(array('uid' => (int)$uids->uid));
        if ($account !== FALSE) {
          $account->selectAT = $default_acctype;
          user_save($account, array('selectAT' => $default_acctype));
        }
      }
      db_query("UPDATE {accounttypes_users} SET atid = %d WHERE atid = %d", $default_acctype, $form_values['atid']);
      db_query("DELETE FROM {accounttypes} WHERE atid = %d", $form_values['atid']);
      db_query("DELETE FROM {accounttypes_roles} WHERE atid = %d", $form_values['atid']);
      drupal_set_message(t('The account type has been deleted.'));
    }
    else {
      drupal_set_message(t('You cannot delete the account type with ID = 1. Change its name and role assignments instead.'), 'error');
    }
  }
  else if ($form_values['op'] == t('Add account type')) {
    db_query("INSERT INTO {accounttypes} (name) VALUES ('%s')", $form_values['name']);
    drupal_set_message(t('The account type has been added.'));
  }
  return 'admin/user/accounttypes';
} //function accounttypes_edit_submit()

/**
 * Theme for the add page of the edit function.
 * 
 * <p>This lists all of the current account types with links to edit them or their assigned roles, followed with 
 * a field and button to add a new account type name to the list.</p>
 * @param mixed $form
 * @return mixed
 */
function theme_accounttypes_new_edit($form) {
  $default = variable_get('accounttypes_default', STD_ACCOUNT_TYPE);
  $header = array(t('Name'), array('data' => t('Operations'), 'colspan' => 3));
  foreach (get_accounttypes() as $atid => $name) {
    if ($atid == $default) {
      $name .= ' <em>(default)</em>';
    }
    $edit_roles = l(t('edit roles'), 'admin/user/accounttypes/admin/' .$atid);
    $edit_account_type = l(t('edit account type'), 'admin/user/accounttypes/edit/' .$atid);
    $set_default = l(t('set as default'), 'admin/user/accounttypes/default/' .$atid);
    $rows[] = array($name, $edit_account_type, $edit_roles, $set_default);
  }
  $rows[] = array(drupal_render($form['name']), array('data' => drupal_render($form['submit']), colspan => 3));

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

  return $output;
} //function theme_accounttypes_new_edit()

/**
 * Register a callback for a certain flavor of the edit page.
 * 
 * maybe there's a better way to do this?
 * @return mixed
 */
function accounttypes_forms() {
  $forms['accounttypes_new_edit']['callback'] = 'accounttypes_edit';
  return $forms;
} //function accounttypes_forms()

/**
 * Retrieve an array of account types matching specified conditions.
 *
 * If no value is given the function, the entire list of account types will be returned, otherwise
 * the account type matching the value will be returned.
 * @param string $atid
 *   A string containing a accounttype ID. If set, only that account type is returned.
 * @return
 *   An associative array with the account type id as the key and the account type name as value.
 */
function get_accounttypes($atid = 0) {
  $accounttypes = array();
  if ($atid != 0) {
    $result = db_query('SELECT * FROM {accounttypes} WHERE atid = %d ORDER BY name', $atid);
  }
  else {
    $result = db_query('SELECT * FROM {accounttypes} ORDER BY name');  
  }
  
  while ($acctype = db_fetch_object($result)) {
    $accounttypes[$acctype->atid] = $acctype->name;
  }
  return $accounttypes;
} //function get_accounttypes()

/**
 * Callback function: Assign roles to account types.
 * 
 * @param int $atid
 * @return mixed
 */
function accounttypes_admin($atid = NULL) {
  if (is_numeric($atid)) {
    $result1 = db_query('SELECT ar.atid, ar.initial, r.name, r.rid FROM {accounttypes_roles} ar LEFT JOIN {role} r ON ar.rid = r.rid WHERE ar.atid = %d', $atid);
  }
  else {
    $result1 = db_query('SELECT ar.atid, ar.initial, r.name, r.rid FROM {accounttypes_roles} ar LEFT JOIN {role} r ON ar.rid = r.rid ORDER BY name');
  }

  // Compile account type array:
  while ($acctype = db_fetch_object($result1)) {
    $acctype_roles[$acctype->atid][$acctype->name] = $acctype->rid;
    $acctype_roles_initial[$acctype->atid][$acctype->name] = $acctype->initial;
  }

  if (is_numeric($atid)) {
    $result2 = db_query('SELECT a.atid, a.name FROM {accounttypes} a WHERE a.atid = %d ORDER BY name', $atid);
  }
  else {
    $result2 = db_query('SELECT a.atid, a.name FROM {accounttypes} a ORDER BY name');
  }
  
  $acctype_names = array();
  while ($acctype2 = db_fetch_object($result2)) {
    $acctype_names[$acctype2->atid] = $acctype2->name;
  }
  
  // Get roles:
  $roles = db_query('SELECT r.name, r.rid FROM {role} r ORDER BY name');

  // Render accounttype/role overview:
  $options = array();
  while ($role = db_fetch_object($roles)) {
    if ($role->name == 'anonymous user') {
      continue;
    }
    $options[$role->name] = '';
    $form['roles'][$role->name] = array('#value' => t($role->name));//store a translated version of the role name
    foreach ($acctype_names as $atid2 => $name) {
      // Builds arrays for checked boxes for each account type
      if (is_array($acctype_roles[$atid2]) && array_key_exists($role->name, $acctype_roles[$atid2])) {
        $status[$atid2][] = $role->name;
      }
      if (is_array($acctype_roles_initial[$atid2]) && array_key_exists($role->name, $acctype_roles_initial[$atid2]) && $acctype_roles_initial[$atid2][$role->name]) {
        $status_initial[$atid2][] = $role->name;
      }
    }
  }
  $form['checkboxes'] = array('#tree' => TRUE);
  $form['checkboxes2'] = array('#tree' => TRUE);
  // Have to build checkboxes here after checkbox arrays are built
  foreach ($acctype_names as $atid3 => $name2) {
    $form['checkboxes'][$atid3] = array('#type' => 'checkboxes', '#options' => $options, '#default_value' => $status[$atid3]);
    $form['checkboxes2'][$atid3] = array('#type' => 'checkboxes', '#options' => $options, '#default_value' => $status_initial[$atid3]);
    $form['acctype_names'][$atid3] = array('#value' => $name2, '#tree' => TRUE);
  }
  $form['instructions'] = array(
    '#type' => 'item',
    '#value' => t('There are two columns for each Account Type. The first, labeled <em>Allow</em>, is used to assign the role to the Account Type.
    The second, labeled <em>Init</em> designates that role as one that will automatically be assigned when the user first gets that Account Type.
    Although these roles will initially be assigned to the user, they can be removed at any time just as those roles not initially given.'),
  );
  $form['submit'] = array('#type' => 'submit', '#value' => t('Save role associations'));

  return $form;
} //function accounttypes_admin()

/**
 * Submit the account type/role associations for storage
 *  
 * @param string $form_id
 * @param mixed $form_values
 */
function accounttypes_admin_submit($form_id, $form_values) {
  $allresults = db_query('SELECT * FROM {accounttypes}');
  $allroles = db_query('SELECT * FROM {role}');
  while ($role = db_fetch_object($allroles)) {
    $allrole_ids[$role->name] = $role->rid;
  }
  while ($result = db_fetch_object($allresults)) {
    if (isset($form_values['checkboxes'][$result->atid])) {
      // Delete, so if we clear every checkbox we reset that role;
      // otherwise permissions are active and denied everywhere.
      db_query('DELETE FROM {accounttypes_roles} WHERE atid = %d', $result->atid);
      $form_values['checkboxes'][$result->atid] = array_filter($form_values['checkboxes'][$result->atid]);
      if (count($form_values['checkboxes'][$result->atid])) {
        foreach ($form_values['checkboxes'][$result->atid] as $accid => $role_name) {
          $role_id = $allrole_ids[$role_name];
          if (!empty($form_values['checkboxes2'][$result->atid][$accid])) {
            $initial = 1;
          }
          else {
            $initial = 0;
          }
          db_query("INSERT INTO {accounttypes_roles} (atid, rid, initial) VALUES (%d, %d, %d)", $result->atid, $role_id, $initial);
        }
      }
    }
  }

  drupal_set_message(t('The changes have been saved.'));

  // Clear the cached pages and menus:
  menu_rebuild();
} //function accounttypes_admin_submit()

/**
 * Theme function to display the account type/role association grid
 * 
 * @param $form The form for the table.
 * @return string An HTML string representing the table.
 */
function theme_accounttypes_admin($form) {
  foreach (element_children($form['roles']) as $key) {
    // Don't take form control structures
    if (is_array($form['roles'][$key])) {
      $row = array();
      $row[] = array('data' => drupal_render($form['roles'][$key]), 'class' => 'role');
      foreach (element_children($form['checkboxes']) as $atid) {
        if (is_array($form['checkboxes'][$atid])) {
          $row[] = array('data' => drupal_render($form['checkboxes'][$atid][$key]), 'align' => 'left', 'title' => t($key));
          $row[] = array('data' => drupal_render($form['checkboxes2'][$atid][$key]), 'align' => 'left', 'title' => t($key));
        }
      }
      $rows[] = $row;
    }
  }
  $header[] = ('&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp\\'. t('Account Types'). '<br />' .t('Roles'). '&nbsp\\');
  foreach (element_children($form['acctype_names']) as $atid) {
    if (is_array($form['acctype_names'][$atid])) {
      $name = drupal_render($form['acctype_names'][$atid]);
      $header[] = array('data' => $name. '<br />Allow');
      $header[] = array('data' => $name. '<br />Init');
    }
  }
  $output = drupal_render($form['instructions']);
  $output .= theme('table', $header, $rows, array('id' => 'roles'));
  $output .= drupal_render($form);
  return $output;
} //function theme_accounttypes_admin()

/**
 * Alter user edit for account type stuff.
 * 
 * <p>Alter the user edit form to show the account type radio selection before the roles.
 *  Also, restrict which roles are shown based on account type selected.</p>
 * 
 * @param string $form_id the string identifying the form to be modified
 * @param mixed &$form the form to modify
 */
function accounttypes_form_alter($form_id, &$form) {
  
  //common variable setup
  $administer = user_access('administer accounttypes');
  $assign = user_access('assign accounttypes');
  $admin_user = user_access('administer access control');
  
  $allacctypes = get_accounttypes();
  $allroles = user_roles(1);
  foreach ($allroles as $key => $value) {
    $allroles[$key] = $key;
  }
  $na_accroles = array();
  $accroles = array();
  $accids = array();
  //copy list to a temporary array to be manipulated for each account type(array2)
  foreach ($allacctypes as $accid => $accname) {
    $accids[$accid] = $accid;
    $na_accroles[$accid] = $allroles;
    $result = db_query('SELECT r.name, r.rid, ar.initial FROM {accounttypes_roles} ar LEFT JOIN {role} r ON ar.rid = r.rid WHERE ar.atid = %d', $accid);
    while ($theentry = db_fetch_object($result)) {
      $accroles[$accid][$theentry->rid] = $theentry->rid;//build the list of all roles assigned to this account type
      $accinitial[$accid][$theentry->rid] = $theentry->initial;
      unset($na_accroles[$accid][$theentry->rid]);//remove roles that are assigned to this account type, leaving those that are not
    }
  }

  if (($uid = arg(1)) && is_numeric(arg(1))) {
    if (!$defaultval = db_result(db_query('SELECT atid FROM {accounttypes_users} WHERE uid = %d', arg(1)))) {
      $defaultval = variable_get('accounttypes_default', STD_ACCOUNT_TYPE);
    }
  }
  else {
    $defaultval = variable_get('accounttypes_default', STD_ACCOUNT_TYPE);
  }
  
  //make sure this only shows on one edit page
  if (isset($form['_category'])) {
    if ($form['_category']['#value'] == 'account') {
      $one_page = 1;
    }
    else {
      $one_page = 0;
    }
  }
  else {
    $one_page = 1;
  }
  
  //user edit and user add - admin perspective
  if (($form_id == 'user_edit' || $form_id == 'user_register') && ($administer || $assign || $admin_user) && ($one_page == 1)) {
    
    $formid = ($form_id == 'user_edit') ? 'user-edit' : 'user-register';
    $form['account']['selectAT'] = array(
      '#type' => 'radios',
      '#title' => t('Account types'),
      '#default_value' => $defaultval,
      '#description' => t('Account types limit the roles that can be assigned to a user. Invalid roles will be unchecked upon changing this. Changes are not saved until you do so below.'),
      '#weight' => 1,
    ); 
    
    foreach ($allacctypes as $accid => $accname) {
      $form['account']['selectAT']['#options'][$accid] = $accname;
    }
    
    $form['account']['roles']['#weight'] = 2;
    $form['account']['roles']['#description'] .= ' This list is restricted by the <em>Account Type</em> selected above.';
    //TODO add list to end of checkbox description of acctypes that can activate it such as: babysitter(basic, music, turtle)
    
    $output = '';
    foreach ($accids as $atid) {//build the options for the javascript population of account type roles to be used as each is selected in turn
      $temp_na_accroles = $na_accroles;
      foreach ($accids as $b) {
        if ($atid != $b) {
          unset($temp_na_accroles[$b]);
        }
      }
      
      $temp_accroles = $accroles;
      foreach ($accids as $b) {
        if ($atid != $b) {
          unset($temp_accroles[$b]);
        }
      }
      
      $temp_accinit = $accinitial;
      foreach ($accids as $b) {
        if ($atid != $b) {
          unset($temp_accinit[$b]);
        }
        foreach ($temp_accinit as $id => $the_rest) {
          foreach ($the_rest as $key => $value) {
            if ($value == 1) {
              $temp_accinit[$id][$key] = $key;
            }
          }
          $temp_accinit[$id] = array_filter($temp_accinit[$id]);
        }
      }
    $output .= '
        function radioclick' .$atid. '() {
          var nor = ' .drupal_to_js($temp_na_accroles). ';
          var yesr = ' .drupal_to_js($temp_accroles). ';
          var initr = ' .drupal_to_js($temp_accinit). ';
          for (var y in nor[' .$atid. ']) {
            $("#' .$formid. ' :checkbox[@id=edit-roles-"+ y +"]").removeAttr("checked");
            $("#' .$formid. ' :checkbox[@id=edit-roles-"+ y +"]").attr("disabled", "disabled");
          }
          for (var b in yesr[' .$atid. ']) {
            $("#' .$formid. ' :checkbox[@id=edit-roles-"+ b +"]").removeAttr("disabled");
          }
          for (var za in initr[' .$atid. ']) {
            $("#' .$formid. ' :checkbox[@id=edit-roles-"+ za +"]").attr("checked", "checked");
          }
        }';
    }
    
    $output .= '
        $(document).ready(function() {
          radioclick' .$defaultval. '();';

      foreach ($accids as $atid) {
        $output .= '$("#' .$formid. ' :radio[@name=selectAT][@value=' .$atid. ']").click(function(){radioclick' .$atid. '();});';
      }
    
    $output .= '});';
    
    drupal_add_js($output, 'inline');
  }
  elseif ($form_id == 'user_register') { //user registration form - user perspective
    $form['account']['selectAT'] = array(
      '#type' => 'hidden',
      '#value' => $defaultval,
    );
  }
  elseif ($form_id == 'user_edit') { //user edit form - user perspective
    if (isset($form['_account']['selectAT'])) { //if they have an accounttype, use it (should be loaded from hook_user)
      $current_accounttype = $form['_account']['selectAT'];
    }
    else { // otherwise, use the default
      $current_accounttype = $defaultval;
    }
    $form['account']['selectAT'] = array(
      '#type' => 'hidden',
      '#value' => $current_accounttype,
    );
  }
  
  //the admin user filter form - had to duplicate the code from user module to get this to work without changing core
  if (($form_id == 'user_filter_form') && ($administer || $assign || $admin_user)) {
    $session = &$_SESSION['user_overview_filter2'];
    $session = is_array($session) ? $session : array();
    $filters = user_filters();
    $filters['acctype'] = array('title' => t('accnt type'),
      'join' => "LEFT JOIN {accounttypes_users} au ON u.uid = au.uid",
      'where' => "au.atid = %d",
      'options' => get_accounttypes(),
    );
    
    $i = 0;
    $form['filters'] = array('#type' => 'fieldset',
      '#title' => t('Show only users where'),
      '#theme' => 'user_filters',
    );
    foreach ($session as $filter) {
      list($type, $value) = $filter;
      $string = ($i++ ? '<em>and</em> where <strong>%a</strong> is <strong>%b</strong>' : '<strong>%a</strong> is <strong>%b</strong>');
      // Merge an array of arrays into one if necessary.
      $options = $type == 'permission' ? call_user_func_array('array_merge', $filters[$type]['options']) : $filters[$type]['options'];
      //unset($form['filters']['current']);
      $form['filters']['current'][] = array('#value' => t($string, array('%a' => $filters[$type]['title'] , '%b' => $options[$value])));
    }
  
    foreach ($filters as $key => $filter) {
      $names[$key] = $filter['title'];
      $form['filters']['status'][$key] = array('#type' => 'select',
        '#options' => $filter['options'],
      );
    }

    $form['filters']['filter'] = array('#type' => 'radios',
      '#options' => $names,
    );
    $form['filters']['buttons']['submit'] = array('#type' => 'submit',
      '#value' => (count($session) ? t('Refine') : t('Filter'))
    );
    if (count($session)) {
      $form['filters']['buttons']['undo'] = array('#type' => 'submit',
        '#value' => t('Undo')
      );
      $form['filters']['buttons']['reset'] = array('#type' => 'submit',
        '#value' => t('Reset')
      );
    }
  
    unset($form['#submit']);
    $form['#submit']['accounttypes_user_filter_form_submit'] = array($form);
  }
  
  // the display of the users
  if (($form_id == 'user_admin_account') && ($administer || $assign || $admin_user)) {
    $filter = accounttypes_user_build_filter_query();

    //TODO make the account type column sortable
    $header = array(
      array(),
      array('data' => t('Username'), 'field' => 'u.name'),
      array('data' => t('Status'), 'field' => 'u.status'),
      t('Account type'),
      t('Roles'),
      array('data' => t('Member for'), 'field' => 'u.created', 'sort' => 'desc'),
      array('data' => t('Last access'), 'field' => 'u.access'),
      t('Operations')
    );
  
    $sql = 'SELECT DISTINCT u.uid, u.name, u.status, u.created, u.access FROM {users} u LEFT JOIN {users_roles} ur ON u.uid = ur.uid  ' .$filter['join']. ' WHERE u.uid != 0 ' .$filter['where'];
    $sql .= tablesort_sql($header);
    $result = pager_query($sql, 50, 0, NULL, $filter['args']);
  
    $form['options'] = array(
      '#type' => 'fieldset',
      '#title' => t('Update options'),
      '#prefix' => '<div class="container-inline">',
      '#suffix' => '</div>',
    );
    $options = array();
    foreach (module_invoke_all('user_operations') as $operation => $array) {
      $options[$operation] = $array['label'];
    }
    $form['options']['operation'] = array(
      '#type' => 'select',
      '#options' => $options,
      '#default_value' => 'unblock',
    );
    $form['options']['submit'] = array(
      '#type' => 'submit',
      '#value' => t('Update'),
    );
    unset($form['#validate']);
    unset($form['#submit']);
    unset($form['#theme']);
    $form['#validate']['accounttypes_user_admin_account_validate'] = array($form_id, $form_values, $form);
    $form['#submit']['accounttypes_user_admin_account_submit'] = array($form_id, $form_values, $form);
    $form['#theme'] = 'accounttypes_user_admin_account';
  
    $destination = drupal_get_destination();
  
    $status = array(t('blocked'), t('active'));
    $roles = user_roles(1);
  
    unset($form['name']);
    unset($form['status']);
    unset($form['theacctype']);
    unset($form['roles']);
    unset($form['member_for']);
    unset($form['last_access']);
    unset($form['operations']);
    
    while ($account = db_fetch_object($result)) {
      $accounts[$account->uid] = '';
      $form['name'][$account->uid] = array('#value' => theme('username', $account));
      $form['status'][$account->uid] =  array('#value' => $status[$account->status]);
      
      $user_acctype = db_fetch_object(db_query('SELECT atid FROM {accounttypes_users} WHERE uid = %d', $account->uid));
        if (!$user_acctype) {
          $form['theacctype'][$account->uid] =  array('#value' => 'none');
        }
        else {
          $acctype_result = db_fetch_object(db_query('SELECT name FROM {accounttypes} WHERE atid = %d', $user_acctype->atid));
          $form['theacctype'][$account->uid] =  array('#value' => $acctype_result->name);
        }
        
      $users_roles = array();
      $roles_result = db_query('SELECT rid FROM {users_roles} WHERE uid = %d', $account->uid);
      while ($user_role = db_fetch_object($roles_result)) {
        $users_roles[] = $roles[$user_role->rid];
      }
      asort($users_roles);
      $form['roles'][$account->uid][0] = array('#value' => theme('item_list', $users_roles));
      $form['member_for'][$account->uid] = array('#value' => format_interval(time() - $account->created));
      $form['last_access'][$account->uid] =  array('#value' => $account->access ? t('@time ago', array('@time' => format_interval(time() - $account->access))) : t('never'));
      $form['operations'][$account->uid] = array('#value' => l(t('edit'), "user/$account->uid/edit", array(), $destination));
    }
    $form['accounts'] = array(
      '#type' => 'checkboxes',
      '#options' => $accounts
    );
    $form['pager'] = array('#value' => theme('pager', NULL, 50, 0));
  }
} //function accounttypes_form_alter()

  //-------------------------------multiple user settings--------------------

/**
 * Theme user administration overview.
 * 
 * @param mixed $form
 * @return string An HTML string representing the table.
 */
function theme_accounttypes_user_admin_account($form) {
  // Overview table:
  $header = array(
    theme('table_select_header_cell'),
    array('data' => t('Username'), 'field' => 'u.name'),
    array('data' => t('Status'), 'field' => 'u.status'),
    t('Account type'),
    t('Roles'),
    array('data' => t('Member for'), 'field' => 'u.created', 'sort' => 'desc'),
    array('data' => t('Last access'), 'field' => 'u.access'),
    t('Operations')
  );

  $output = drupal_render($form['options']);
  if (isset($form['name']) && is_array($form['name'])) {
    foreach (element_children($form['name']) as $key) {
      $rows[] = array(
        drupal_render($form['accounts'][$key]),
        drupal_render($form['name'][$key]),
        drupal_render($form['status'][$key]),
        drupal_render($form['theacctype'][$key]),
        drupal_render($form['roles'][$key]),
        drupal_render($form['member_for'][$key]),
        drupal_render($form['last_access'][$key]),
        drupal_render($form['operations'][$key]),
      );
    }
  }
  else  {
    $rows[] = array(array('data' => t('No users available.'), 'colspan' => '7'));
  }

  $output .= theme('table', $header, $rows);
  if ($form['pager']['#value']) {
    $output .= drupal_render($form['pager']);
  }

  $output .= drupal_render($form);

  return $output;
} //function theme_accounttypes_user_admin_account()

/**
 * Submit the user administration update form.
 * 
 * copied from user.module
 * @param string $form_id
 * @param mixed $form_values
 * @param mixed $form
 */
function accounttypes_user_admin_account_submit($form_id, $form_values, $form) {
  $operations = module_invoke_all('user_operations');
  $operation = $operations[$form_values['operation']];
  // Filter out unchecked accounts.
  $accounts = array_filter($form_values['accounts']);
  if ($function = $operation['callback']) {
    // Add in callback arguments if present.
    if (isset($operation['callback arguments'])) {
      $args = array_merge(array($accounts), $operation['callback arguments']);
    }
    else {
      $args = array($accounts);
    }
    call_user_func_array($function, $args);

    cache_clear_all('*', 'cache_menu', TRUE);
    drupal_set_message(t('The update has been performed.'));
  }
} //function accounttypes_user_admin_account_submit()

/**
 * Validate the user administration update form.
 * 
 * copied from user.module
 * @param string $form_id
 * @param mixed $form_values
 * @param mixed $form
 */
function accounttypes_user_admin_account_validate($form_id, $form_values, $form) {
  
  $form_values['accounts'] = array_filter($form_values['accounts']);
  if (count($form_values['accounts']) == 0) {
    form_set_error('', t('No users selected.'));
    return;
  }
   
  //Get the checked users, and the operation name.
  $uids = array_filter($form_values['accounts']);
  $operation_rid = explode('-', $form_values['operation']);
  $operation = $operation_rid[0];
  $oprid = $operation_rid[1];
  
  //perform the check for each submitted user
  foreach ($uids as $uid) {
    $account = user_load(array('uid' => $uid));
    
    switch ($operation) {
      case 'add_role':
      case 'remove_role':
      case 'roleassign_add_role':
      case 'roleassign_remove_role':  
        if (!accounttypes_check_role_restriction($account->selectAT, $oprid) || ($uid == 1)) {
          form_set_value($form['accounts'][$uid], 0);
          drupal_set_message(t('%user has an <em>account type</em> which is incompatible with the selected <em>role</em> and was not updated.', array('%user' => $account->name)), 'error');
          unset($uids[$uid]);
          if($account->selectAT == 0) {
            drupal_set_message(t('%user has not been given a valid <em>account type</em>. Please edit their account to fix this issue.', array('%user' => $account->name)), 'error');
          }
        }
        break;
    }
  }
  
  if (!count($uids)) {
    drupal_set_message('No valid users were selected for that change. Their <em>account type</em> prevents them from receiving that <em>role</em>. Please try again.', 'error');
    drupal_goto('admin/user/user');
  }
} //function accounttypes_user_admin_account_validate()

/**
 * Check if the selected role is able to be applied to the selected user
 *
 * @param array $account The user's account information.
 * @rid integer $rid A role ID.
 * @return object $result A database object.
 */
function accounttypes_check_role_restriction($account, $rid) {
  return $result = (int)db_result(db_query('SELECT COUNT(*) FROM {accounttypes_roles} WHERE rid = %d AND atid = %d', $rid, $account));
} //function accounttypes_check_role_restriction()

/**
 * Implementation of hook_user_operations
 * 
 * Change the account type of multiple users at once. Set callback for function that
 * will do the work.
 * @return ??? I don't remember.
 */
function accounttypes_user_operations() {
  global $form_values;
  
  if (user_access('administer accounttypes') || user_access('assign accounttypes')) {
    $allacctypes = get_accounttypes();
    
    $change_acctypes = array();
    foreach ($allacctypes as $key => $value) {
      $change_acctypes['change_account_type-' .$key] = $value;
    }

    if (count($allacctypes)) {
      $acctype_operations = array(
        t('Change the account type of the selected users') => array(
          'label' => $change_acctypes,
        ),
      );

      $operations = $acctype_operations;
    }
  }
  
  // If the form has been posted, we need to insert the proper data for role editing if necessary.
  if ($form_values) {
    $operation_atid = explode('-', $form_values['operation']);
    $operation = $operation_atid[0];
    $atid = $operation_atid[1];
    if ($operation == 'change_account_type') {
      if (user_access('administer accounttypes') || user_access('assign accounttypes')) {
        $operations[$form_values['operation']] = array(
          'callback' => 'accounttypes_multiple_accounttype_change',
          'callback arguments' => array($operation, $atid),
        );
      }
      else {
        watchdog('security', t('Detected malicious attempt to alter protected user fields.'), WATCHDOG_WARNING);
        return;
      }
    }
  }
  
  return $operations;
} //function accounttypes_user_operations()

/**
 * Deal with changing multiple users' account type.
 * 
 * Check existing role assignments and remove those incompatible with the new account type
 * from the users_roles table. Alert the admin that some roles were changed.
 * 
 * @param array $accounts The accounts to work on.
 * @param string $operation The operation to perform.
 * @param integer $atid The ID of the account type to use in the operation.
 */
function accounttypes_multiple_accounttype_change($accounts, $operation, $atid) {
  foreach ($accounts as $uid) {
    $account = user_load(array('uid' => (int)$uid));
    // Skip changing the account type if they already have it.
    if ($account !== FALSE && ($account->selectAT != $atid) && ($account->uid != 1)) {
      user_save($account, array('selectAT' => $atid));
    }
  }
} //function accounttypes_multiple_accounttype_change()

/**
 * Build query for user administration filters based on session.
 * copied from user.module and modified
 * 
 * @return array A SQL query's WHERE and JOIN clauses and the args to go with them
 * in an associative array.
 */
function accounttypes_user_build_filter_query() {
  $filters = user_filters();
  $filters['acctype'] = array('title' => t('accnt type'),
    'join' => 'LEFT JOIN {accounttypes_users} au ON u.uid = au.uid',
    'where' => 'au.atid = %d',
    'options' => get_accounttypes(),
  );

  // Build query
  $where = $args = $join = array();
  foreach ($_SESSION['user_overview_filter2'] as $filter) {
    list($key, $value) = $filter;
    // This checks to see if this permission filter is an enabled permission for the authenticated role.
    // If so, then all users would be listed, and we can skip adding it to the filter query.
    if ($key == 'permission') {
      $account = new stdClass();
      $account->uid = 'user_filter';
      $account->roles = array(DRUPAL_AUTHENTICATED_RID => 1);
      if (user_access($value, $account)) {
        continue;
      }
    }
    $where[] = $filters[$key]['where'<