<?php
 
/**
 * 
 * engCIS local version
 * 
 */
 function & rel($struc, &$file) {
 	return file_exists( ( $file = ( dirname($struc).'/'.$file ) ) );
 }
 
 function relativetome($structure, $filetoget){
 	return rel($structure,$filetoget) ? require_once($filetoget) : null;
 }
 
relativetome(__FILE__, 'inc_global.php');
 
require_once(DOC__ROOT . '/library/classes/class_dao.php');
require_once(DOC__ROOT . '/library/functions/lib_array_functions.php');
 
 
class EngCIS {
	// Public Vars
 
 
	// Private Vars
	private $_DAO = null;
	private $_ordering_types = null;
 
	/**
	* CONSTRUCTOR
	*/
	function EngCIS() {
		$this->_DAO = new DAO(APP__DB_HOST,APP__DB_DATABASE,APP__DB_PASSWORD,APP__DB_DATABASE);
		$this->_DAO->set_debug(false);
	}// /->EngCIS()
 
 
/*
* ================================================================================
* Public Methods
* ================================================================================
*/
 
 
/*
* --------------------------------------------------------------------------------
* Course Methods
* --------------------------------------------------------------------------------
*/
 
 
	/**
	* Get array of courses for a department
	* @param string $department_id	ID of department to search
	* @param string $ordering	 ordering mode
	* @return array
	*/
/**	function get_department_courses($department_id, $ordering = 'name') {
		$order_by_clause = $this->_order_by_clause('course', $ordering);
 
		return $this->_DAO->fetch(	"
			SELECT lcc.*
			FROM live_cis_course lcc
			WHERE department_id='$department_id'
			$order_by_clause
		");
	}// /->get_department_courses()
*/
 
	/**
	* Get course info as an array
	* @param integer $course_id
	* @return array
	*/
/**	function get_course($course_id) {
		return $this->_DAO->fetch_row(	"SELECT lcc.*
										FROM live_cis_course lcc
										WHERE course_id='$course_id'
										");
	}// /->get_course()
*/
 
