";
		//		print_r(debug_backtrace());
		return false;
	}

	$ret = $q->fetch(PDO::FETCH_ASSOC);

	/*
	 * Make sure they're not deleted, we don't want to do this in the query, because loading by $uid would
	 * simply return the previous year (where deleted=no)
	 */
	if ($ret['deleted'] != 'no') {
		/* User is deleted */
		return false;
	}

	/* Do we need to do number conversions? */
	$ret['id'] = intval($ret['id']);
	$ret['uid'] = intval($ret['uid']);
	$ret['year'] = intval($ret['year']);

	/* Turn the type into an array, because there could be more than one */
	$ts = explode(',', $ret['types']);
	$ret['types'] = $ts;  /* Now we can use in_array('judge', $ret['types']) ; */

	/* Convenience */
	$ret['name'] = $ret['firstname'] . ' ' . $ret['lastname'];

	foreach ($ret['types'] as $t) {
		/*
		 * These all pass $ret by reference, and can modify
		 * $ret
		 */
		$r = call_user_func("db146_user_load_$t", $ret);
		if ($r != true) {
			echo "db146_user_load_$t returned false!\n";
			return false;
		}

		/* It is important that each type database doesn't
		have conflicting column names */

		/*
		 * foreach($r as $k=>$v) {
		 * 			if(array_key_exists($k, $ret)) {
		 * 				echo "DATABASE DESIGN ERROR, duplicate user key $k";
		 * 				exit;
		 * 			}
		 * 		}
		 * 		$ret = array_merge($ret, $r);
		 */
	}

	/* Do this assignment without recursion :) */
	unset($ret['orig']);
	$orig = $ret;
	$ret['orig'] = $orig;

	/*
	 * echo "
User load returning: \n";
	 * 	print_r($ret);
	 * 	echo "
";
	 */
	return $ret;
}

function db146_user_load_by_uid($uid)
{
	return db146_user_load(0, $uid);
}

function db146_user_load_by_email($email)
{
	/* Find the most recent uid for the email, regardless of deleted status */
	$e = $email;
	$q = $pdo->prepare("SELECT uid FROM users WHERE email=? OR username=? ORDER BY year DESC LIMIT 1");
	$q->execute([$e,$e]);

	if ($q->rowCount() == 1) {
		$i = $q->fetch(PDO::FETCH_ASSOC);
		return db146_user_load_by_uid($i['uid']);
	}
	return false;
}

function db146_user_load_by_uid_year($uid, $year)
{
	$q = $pdo->prepare("SELECT id FROM users WHERE uid=? AND year <=?");
	$q->execute([$uid,$year]);
	if (!$q->rowCount())
		return false;
	$i = $q->fetch(PDO::FETCH_ASSOC);
	return db146_user_load($i['id']);
}

function db146_user_set_password($id, $password = NULL)
{
	/* pass $u by reference so we can update it */
	$save_old = false;
	if ($password == NULL) {
		$q = $pdo->prepare("SELECT passwordset FROM users WHERE id=?");
		$q->execute([$id]);
		$u = $q->fetch(PDO::FETCH_ASSOC);
		/* Generate a new password */
		$password = db146_user_generate_password(12);
		/* save the old password only if it's not an auto-generated one */
		if ($u['passwordset'] != '0000-00-00')
			$save_old = true;
		/* Expire the password */
		$save_set = "'0000-00-00'";
	} else {
		/* Set the password, no expiry, save the old */
		$save_old = true;
		$save_set = 'NOW()';
	}

	$p = $password;
	$set = ($save_old == true) ? 'oldpassword=password, ' : '';
	$set .= "password='$p', passwordset=$save_set ";

	$query = "UPDATE users SET ? WHERE id=?";
	$stmt = $pdo->prepare($query);
	$stmt->execute([$set,$id]);
	show_pdo_errors_if_any($pdo);

	return $password;
}