	/**
	* Get array of students for course
	*
	* @param string $ordering ordering mode
	*
	* @return array assoc-array of student info
	*/
/**	function get_course_students($course_id, $ordering = 'name') {
		$order_by_clause = $this->_order_by_clause('student', $ordering);
 
		return $this->_DAO->fetch(	"
																SELECT lcs.*
																FROM live_cis_student lcs INNER JOIN live_student_module lcsm ON lcs.student_id=lcsm.student_id AND module_id='$module_id'
																WHERE course_id='$course_id'
																$order_by_clause
															");
	}// /->get_course_students()
*/
 
/*
* --------------------------------------------------------------------------------
* Module Methods
* --------------------------------------------------------------------------------
*/
 
 
	/**
	* Get module info as an array
	*
	* @param string/array $module_id module ID(s) to search for
	* @param string $ordering	ordering mode
	*
	* @return array  either an assoc-array of module info or an array of assoc-arrays, containing many modules' info
	*/
	function get_module($modules = null, $ordering = 'id') {
		$module_search = $this->_DAO->build_filter('module_code', (array) $modules);
		$order_by_clause = $this->_order_by_clause('module', $ordering);
 
		// If there's more than one module to search for, get all the rows
		if (is_array($modules)) {
			return $this->_DAO->fetch("SELECT lcm.module_code AS module_id, lcm.module_title
										FROM module lcm
										WHERE $module_search
										$order_by_clause");
		} else {	// else, just return one row
			if (!empty($modules)) {
				return $this->_DAO->fetch_row("SELECT lcm.module_code AS module_id, lcm.module_title
												FROM module lcm
												WHERE $module_search
												LIMIT 1");
			}
		}
	}// /->get_module()
 
 
	/**
	* Get array of staff for module
	* @param integer $module_id
	* @param string $ordering
	* @return array
	*/
	function get_module_staff($module_id, $ordering) {
		$order_by_clause = $this->_order_by_clause('staff', $ordering);
 
		return $this->_DAO->fetch	("SELECT lcs.*
									FROM user lcs 
									INNER JOIN user_module lcsm ON lcs.user_id = lcsm.user_id
									WHERE lcs.user_type = 'staff'
										AND module_id='$module_id'
									$order_by_clause");
	}// /->get_module_staff()
 
 
	/**
	* Get array of students for one or more modules
	* @param integer $modules
	* @param string $ordering
	* @return array
	*/
	function get_module_students($modules, $ordering = 'name') {
		$module_set = $this->_DAO->build_set($modules);
		$order_by_clause = $this->_order_by_clause('student', $ordering);
 
		return $this->_DAO->fetch("	SELECT DISTINCT lcs.*, lcs.lastname AS surname, institutional_reference AS student_id
									FROM user lcs
									INNER JOIN user_module lcsm ON lcs.user_id=lcsm.user_id AND module_id IN $module_set
									WHERE lcs.user_type = 'student'
									$order_by_clause
									");
	}// /->get_module_students()
 
 
	/**
	* Get total number of students on one or more modules
	*
	* @param array $modules	 modules to count students for
	* @return array
	*/
	function get_module_students_count($modules) {
		$module_set = $this->_DAO->build_set($modules);
 
		$sql = "SELECT COUNT(DISTINCT u.user_id)
				FROM user u
  					INNER JOIN user_module um ON u.user_id=um.user_id
  					INNER JOIN module m ON m.module_code=um.module_id
				WHERE m.module_code IN $module_set
					AND u.user_type = 'student'";
		return $this->_DAO->fetch_value($sql);
	}// /->get_module_students_count
 
 
	/**
	* Get an array of student IDs for students on the given modules
	* @param array $modules	 modules to count students for
	* @return array
	*/
	function get_module_students_id($modules) {
		if (!empty($modules)) {
			$module_set = $this->_DAO->build_set( (array) $modules);
			return $this->_DAO->fetch_col("SELECT DISTINCT u.institutional_reference AS staff_id
											FROM user u
											INNER JOIN user_module um ON u.user_id=um.user_id
											INNER JOIN module m ON m.module_code=um.module_id
											WHERE m.module_code IN $module_set
												AND u.user_type = 'student'
											ORDER BY u.user_id ASC");
		}
	}// /->get_module_students_id()
 
 
	/**
	* Get an array of user IDs for students on the given modules (user_id = 'student_{studentID}'
	* @param array $modules	 modules to count students for
	* @return array
	*/
	function get_module_students_user_id($modules) {
		if (!empty($modules)) {
			$module_set = $this->_DAO->build_set( (array) $modules);
			$sql = "SELECT DISTINCT u.user_id
					FROM user u
						INNER JOIN user_module um ON u.user_id=um.user_id
						INNER JOIN module m ON m.module_code=um.module_id
					WHERE m.module_code IN $module_set
						AND u.user_type = 'student'
					ORDER BY u.user_id ASC
					";
			return $this->_DAO->fetch_col($sql);
		}
	}// /->get_module_students_user_id()
 
 
	/**
	* Get number of students on individual multiple modules, grouped by module
	*
	* @param array  $modules	modules to count students for
	* @return array 
	*/
	function get_module_grouped_students_count($modules) {
		$module_search = $this->_DAO->build_filter('module_id', (array) $modules, 'OR');
 
		return $this->_DAO->fetch_assoc("SELECT module_id, COUNT(user_id)
										FROM user_module lcsm
										WHERE $module_search
										GROUP BY module_id
										ORDER BY module_id");
	}// ->get_modules_grouped_students_count()
 
 
/*
* --------------------------------------------------------------------------------
* Staff Methods
* --------------------------------------------------------------------------------
*/
 
 
	/**
	* Get staff info
	* Can work with either staff_id or staff_username alone (staff_id takes precedent)
	*
	* @param string/array $staff_id	 staff ID(s) to search for (use NULL if searching on username)
	* @param string/array $staff_username	 staff username(s) to search for
	* @param string $ordering ordering mode
	*
	* @return array either an assoc-array of staff member info or an array of assoc-arrays, containting many staff members' info
	*/
	function get_staff($staff_id, $staff_username = null, $ordering = 'name') {
		if ($staff_id) {
			$staff_set = $this->_DAO->build_set($staff_id);
			$sql_WHERE = "user_id IN $staff_set ";
		}	else {
			if ($staff_username) {
				$staff_set = $this->_DAO->build_set($staff_username);
				$sql_WHERE = "username IN $staff_set ";
			}	else { return null; }
		}
 
		$order_by_clause = $this->_order_by_clause('staff', $ordering);
 
		// If there's more than one staff member to search for, get all the rows
		if ( (is_array($staff_id)) || (is_array($staff_username)) ) {
			return $this->_DAO->fetch("SELECT lcs.*, lcs.lastname AS surname, institutional_reference AS staff_id
										FROM user lcs
										WHERE $sql_WHERE
										$order_by_clause");
		} else {	// else, just return one row
			return $this->_DAO->fetch_row("SELECT lcs.*, lcs.lastname AS surname, institutional_reference AS staff_id
											FROM user lcs
											WHERE $sql_WHERE
											LIMIT 1");
		}
	}// /->get_staff()
 
 
	/**
	* Get array of modules for the given staff member(s)
	* Can work with either staff_id or staff_username alone (staff_id takes precedent)
	*
	* @param string/array $staff_id	staff ID(s) to search for (use NULL if searching on username)
	* @param string/array $staff_username	staff username(s) to search for
	* @param string $ordering	ordering mode
	*
	* @return array	 an array of assoc-arrays, containting many module info
	*/
	function get_staff_modules($staff_id, $staff_username = null, $ordering = 'id') {
		if ($staff_id) {
			$staff_set = $this->_DAO->build_set($staff_id);
			$sql_WHERE = "user_id IN $staff_set ";
		}	else {
			if ($staff_username) {
				$staff_set = $this->_DAO->build_set($staff_username);
				$sql_WHERE = "username IN $staff_set ";
			}	else { return null; }
		}
 
		$order_by_clause = $this->_order_by_clause('module', $ordering);
 
		return $this->_DAO->fetch(	"SELECT DISTINCT lcm.module_code AS module_id, lcm.module_title
									FROM module lcm INNER JOIN user_module lcsm ON lcm.module_code=lcsm.module_id
									WHERE $sql_WHERE
									$order_by_clause");
	}// /->get_staff_modules
 
 
	/**
	* Is the given staff member associated with the given modules?
	*
	* @param string $staff_id staff id of member being checked
	* @param string/array $module_id	either a single module_id, or an array of module_ids
	* @return integer
	*/
	function staff_has_module($staff_id, $module_id) {
		$module_id = (array) $module_id;
		$staff_modules = $this->get_staff_modules($staff_id);
		if (!$staff_modules) {
			return false;
		} else {
			$arr_module_id = array_extract_column($staff_modules, 'module_id');
			$diff = array_diff($module_id, $arr_module_id);
 
			// If the array is empty, then the staff member has those modules
			return (count(array_diff($module_id, $arr_module_id))===0);  
		}
	}// /->staff_has_module()
 
 
/*
* --------------------------------------------------------------------------------
* Student Methods
* --------------------------------------------------------------------------------
*/
 
 
	/**
	* Get student info
	* Can work with either student_id or student_username alone (student_id takes precedent)
	*
	* @param string/array $student_id	 student ID(s) to search for (use NULL if searching on username)
	* @param string/array $student_username	 student
	* @param string $ordering	 ordering mode
	*
	* @returns	array either an assoc-array of student info	or an array of assoc-arrays, containting many students info
	*/
	function get_student($student_id = null, $student_username = null, $ordering = 'name') {
		if ($student_id) {
			$student_set = $this->_DAO->build_set($student_id);
			$sql_WHERE = "user_id IN $student_set ";
		}	else {
			if ($student_username) {
				$student_set = $this->_DAO->build_set($student_username);
				$sql_WHERE = "username IN $student_set ";
			}	else { return null; }
		}
 
		// If there's more than one student to search for, get all the rows
		if ( (is_array($student_id)) || (is_array($student_username)) ) {
			$order_by_clause = $this->_order_by_clause('student', $ordering);
			return $this->_DAO->fetch("SELECT lcs.*, lcs.lastname AS surname, institutional_reference AS student_id
										FROM user lcs
										WHERE $sql_WHERE
										$order_by_clause");
		} else {	// else, just return one row
			return $this->_DAO->fetch_row("SELECT lcs.*, lcs.lastname AS surname, institutional_reference AS student_id
											FROM user lcs
											WHERE $sql_WHERE
											LIMIT 1");
		}
	}// /->get_student()
 
 
	/**
	* Get array of modules for the given student(s)
	* Can work with either student_id or student_username alone (student_id takes precedent)
	*
	* @param string/array $student_id	student ID(s) to search for (use NULL if searching on username)
	* @param string/array $student_username	student username(s) to search for
	* @param string $ordering	ordering mode
	*
	* @return array an array of module info arrays
	*/
	function get_student_modules($student_id, $student_username = null, $ordering = 'id') {
		if ($student_id) {
			$student_set = $this->_DAO->build_set($student_id);
			$sql_WHERE = "user_id IN $student_set ";
		}	else {
			if ($student_username) {
				$student_set = $this->_DAO->build_set($student_username);
				$sql_WHERE = "username IN $student_set ";
			}	else { return null; }
		}
 
		$order_by_clause = $this->_order_by_clause('module', $ordering);
 
		return $this->_DAO->fetch(	"SELECT DISTINCT lcm.module_code AS module_id, lcm.module_title
									FROM module lcm INNER JOIN user_module lcsm ON lcm.module_code=lcsm.module_id
									WHERE $sql_WHERE
									$order_by_clause");
	}// /->get_student_modules()
 
 
/*
* --------------------------------------------------------------------------------
* User Methods
* --------------------------------------------------------------------------------
*/
 
 
	/**
	* Get a user's info
	*
	* @param string/array $user_id user ID(s) to search for
	* $ordering	: (string) - ordering mode
	*
	* Returns	: either an assoc-array of user info
	*						or an array of assoc-arrays, containting many users' info
	*/
	function get_user($user_id, $ordering = 'name') {
		$user_set = $this->_DAO->build_set($user_id);
		$sql_WHERE = "user_id IN $user_set ";
 
 
		// If there's more than one user to search for, get all the rows
		if (is_array($user_id)) {
			$order_by_clause = $this->_order_by_clause('user', $ordering);
			$sql = "SELECT scu.*, scu.lastname AS surname
					FROM user scu
					WHERE $sql_WHERE
					$order_by_clause";
 
			return $this->_DAO->fetch($sql);
		} else {	// else, just return one row
			$sql = "SELECT scu.*, scu.lastname AS surname
					FROM user scu
					WHERE $sql_WHERE
					LIMIT 1";
			return $this->_DAO->fetch_row($sql);
		}
	}// /->get_user()
 
 
 
	/**
	* Get a user's info by searching on email address
	*
	* @param string $email email address to search for
	*
	* Returns	: an assoc-array of user info
	*/
	function get_user_for_email($email) {
		return $this->_DAO->fetch_row("SELECT scu.*
									   FROM user scu
									   WHERE email='$email'
									   LIMIT 1");
	}// /->get_user_for_email()
 
 
 
 
/*
* ================================================================================
* Private Methods
* ================================================================================
*/
 
 
	/**
	* Return an ORDER BY clause matching the given parameters
	*
	* @param string $row_type type of row being ordered. ['course','module','staff','student']
	* @param string $ordering	 type of ordering to do. ['id','name']
	*
	* @return	string	SQL ORDER BY clause of the form 'ORDER BY fieldname' or NULL if row_type/ordering are invalid
	*/
	function _order_by_clause($row_type, $ordering = null) {
		if (!is_array($this->_ordering_types)) {
			// All available ordering types
			$this->_ordering_types = array (
/**				'course'	=> array	(
									'id'	=> 'lcc.course_id' ,
									'name'	=> 'lcc.course_title' ,
								) ,
*/
				'module'	=> array	(
									'id'	=> 'lcm.module_id' ,
									'name'	=> 'lcm.module_title' ,
								) ,
				'staff'		=> array	(
									'id'	=> 'lcs.user_id' ,
									'name'	=> 'lcs.lastname, lcs.forename' ,
								) ,
				'student'	=> array	(
									'id'	=> 'lcs.user_id' ,
									'name'	=> 'lcs.lastname, lcs.forename' ,
								) ,
				'user'		=> array	(
									'id'	=> 'scu.user_id' ,
									'name'	=> 'scu.lastname, scu.forename' ,
								) ,
			);
		}
 
		if ( (array_key_exists($row_type, $this->_ordering_types)) && (array_key_exists($ordering, $this->_ordering_types["$row_type"])) ) {
			return 'ORDER BY '. $this->_ordering_types["$row_type"]["$ordering"];
		} else {
			return null;
		}
	}// /->_order_by_clause()
 
 
}// /class: EngCIS
 
?>

<?php
/**
 * 
 * Class : DAO
 * 	
 * This data access object is designed for MySQL only
 *
 * 
 * Updates:
 * 18-07-2007   : improved ->_throw_error() code
 * 13-07-2005	: added ->build_set() method - returns a string containing an SQL set
 * 12-07-2005	: added ->get_num_cols() method - returns the number of column names
 * 12-07-2005	: added ->get_cols() method - returns an array of column names
 * 16-06-2005	: fixed a bug when using NULL values in do_insert/do_update
 * 14-06-2005	: added $new_link parameter to ->open() method
 * 13-06-2005	: added ->do_insert_multi() method for adding multiple rows in one statement
 * 09-06-2005	: fixed potential insert-id bug
 * 15-10-2004	: new ->fetch_assoc() method - gets the query as an associative array
 *				  of the form:  array ( row1.field1 => row1.field2, ... ) 
 * 31-09-2004	: Fixed multi-database usage (stops connection clashing)
 * 
 */
 
 
class DAO {
	// Public Vars
 
	// Private Vars
	private $_host = 'localhost';				// DB Connection info
	private $_user = '';
	private $_password = '';
	private $_database = 'pa';
	private $_persistent = false;
 
	private $_conn = null;				// DB Connection object
 
	private $_result_set = null;		// Contains the result set (temporarily)
	private $_result_cols	= null;		// Array of columns for the result set
 
	private $_last_sql = null;			// Last query run
	private $_result = null;			// Query results, as array of row objects
 
	private $_output_type = 'ARRAY_A';	// 'ARRAY_A': Associative Array	: $results[row]['field']
										// 'ARRAY_N': Numeric Array	: $results[row][col]
										// 'ARRAY_B': Assoc + Numeric Array	: use $results[row]['field'] or $results[row][col]
 
	private $_output_type_int = MYSQL_ASSOC;	// MYSQL_ASSOC, MYSQL_BOTH, MYSQL_NUM
 
	private $_insert_id = null;			// Last inserted id (on auto-increment columns)
 
	private $_num_cols = null;
  	private $_num_rows = null;
  	private $_num_affected = null;
 
	private	$_debug = false;			// debug mode (default: off)
	private $_last_error = null;
 
 
   /**
	* CONSTRUCTOR
  	* Set database connection strings
  	* @param string $host
  	* @param string $user
  	* @param string $password
  	* @param string $database
  	* @param boolean $persistent
	*/
	function DAO($host, $user, $password, $database, $persistent = false) {
		$this->_host = $host;
		$this->_user = $user;
		$this->_password = $password;
		$this->_database = $database;
		$this->_persistent = $persistent;
	} // /DAO()
 
 
/*
* ================================================================================
* Public Methods
* ================================================================================
*/
 
 
	/**
	* Open database connection
	* @param boolean $new_link	 block reusing an existing database connection when the same server/username/password are used
	* @return boolean
	*/
	function open($new_link = true) {
		if (is_null($this->_conn)) {
			if ($this->_persistent) {
				$func = 'mysql_pconnect';
			} else {
				$func = 'mysql_connect';
			}
 
			if ($this->_debug) {
				$this->_conn = @$func($this->_host, $this->_user, $this->_password, $new_link) or $this->_throw_error('Connecting to server');
				@mysql_select_db($this->_database, $this->_conn) or $this->_throw_error('Selecting Database');
			} else {
				$this->_conn = @$func($this->_host, $this->_user, $this->_password, $new_link);
				if(@!mysql_select_db($this->_database, $this->_conn)) {
					return false;
				}
			}
 		}
		return true;
	} // /->open()
 
/**
 * Close database connection
 * @return object
 */
	function close() {
  	$this->flush();
		return ( @mysql_close($this->_conn) );
	} // /->close()
 
 
	/** 
	 * Clear results and reset result vars
	 */
	function flush() {
    $this->_result = null;
		$this->_num_rows = null;
		$this->_num_affected = null;
    $this->_insert_id = null;
	} // /->flush()
 
 
	/**
	* Execute the SQL query, and ignore results (ie, not a SELECT)
	* Sets affected rows (ie could be DELETE/INSERT/REPLACE/UPDATE)
	* Sets inserted id if query is INSERT/REPLACE	(checks first word of query)
	* @param string $sql
	* @return boolean
	*/
  function execute($sql) {
  	$this->flush();
		$this->open();
  	$this->_last_sql = trim( $sql );	// Save query
 
		if ($this->_debug) {
			$this->_result_set = mysql_query($sql, $this->_conn) or $this->_throw_error('Executing SQL');
		} else {
	 		$this->_result_set = @mysql_query($sql, $this->_conn);
		}
 
		if ($this->_result_set) {
			$this->_num_affected = mysql_affected_rows($this->_conn);
 
  	  if ( preg_match("/^\\s*(insert|replace) /i", $sql) ) {
    		$this->_insert_id = mysql_insert_id($this->_conn);
	    }
 
  	  if ($this->_num_affected) {
    		return true;
	    } else {
  	  	return false;
    	}
		} else {
    	return false;
    }
  }// /->execute()
 
 
	/**
	* Get results of the given query
	* @param string $sql
	* @return object
	*/
	function fetch($sql = null) {
			// If there is an SQL query, get its results instead..
		if ( $sql ) { $this->_process_query($sql); }
 
		return $this->_result;
	} // /->fetch()
 
 
	/**
	* Get a single row (of the given query or cache)
	* Row indexes are 0-based
	* @param string $sql
	* @param integer $y
	* @return object
	*/
  function fetch_row($sql = null, $y = 0) {
		// If there is an SQL query, get its results instead..
  	if ( $sql ) { $this->_process_query($sql);	}
		return (isset($this->_result)) ? $this->_result[$y] : null;
	}	// /->fetch_row()
 
 
	/**
	* Get a single column as a numeric array
	* column indexes are 0-based
	* @param string $sql
	* @param integer $x
	* @return array
	*/
 	function fetch_col($sql = null, $x = 0)	{
		// If there is an SQL query, get its results instead..
		if ( $sql ) { $this->_process_query($sql);	}
 
		$new_array = null;
 
		// Extract the column value
		if ($this->_num_rows>0) {
			for ( $i=0; $i<$this->_num_rows; $i++ ) {
				$new_array[$i] = $this->fetch_value(null,$x,$i);
			}
		}
		return $new_array;
	}	// /->fetch_col()
 
 
	/**
	* Get a single value from the result set
    * column/row indexes are 0-based
	* An empty string ('') or no value, will return null
	* @param string $sql
	* @param integer $x
	* @param integer $y
	* @return integer
	*/
 	function fetch_value($sql = null, $x = 0, $y = 0) {
		// If there is an SQL query, get its results instead..
		if ( $sql ) { $this->_process_query($sql);	}
 
  	// Extract value using x,y vals
  	if ( $this->_result[$y] )	{
  		$values = array_values($this->_result[$y]);
  	}
  	// If there is a value return it, else return null
  	return ( isset($values[$x]) && $values[$x]!=='') ? $values[$x] : null;
	} // /->fetch_value()
 
 
	/**
	* Get an associative array ( field1-value => field2-value ) from the result set
	* If you retrieve more than 2 fields, you will get an associative array of row-arrays
	* e.g.   field1-value => array ( field2 => field2-value, field3 => field3-value, ... ), ...
	* @param string $sql
	* @return array
	*/
	function fetch_assoc($sql = null) {
		// Need to be in Numeric+Assoc Array mode, so set it
		$original_output_mode = $this->get_output_mode();
		$this->set_output($output = 'ARRAY_B');
 
		// Fetch the new result set
		$this->_process_query($sql);
 
		// Reset mode to what it was before
		$this->set_output($original_output_mode);
 
		$new_array = null;
 
		if ($this->_num_rows>0) {		
			if ($this->get_num_cols()==2) {
				// Convert rows to simple associative array
				for ( $i=0; $i<$this->_num_rows; $i++ ) {
					$new_array["{$this->_result[$i][0]}"] = $this->_result[$i][1];
				}
			} else {
				// Convert rows to associative array of arrays
				for ( $i=0; $i<$this->_num_rows; $i++ ) {
					$row_array = null;
					for ( $j=1; $j<$this->_num_cols; $j++ ) {
						$row_array[$this->_result_cols["$j"]] = $this->_result[$i][$j];
					}
					$new_array["{$this->_result[$i][0]}"] = $row_array;
				}
			}
		}
		return $new_array;
	}// /->fetch_assoc()
 
 
	/**
	*	Execute the insert query in $sql, using the fields in $fields
	*	auto-slashes the given fields
	* @param string $sql string of the form 'INSERT INTO tbl_name ({fields}) VALUES ({values}) '
	* @param array $fields	 array ( fieldname1 => ???, fieldname2 => ???, ... )
	*/
	function do_insert($sql, $fields) {
		$fields_str = implode(',', (array) array_keys($fields) );
 
		$values = array();
 		foreach ($fields as $k => $v) {
			$values[] = $this->_prepare_field_value($v);
 		}
		$values_str = implode(',',$values);
 
		$sql = str_replace('{fields}',$fields_str,$sql);
		$sql = str_replace('{values}',$values_str,$sql);
		return $this->execute($sql);
	} // /->do_insert()
 
 
	/**
	* Execute the insert query in $sql, using multiple VALUES statements as given in $fields
	* Auto-slashes the given fields
	*
	* NOTE	: Unlike ->do_insert, the $fields array is an array[0..n] of assoc-arrays
	* NOTE	: Only the last insert-id will be available from ->get_insert_id() following execution
	* 
	* @param string $sql of the form, 'INSERT INTO tbl_name ({fields}) VALUES {values}
	* @param array $fields array[0..n] of array ( fieldname1 -> ???, fieldname2 => ???, ... )
	* @return object
	*/
	function do_insert_multi($sql, $fields) {
		if (is_array($fields)) {
			$fields_str = implode(',', array_keys($fields[0]) );
 
			$value_row = null;
 
			foreach ($fields as $i => $row) {
				$value_row["$i"] = array ();
				foreach($row as $k => $v) {
					$value_row["$i"][] = $this->_prepare_field_value($v);
				}
				$value_row["$i"] = '('. implode(',',$value_row["$i"]) .')';
			}
			$values_str = implode(',',$value_row);
 
			$sql = str_replace('{fields}',$fields_str,$sql);
			$sql = str_replace('{values}',$values_str,$sql);
 
			return $this->execute($sql);
		} else {
			return null;
		}
	}// /->do_insert_multi()
 
 
	/**
	*	Execute the update query in $sql, setting the fields in $fields
	*	Auto-slashes the given fields
	*	@param string $sql  sql query of the form  'UPDATE tbl_name SET {fields} WHERE xxx=yyy'
	*	@param array $fields of fields and values to set - of the form  array ( fieldname1 => ???, fieldname2 => ???, ... )
	*	@return mixed
	*/
	function do_update($sql, $fields) {
		$set_str = '';
		$fields_count = count($fields);
		$i=1;
 
		foreach ($fields AS $k=>$v) {
			$set_str .= " $k=". $this->_prepare_field_value($v);
			if ($i<$fields_count) { $set_str .= ','; }
			++$i;
		}
 
		$sql = str_replace('{fields}',$set_str,$sql);
		return $this->execute($sql);
	} // /->do_update()
 
 
	/**
	* Builds filter clause of the form  (aaa='bbb' OR aaa='ccc' OR aaa='ddd' ... )
	*
	* @param string $field_name the field name being checked (aaa in example above)
	* @param array/value $filter_values the values to compare against.
	* @param string $logical_operator the operator to use to concatenate the filters (AND, OR, XOR)
	* @return string
	*/
	function build_filter($field_name, $filter_values, $logical_operator = 'OR') {
		$filter_values = (array) $filter_values;	// cast values to array (in case it was only passed one)
 
		$filter_clause = '(';
		$w_count = count($filter_values);
		$i = 1;
		foreach($filter_values as $k => $v) {
			$v = $this->escape_str($v);
			$filter_clause .= "$field_name=". $this->_prepare_field_value($v);
			if ($i<$w_count) { $filter_clause .= " $logical_operator "; }
			$i++;
		}
		$filter_clause .= ')';
 
		return $filter_clause;
	}// ->build_filter()
 
 
	/**
	* Builds an SQL set of the form  ('aaa','bbb','ccc') for use with IN operators
	*
	* @param array/value $value_array	array of values to include in the set
	* @return string
	*/
	function build_set($value_array) {
		$value_array = array_map('addslashes',(array) $value_array);
		return '(\''. implode('\',\'',$value_array) .'\')';
	}// /->build_set()
 
 
/*
* --------------------------------------------------------------------------------
* Accessor Methods
* --------------------------------------------------------------------------------
*/
 
	// GET_xxx functions
 
  /**
   * Return an array of columns names from the last query
   * @return boolean 
   */
	function get_cols() { return (is_array($this->_result_cols)) ? $this->_result_cols : null ; }
 
 
  /**
   * Return the number of columns from the last query
   * @return integer
   */
	function get_num_cols() { return $this->_num_cols; }
 
 
  /**
   * Return the number of rows from the last query
   * @return integer
   */
	function get_num_rows() { return $this->_num_rows; }
 
 
  /**
   * Return the number of affected rows from the last query (insert/replace/update)
   * @return integer
   */
	function get_num_affected() { return $this->_num_affected; }
 
 
 /** 
  * Return last inserted id (for auto-increment columns)
  * @return integer 
  */
  function get_insert_id() { return $this->_insert_id; }
 
 
 /** 
  * Return last run query
  * @return string
  */
  function get_last_sql() { return $this->_last_sql; }
 
 
/**
 *  Get last mysql error
 */	
	function get_last_error() { mysql_error($this->_conn); }
 
 
	/**
	 * Get output mode
	 * @return mixed 
	 */
	function get_output_mode() { return $this->_output_type; }
 
 
/*
* --------------------------------------------------------------------------------
* SET_xxx functions
* --------------------------------------------------------------------------------
*/
 
	/**
	* Set debug mode
	* When in debug mode, detailed error reports are echoed
	* @param boolean 
	*/
	function set_debug($on) {
		$this->_debug = $on;
	}
 
 
	/**
	* Set default output mode for results array
	* @param string $output
	* @return boolean
	*/
	function set_output($output = 'ARRAY_A') {
		switch ($output) {
			case 'ARRAY_A'	:
						$this->_output_type_int = MYSQL_ASSOC;
						$this->_output_type = $output;
						return true;
						break;
			// ----------------------------------------
			case 'ARRAY_B'	:
						$this->_output_type_int = MYSQL_BOTH;
						$this->_output_type = $output;
						return true;
						break;
			// ----------------------------------------
			case 'ARRAY_N'	:
						$this->_output_type_int = MYSQL_NUM;
						$this->_output_type = $output;
						return true;
						break;
			// ----------------------------------------
			default :
				return false;
				break;
		}
	}// /->set_output()
 
 
  /** 
   * Escape character string
   * @param string $str
   * @return string 
   */
  function escape_str($str)	{	return mysql_escape_string(stripslashes($str)); }
 
 
/*
* ================================================================================
* Private Methods
* ================================================================================
*/
 
 
	/** 
	 * Execute the SQL and collect the result set
	 * @param string $sql
	 * @return boolean
	 */
	function _process_query($sql) {
  	$this->flush();
		$this->open();
  	$this->_last_sql = trim( $sql );	// Save query
 
		if ($this->_debug) {
			$this->_result_set = mysql_query($sql, $this->_conn) or $this->_throw_error('Querying database');
		} else {
	  	$this->_result_set = @mysql_query($sql, $this->_conn);
		}
 
		// If got a result set..	
		if ($this->_result_set) {
 
			// number of columns returned
			$this->_num_cols = mysql_num_fields($this->_result_set);
 
			// Store column names as an array
			$i=0;
			$this->_result_cols = array();
			while ($i < $this->_num_cols) {
				$field = @mysql_fetch_field($this->_result_set,$i);
				$this->_result_cols[] = $field->name;
				$i++;
			}
 
			// Store the results as an array of row objects
			while ( $row = @mysql_fetch_array($this->_result_set,$this->_output_type_int) ) {
				$this->_result[] = $row;
			}
 
			// number of rows returned
			$this->_num_rows = count($this->_result);
 
      // Free the actual result set
			@mysql_free_result($this->_result_set);
 
			// If there were results.. return true
			return ($this->_num_rows>=1);
		} else {
			$this->_num_cols = 0;
			$this->_num_rows = 0;
			$this->_result_cols = null;
    	return false;
    }
	} // /->process_query()
 
	/**
	 * function to capture the thrown error and out put to the screen
	 * @param string $err_msg
	 * @return boolean 
	 */
	function _throw_error($err_msg) {
		if ($this->_conn) {
			die("<hr />DATABASE ERROR<hr />$err_msg :: ". mysql_error($this->_conn) .'<hr />'. $this->get_last_sql().'<hr />');
		} else {
			die("<hr />DATABASE ERROR<hr />$err_msg :: &lt;NO SERVER&gt;<hr />". $this->get_last_sql().'<hr />');
		}
		return false;
	}// /->_throw_error()
 
 
	/**
	* Prepare a value for putting into the database
	* Escapes special characters, checks for NULL, and puts in quotes as necessary
	*
	* @param integer $value	value to prepare
	*
	* @return string   en-quoted value, ready for insertion into a database (of the form 'value' or NULL)
	*/
	function _prepare_field_value($value) {
		// NULL values don't need quotes, so if it's null, just return a string containing NULL
		// Else, return an escaped string containing the value enclosed in quotes
		return (is_null($value)) ? 'NULL' : '\''. $this->escape_str($value) .'\'';
	}// /->_prepare_field_value()
 
 
} // /class: DAO
 
?>