function db146_user_save_type_list($u, $db, $fields)
{
	/*	echo "
 save type list $db";
		print_r($u);
		echo "
";*/
	$set = '';

	foreach ($fields as $f) {
		/* == even works on arrays in PHP */
		if ($u[$f] == $u['orig'][$f])
			continue;

		if ($set != '')
			$set .= ',';

		if ($u[$f] == NULL) {
			$set .= "$f=NULL";
			continue;
		}

		if (is_array($u[$f]))
			$data = serialize($u[$f]);
		else
			$data = stripslashes($u[$f]);

		$set .= "`$f`='$data'";
	}
	if ($set != '') {
		$query = "UPDATE ? SET ? WHERE users_id=?";
		$stmt = $pdo->prepare($query);
		$stmt->execute([$db,$set,$u['id']]);
		if ($pdo->errorInfo()) {
			show_pdo_errors_if_any($pdo);
			echo error("Full query: $query");
		}
	}
}

function db146_user_save_volunteer($u)
{
	$fields = array('volunteer_active', 'volunteer_complete');
	db146_user_save_type_list($u, 'users_volunteer', $fields);
}

function db146_user_save_committee($u)
{
	$fields = array('committee_active', 'emailprivate', 'ord', 'displayemail', 'access_admin',
		'access_config', 'access_super');
	db146_user_save_type_list($u, 'users_committee', $fields);
}

function db146_user_save_judge($u)
{
	$fields = array('judge_active', 'judge_complete', 'years_school', 'years_regional', 'years_national',
		'willing_chair', 'special_award_only',
		'cat_prefs', 'div_prefs', 'divsub_prefs',
		'expertise_other', 'languages', 'highest_psd');
	db146_user_save_type_list($u, 'users_judge', $fields);
}

function db146_user_save_student($u)
{
	//	$fields = array('student_active','student_complete');
	//	user_save_type_list($u, 'users_student', $fields);
}

function db146_user_save_fair($u)
{
	$fields = array('fair_active', 'fairs_id');
	db146_user_save_type_list($u, 'users_fair', $fields);
}

function db146_user_save_sponsor($u)
{
	$fields = array('sponsors_id', 'sponsor_active', 'sponsor_complete', 'primary', 'position', 'notes');
	db146_user_save_type_list($u, 'users_sponsor', $fields);
}

function db146_user_save_teacher($u) {}

function db146_user_save_principal($u) {}

function db146_user_save_mentor($u) {}

function db146_user_save_alumni($u) {}

function db146_user_save_parent($u) {}

function db146_user_save(&$u)
{
	/* Add any new types */
	$added = array_diff($u['types'], $u['orig']['types']);
	foreach ($added as $t) {
		if (!db146_user_add_role_allowed($t, $u)) {
			echo "HALT: user can't add this type";
			exit;
		}
		// give em a record, the primary key on the table takes care of uniqueness
		$q = $pdo->prepare("INSERT INTO users_? (users_id) VALUES (?)");
		$q->execute([$t,$u['id']]);
	}

	$fields = array('salutation', 'firstname', 'lastname', 'username',
		'email',
		'phonehome', 'phonework', 'phonecell', 'fax', 'organization',
		'address', 'address2', 'city', 'province', 'postalcode', 'sex',
		'firstaid', 'cpr', 'types');

	$set = '';
	foreach ($fields as $f) {
		if ($u[$f] == $u['orig'][$f])
			continue;

		if ($set != '')
			$set .= ',';

		if ($f == 'types')
			$set .= "$f='" . implode(',', $u[$f]) . "'";
		else {
			$data = stripslashes($u[$f]);
			$set .= "$f='$data'";
		}
	}
	//	echo "
";
	//	print_r($u);
	//	echo "
";
	if ($set != '') {
		$query = "UPDATE users SET ? WHERE id=?";
		$stmt = $pdo->prepare($query);
		$stmt->execute([$set,$u['id']]);
		//		echo "query=[$query]";
		show_pdo_errors_if_any($pdo);
	}

	/* Save the password if it changed */
	if ($u['password'] != $u['orig']['password'])
		db146_user_set_password($u['id'], $u['password']);

	/* Save types */
	foreach ($u['types'] as $t) {
		call_user_func("db146_user_save_$t", $u);
	}

	/* Should we do this? */
	/* Record all the data in orig that we saved */
	unset($u['orig']);
	$orig = $u;
	$u['orig'] = $orig;

	//	print_r($u);
}

/*
 * Delete functions. These mark a user as deleted, and delete references to other
 * tables
 */

function db146_user_delete_committee($u)
{
	$stmt = $pdo->prepare("DELETE FROM committees_link WHERE users_uid=?");
	$stmt->execute([$u['uid']]);
}

function db146_user_delete_volunteer($u) {}

function db146_user_delete_judge($u)
{
	global $config;
	$id = $u['id'];
	$stmt = $pdo->prepare("DELETE FROM judges_teams_link WHERE users_id=?");
	$stmt->execute([$id]);
	$stmt = $pdo->prepare("DELETE FROM judges_specialawards_sel WHERE users_id=?");
	$stmt->execute([$id]);
}

function db146_user_delete_fair($u) {}

function db146_user_delete_student($u) {}

function db146_user_delete_sponsor($u) {}

function db146_user_delete_principal($u) {}

function db146_user_delete_teacher($u) {}

function db146_user_delete_parent($u) {}

function db146_user_delete_mentor($u) {}

function db146_user_delete_alumni($u) {}

function db146_user_delete($u, $type = false)
{
	$finish_delete = false;

	if (!is_array($u)) {
		$u = db146_user_load($u);
	}
	if ($type != false) {
		if (!in_array($type, $u['types'])) {
			/*
			 * Hum, type specified, but the user is not this type,
			 * so, i guess we're done.
			 */
			return;
		}
		if (count($u['types']) > 1) {
			/* Don't delete the whole user */
			$types = '';
			foreach ($u['types'] as $t) {
				if ($t == $type)
					continue;
				if ($types != '')
					$types .= ',';
				$types .= $t;
			}
			$stmt = $pdo->prepare("UPDATE users SET types=? WHERE id=?");
			$stmt->execute([$types,$u['id']]);
		} else {
			$finish_delete = true;
		}
		call_user_func("db146_user_delete_$type", $u);
	} else {
		/* Delete the whole user */
		if (is_array($u['types'])) {
			foreach ($u['types'] as $t)
				call_user_func("db146_user_delete_$t", $u);
		}
		$finish_delete = true;
	}
	if ($finish_delete == true) {
		$stmt = $pdo->prepare("UPDATE users SET deleted='yes', deleteddatetime=NOW() WHERE id=?");
		$stmt->execute([$u['id']]);
	}
}

/*
 * Purge functions. These completely eliminate all traces of a user from the
 * database.  This action cannot be undone.  We prefer the committee to use the
 * "delete" functions, which simply mark the account as "deleted".
 */

function db146_user_purge($u, $type = false)
{
	$finish_purge = false;

	if (!is_array($u)) {
		$u = db146_user_load($u);
	}
	if ($type != false) {
		if (!in_array($type, $u['types'])) {
			/*
			 * Hum, type specified, but the user is not this type,
			 * so, i guess we're done.
			 */
			return;
		}
		if (count($u['types']) > 1) {
			/* Don't delete the whole user */
			$types = '';
			foreach ($u['types'] as $t) {
				if ($t == $type)
					continue;
				if ($types != '')
					$types .= ',';
				$types .= $t;
			}
			$stmt = $pdo->prepare("UPDATE users SET types=? WHERE id=?");
			$stmt->execute([$types,$u['id']]);
		} else {
			$finish_purge = true;
		}

		/*
		 * Call the delete func to deal with table linking, then completely wipe
		 * out the entry
		 */
		call_user_func("db146_user_delete_$type", $u);
		//		call_user_func("user_purge_$type", $u);
		$stmt = $pdo->prepare("DELETE FROM users_? WHERE users_id=?");
		$stmt->execute([$type,$u['id']]);
	} else {
		/* Delete the whole user */
		foreach ($u['types'] as $t) {
			call_user_func("db146_user_delete_$t", $u);
			//			call_user_func("user_purge_$t", $u);
			$stmt = $pdo->prepare("DELETE FROM users_? WHERE users_id=?");
			$stmt->execute([$t,$u['id']]);
		}
		$finish_purge = true;
	}
	if ($finish_purge == true) {
		$stmt = $pdo->prepare("DELETE FROM users WHERE id=?");
		$stmt->execute([$u['id']]);
	}
}

/* Duplicate a row in the users table, or any one of the users_* tables. */
function db146_user_dupe_row($db, $key, $val, $newval)
{
	global $config;
	$nullfields = array('deleteddatetime');  /* Fields that can be null */
	$q = $pdo->prepare("SELECT * FROM ? WHERE ?=?");
	$q->execute([$db,$key,$val]);
	if ($q->rowCount() != 1) {
		echo "ERROR duplicating row in $db: $key=$val NOT FOUND.\n";
		exit;
	}
	$i = $q->fetch(PDO::FETCH_ASSOC);
	$i[$key] = $newval;

	foreach ($i as $k => $v) {
		if ($v == NULL && in_array($k, $nullfields))
			$i[$k] = 'NULL';
		else if ($k == 'year')
			$i[$k] = $config['FAIRYEAR'];
		else
			$i[$k] = "'" . $v . "'";
	}

	$keys = '`' . join('`,`', array_keys($i)) . '`';
	$vals = join(',', array_values($i));

	$q = "INSERT INTO ? (?) VALUES (?)";
	//	echo "Dupe Query: [$q]";
	$r = $pdo->prepare($q);
	$r->execute([$db,$keys,$vals]);
	show_pdo_errors_if_any($pdo);

	$id = $pdo->lastInsertId();
	return $id;
}

/* Used by the login scripts to copy one user from one year to another */
function db146_user_dupe($u, $new_year)
{
	/*
	 * Dupe a user if:
	 * - They don't exist in the current year
	 * 	(users->year != the target year (passed in so we can use it in the rollover script) )
	 * - They have a previous year entry
	 * 	(users->year DESC LIMIT 1 == 1 row)
	 * - That previous entry has deleted=no
	 */

	/* Find the last entry */
	$q = $pdo->prepare("SELECT id,uid,year,deleted FROM users WHERE uid=?
				ORDER BY year DESC LIMIT 1");
	$q->execute([$u['uid']]);
	$r = $q->fetch(PDO::FETCH_OBJ);
	if ($r->deleted == 'yes') {
		echo "Cannot duplicate user ID {$u['id']}, they are deleted.  Undelete them first.\n";
		exit;
	}
	if ($r->year == $new_year) {
		echo "Cannot duplicate user ID {$u['id']}, they already exist in year $new_year\n";
		exit;
	}

	$id = db146_user_dupe_row('users', 'id', $u['id'], NULL);
	$q = $pdo->prepare("UPDATE users SET year=? WHERE id=?");

	$q->execute([$new_year,$id]);
	/* Load the new user */
	$u2 = db146_user_load($id);

	foreach ($u2['types'] as $t) {
		db146_user_dupe_row("users_$t", 'users_id', $u['id'], $id);
	}
	/* Return the ID of the new user */
	return $id;
}

/*
 * Returns true if loaded user ($u) is allowed to add role type $type to their
 * profile.  THis is intended as a last-stop mechanism, preventing, for example
 * a student from co-existing with any other account type.
 */
function db146_user_add_role_allowed($type, $u)
{
	/*
	 * For example, a committee member can add a volunteer or judge role to
	 * their account.
	 */
	$allowed = array(
		'committee' => array('volunteer', 'judge', 'sponsor', 'principal', 'teacher', 'parent', 'mentor', 'alumni'),
		'volunteer' => array('judge', 'committee', 'sponsor', 'principal', 'teacher', 'parent', 'mentor', 'alumni'),
		'judge' => array('volunteer', 'committee', 'sponsor', 'principal', 'teacher', 'parent', 'mentor', 'alumni'),
		'student' => array(),
		'fair' => array(),
		'sponsor' => array('volunteer', 'judge', 'sponsor', 'principal', 'teacher', 'parent', 'mentor', 'alumni'),
		'principal' => array('volunteer', 'judge', 'sponsor', 'committee', 'teacher', 'parent', 'mentor', 'alumni'),
		'teacher' => array('volunteer', 'judge', 'sponsor', 'principal', 'committee', 'parent', 'mentor', 'alumni'),
		'parent' => array('volunteer', 'judge', 'sponsor', 'principal', 'teacher', 'committee', 'mentor', 'alumni'),
		'mentor' => array('volunteer', 'judge', 'sponsor', 'principal', 'teacher', 'parent', 'committee', 'alumni'),
		'alumni' => array('volunteer', 'judge', 'sponsor', 'principal', 'teacher', 'parent', 'mentor', 'committee'),
	);

	foreach ($u['types'] as $ut) {
		$allowed_array = $allowed[$ut];
		if (in_array($type, $allowed[$ut]))
			return true;
	}
	return false;
}

function db146_user_create($type, $username, $u = NULL)
{
	global $config;
	if (!is_array($u)) {
		$stmt = $pdo->prepare("INSERT INTO users (`types`,`username`,`passwordset`,`created`,`year`) 
			VALUES (?,?,'0000-00-00', NOW(),?)");
		$stmt->execute([$type,$username,$config['FAIRYEAR']]);
		show_pdo_errors_if_any($pdo);
		$uid = $pdo->lastInsertId();
		if (db146_user_valid_email($username)) {
			$stmt = $pdo->prepare("UPDATE users SET email=? WHERE id=?");
			$stmt->execute([$username,$uid]);
		}

		$stmt = $pdo->prepare("UPDATE users SET uid=? WHERE id=?");
		$stmt->execute([$uid,$uid]);
		show_pdo_errors_if_any($pdo);
		db146_user_set_password($uid, NULL);

		/*
		 * Since the user already has a type, user_save won't create this
		 * entry for us, so do it here
		 */
		$stmt = $pdo->prepare("INSERT INTO users_? (users_id) VALUES(?)");
		$stmt->execute([$type,$uid]);
		show_pdo_errors_if_any($pdo);
		/* Load the complete user */
		$u = db146_user_load($uid);
	} else {
		/*
		 * The user has been specified and already exists,
		 * just add a role
		 */
		$uid = $u['uid'];
		if (!db146_user_add_role_allowed($type, $u)) {
			/* If we get in here, someone is hand crafting URLs */
			echo 'HALT: invalid role add specified for operation.';
			exit;
		}
		/* Ensure we have a full user, and add the type to the existing user */
		$u = db146_user_load_by_uid($uid);
		$u['types'][] = $type;
	}
	/* Activate the new type, and save, then return the user */
	$u["{$type}_active"] = 'yes';
	db146_user_save($u);
	return $u;
}

function db146_user_valid_user($user)
{
	/*
	 * Find any character that doesn't match the valid username characters
	 * (^ inverts the matching remember
	 */
	$x = preg_match('[^a-zA-Z0-9@.-_]', $user);

	/* If x==1, a match was found, and the input is bad */
	return ($x == 1) ? false : true;
}

function db146_user_valid_password($pass)
{
	/* Same as user, but allow more characters */
	$x = preg_match('[^a-zA-Z0-9 ~!@#$%^&*()-_=+|;:,<.>/?]', $pass);

	/* If x==1, a match was found, and the input is bad */
	if ($x == 1)
		return false;

	if (strlen($pass) < 6)
		return false;

	return true;
}

/* A more strict version of isEmailAddress() */
function db146_user_valid_email($str)
{
	if (eregi('^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+\.([a-zA-Z]{2,4})$', $str))
		return true;
	return false;
}

/*
 * Perform some checks.  Make sure the person is logged in, and that their
 * password hasn't expired (the password_expired var is set in the login page)
 */
function db146_user_auth_required($type, $access = '')
{
	global $config;
	if (!isset($_SESSION['users_type'])) {
		message_push(error(i18n('You must login to view that page')));
		header("location: {$config['SFIABDIRECTORY']}/user_login.php?type=$type");
		exit;
	}

	if ($_SESSION['users_type'] != $type) {
		message_push(error(i18n('You must login to view that page')));
		header("location: {$config['SFIABDIRECTORY']}/user_login.php?type=$type");
		exit;
	}

	if ($_SESSION['password_expired'] == true) {
		header("location: {$config['SFIABDIRECTORY']}/user_password.php");
		exit;
	}

	if ($access != '') {
		if ($type != 'committee') {
			echo 'CRITICAL ERROR, cannot check access in user_auth_required without specifying type=committee';
			exit;
		}

		if (committee_auth_has_access($access) == false) {
			message_push(error(i18n('You do not have permission to view that page')));
			header("Location: {$config['SFIABDIRECTORY']}/committee_main.php");
			exit;
		}
	}
	return true;
}

function db146_user_volunteer_registration_status()
{
	global $config;
	//	$now = date('Y-m-d H:i:s');
	//      if($now < $config['dates']['judgeregopen']) return "notopenyet";
	//	if($now > $config['dates']['judgeregclose']) return "closed";
	return 'open';
}

function db146_user_judge_registration_status()
{
	global $config;
	$now = date('Y-m-d H:i:s');
	if ($now < $config['dates']['judgeregopen'])
		return 'notopenyet';
	if ($now > $config['dates']['judgeregclose'])
		return 'closed';
	return 'open';
}

$user_personal_fields_map = array(
	'salutation' => array('salutation'),
	'name' => array('firstname', 'lastname'),
	'email' => array('email'),
	'sex' => array('sex'),
	'phonehome' => array('phonehome'),
	'phonework' => array('phonework'),
	'phonecell' => array('phonecell'),
	'fax' => array('fax'),
	'org' => array('organization'),
	'birthdate' => array('birthdate'),
	'lang' => array('lang'),
	'address' => array('address', 'address2', 'postalcode'),
	'city' => array('city'),
	'province' => array('province'),
	'firstaid' => array('firstaid', 'cpr')
);

function db146_user_personal_fields($type)
{
	global $config, $user_personal_fields_map;
	$ret = array('firstname', 'lastname', 'email');
	$fields = $config["{$type}_personal_fields"];
	if ($fields != '') {
		$fields = split(',', $fields);
		foreach ($fields as $f) {
			$ret = array_merge($ret, $user_personal_fields_map[$f]);
		}
	}
	return $ret;
}

function db146_user_personal_required_fields($type)
{
	global $config, $user_personal_fields_map;
	$ret = array('firstname', 'lastname', 'email');
	$required = $config["{$type}_personal_required"];
	if ($required != '') {
		$fields = split(',', $required);
		foreach ($fields as $f) {
			$ret = array_merge($ret, $user_personal_fields_map[$f]);
		}
	}

	/*
	 * Filter some elements that are never required.
	 * 	- address2
	 */
	$ret = array_diff($ret, array('address2'));
	return $ret;
}

function db146_user_personal_info_status(&$u)
{
	$required = array();
	foreach ($u['types'] as $t) {
		$required = array_merge($required,
			db146_user_personal_required_fields($t));
	}
	foreach ($required as $r) {
		$val = trim($u[$r]);

		if (strlen($val) > 0) {
			/* Ok */
		} else {
			return 'incomplete';
		}
	}

	/*
	 * FIXME: somehow call the $type _status_update() function db146_to update
	 * the individual $type _complete entry?
	 */
	return 'complete';
}

/* user_{$type}_login() is called with a full $u loaded */
function db146_user_committee_login($u)
{
	/* Double check, make sure the user is of this type */
	if (!in_array('committee', $u['types'])) {
		echo "ERROR: attempted to login committee on a non-committee user\n";
		exit;
	}

	$_SESSION['access_admin'] = $u['access_admin'];  // == 'yes') ? true : false;
	$_SESSION['access_config'] = $u['access_config'];  // == 'yes') ? true : false;
	$_SESSION['access_super'] = $u['access_super'];  // == 'yes') ? true : false;
}

function db146_user_fair_login($u)
{
	/* Double check, make sure the user is of this type */
	if (!in_array('fair', $u['types'])) {
		echo "ERROR: attempted to login fair on a non-fair user\n";
		exit;
	}

	$_SESSION['fairs_id'] = $u['fairs_id'];  // == 'yes') ? true : false;
}

?>