<?php
	
/**
 * AgileBill - Open Billing Software
 *
 * This body of work is free software; you can redistribute it and/or
 * modify it under the terms of the Open AgileBill License
 * License as published at http://www.agileco.com/agilebill/license1-4.txt
 * 
 * For questions, help, comments, discussion, etc., please join the
 * Agileco community forums at http://forum.agileco.com/ 
 *
 * @link http://www.agileco.com/
 * @copyright 2004-2008 Agileco, LLC.
 * @license http://www.agileco.com/agilebill/license1-4.txt
 * @author Tony Landis <tony@agileco.com> 
 * @package AgileBill
 * @version 1.4.93
 */
	
class module
{

	# Open the constructor for this mod
	function module()
	{
		# name of this module:
		$this->module = "module";

		# location of the construct XML file:
		$this->xml_construct = PATH_MODULES . "" . $this->module . "/" . $this->module . "_construct.xml";

		# open the construct file for parsing	
		$C_xml = new CORE_xml;
		$construct = $C_xml->xml_to_array($this->xml_construct);

		$this->method   = $construct["construct"]["method"];
		$this->trigger  = $construct["construct"]["trigger"];
		$this->field    = $construct["construct"]["field"];
		$this->table 	= $construct["construct"]["table"];
		$this->module 	= $construct["construct"]["module"];
		$this->cache	= $construct["construct"]["cache"];
		$this->order_by = $construct["construct"]["order_by"];
		$this->limit	= $construct["construct"]["limit"];

		# core modules for installation/deletion:
		$this->core_mods= Array(  'account',
								  'account_admin',
								  'account_group',
								  'backup',
								  'blocked_email',
								  'blocked_ip',
								  'country',
								  'currency',
								  'email_template',
								  'email_template_translate',
								  'group',
								  'group_method',
								  'login_lock',
								  'login_log',
								  'log_error',
								  'module',
								  'module_method',
								  'newsletter',
								  'newsletter_subscriber',
								  'session',
								  'session_auth_inc',
								  'setup',
								  'setup_email',
								  'staff',
								  'staff_department',
								  'static_relation',
								  'static_var',
								  'static_var_record',
								  'task',
								  'temporary_data'  );


		$this->dev_inst_excl = Array(   'module',
										'module_method',
										'group_method',
										'backup',
										'login_log',
										'session',
										'weblog',
										'temporary_data',
										'setup',
										'session_auth_cache');
	}


	### Send php/mysql/server/license details and check versions
	function remote_version_check($VAR) {     
		global $C_auth;
		if(!$C_auth->auth_method_by_name("module","upgrade")) return false;

		require_once('includes/pear/Compat/Function/file_get_contents.php');  
		if(is_file(PATH_AGILE.'Version.txt'))
		$f['version']=trim(file_get_contents(PATH_AGILE.'Version.txt'));
		else
		$f['version']='SVN';

		$f['license']=LICENSE_KEY;
		$f['php']=phpversion();
		$f['mysql']=mysql_get_client_info();
		$f['os']=$_ENV['OS'];
		$f['proc']=$_ENV['PROCESSOR_ARCHITECTURE'];
		$f['arch']=$_ENV['PROCESSOR_ARCHITEW6432'];
		$f['server']=$_SERVER["SERVER_SOFTWARE"]; 
		global $smarty;
		$smarty->assign('send', $f);
	} 

	### Get remote hash file and check for inconsitancys in local files
	function remote_update($VAR)
	{
		## Load file_get_contents function for older versions:
		require_once('includes/pear/Compat/Function/file_get_contents.php');  	

		$ver = $VAR['ver']; 				
		$mis=0;
		$md5=0;
		$i=0;
		$msg = '';

		# Get the core modules & compare  
		if(defined('DEMO_VERSION'))
			$url_core = 'http://agileco.com/downloads/trial/'.$ver.'.hash.txt';
		else 
			$url_core = 'http://agileco.com/downloads/commercial/'.$ver.'.hash.txt';

		@$data = file_get_contents($url_core);
		if(empty($data)) {
			$msg .= 'Failed to retrieve MD5 Hash file at http://agileco.com/downloads/commercial/'.$ver.'.hash.txt...<BR>';
		} else {  
			$arr = explode("|",$data); 
			foreach($arr as $arx)
			{
				$rx = explode(',',$arx);
				@$ar['name'] = $rx[1];
				@$ar['md5'] = $rx[0]; 
				if(!empty($ar['name']) && !empty($ar['md5']) && 
					!ereg("^install/", $ar['name']) &&
					!ereg("^test.php", $ar['name']))
				{
					if(!is_file(PATH_AGILE.$ar["name"]))
					{
						$core_mis[] = $ar["name"];
						$mis++;
					} 
					elseif(md5_file(PATH_AGILE.$ar["name"]) != $ar["md5"])
					{ 
						$core_md5[] =  $ar["name"];
						$md5++;
					}
				}
				$i++;
			}      
			$smart[] = Array ('name' => 'Core', 'md5' => @$core_md5, 'mis' => @$core_mis );
		}


		### Get each optional module && compare	
		if(!defined('DEMO_VERSION'))
		{	 
			@$modules = $VAR["module"]; 
			foreach($modules as $module)
			{
				$data = '';
				@$data = file_get_contents('http://agileco.com/downloads/commercial/'.$module.'.hash.txt');
				if(empty($data)) {
					$msg .= 'Failed to retrieve MD5 Hash file at http://agileco.com/downloads/commercial/'.$module.'.hash.txt...<BR>';
				} else {  
					$arr = explode("|",$data); 
					foreach($arr as $arx)
					{
						$rx = explode(',',$arx);
						@$ar['name'] = $rx[1];
						@$ar['md5'] = $rx[0];

						# check if file exists locally...
						if(!empty($ar['name']) && !empty($ar['md5']) ) 
						{
							if(!is_file(PATH_AGILE.$ar["name"]))
							{
								$f_mis[] = $ar["name"];
								$mis++;
							} 
							elseif(md5_file(PATH_AGILE.$ar["name"]) != $ar["md5"])
							{ 
								$f_md5[] =  $ar["name"];
								$md5++;
							}
						}
						$i++;
					}

					$smart[] = Array ('name' => $module, 'md5' => @$f_md5, 'mis' => @$f_mis );
					unset($f_mis);
					unset($f_md5);
				}		
			}
		} 

		global $smarty;
		$smarty->assign('modules', $smart);	 
		$smarty->assign('md5', $md5);
		$smarty->assign('mis', $mis);

		if(!empty($msg)) {
			global $C_debug;
			$C_debug->alert($msg);
		}
	}  


	##############################
	##		TRANSLATE           ##
	##############################
	function translate($VAR)
	{
		if(!isset($VAR['translate_language']) || !isset($VAR['translate_module']))
		{
			echo "error!";
			return;
		}

		if($VAR['translate_module'] == "")
		{
			echo "error!";
			return;
		}

		# Get the default language file:
		if(!$file = fopen(PATH_LANGUAGE . '' .
					$VAR["translate_module"] .
					"/english_" . $VAR["translate_module"] .
					".xml", "r"))
		{
			echo 'Unable to open base translation!';
		}
		else
		{
			$systran_text='';
			while(!feof($file))
			{
				$systran_text .= fgetc($file);
			}
		}
		fclose($file);


		for($i=0; $i<count($VAR['translate_language']); $i++)
		{
			if(isset($VAR['translate_language'][$i]) && $VAR['translate_language'][$i] != "")
			{
			   $systran_lp      = $VAR['translate_language'][$i];
			   $language   		= $VAR['translate_lang'][$systran_lp];

			   ### Get the translation from systran:
			   $language_xml = trim($this->systran($systran_text,$systran_lp));

			   # write the language packs
			   $file = fopen(PATH_LANGUAGE . '' . $VAR["translate_module"] . "/".$language."_" . $VAR["translate_module"] . ".xml", "w+");
			   fputs($file, $language_xml);
			   fclose($file);
			}
		}
	} 


	##############################
	##	SYSTRAN TRANSLATION     ##
	##############################
	function systran($text, $lang)
	{
		$systran_id      = "SystranSoft-en";
		$systran_charset = "ISO-8859-1";

		$host	=	'systranbox.com';
		$form	=	'/systran/box';
		$pass	=	array(
					 'systran_id'        =>  $systran_id,
					 'systran_charset'   =>  $systran_charset,
					 'systran_lp'        =>  $lang,
					 'systran_text'      =>  $text
					);

		// CREATE THE RECORD
		require_once(PATH_CORE  . 'post.inc.php');
		$post= new CORE_post;
		$result = $post->post_data($host, $form, $pass);
		$pat = "\n";
		$arr = split($pat, $result);

		$ret='';
		for($i=0; $i<count($arr); $i++)
		   if($i>5) $ret.= $arr[$i];

		return $ret;
	}


	##############################
	##		ADD   		        ##
	##############################
	function add($VAR)
	{
		$type 		= "add";
		$this->method["$type"] = split(",", $this->method["$type"]);    		
		$db 		= new CORE_database;
		$db->add($VAR, $this, $type);
	}

	##############################
	##		VIEW			    ##
	##############################
	function view($VAR)
	{	
		$type = "view";
		$this->method["$type"] = split(",", $this->method["$type"]);
		$db = new CORE_database;
		 $db->view($VAR, $this, $type);
	}		

	##############################
	##		UPDATE		        ##
	##############################
	function update($VAR)
	{
		$type = "update";
		$this->method["$type"] = split(",", $this->method["$type"]);
		$db = new CORE_database;
		 $db->update($VAR, $this, $type);
	}

	##############################
	##		 DELETE	            ##
	##############################
	function delete($VAR)
	{	
		# set the core modules:
		$core = $this->core_mods;

		if(isset($VAR["delete_id"]))
			$id = split(',',$VAR["delete_id"]);
		elseif (isset($VAR["id"]))
			$id = split(',',$VAR["id"]);

		for($i=0; $i<count($id); $i++)
		{
			if($id[$i] != '')
			{
				# get the module id
				$module_id = $id[$i];

				# is this module part of the core?
				$db = &DB();
				$q  = "SELECT name FROM ".AGILE_DB_PREFIX."module WHERE
						id      = ".$db->qstr($module_id)." AND
						site_id = ".$db->qstr(DEFAULT_SITE);
				$result = $db->Execute($q);
				$module_name = $result->fields['name'];

				# loop through the core array and see if this module is part of the core
				for($i=0; $i<count($core); $i++)
				{
					if($core[$i] == $module_name)
					{
						# alert message translated
						echo "This module is part of the core - it cannot be uninstalled!";
						return;
					}
				}

				# get each each group_method for this module & delete it
				$q  = "SELECT id FROM ".AGILE_DB_PREFIX."module_method WHERE
						module_id = ".$db->qstr($module_id)." AND
						site_id = ".$db->qstr(DEFAULT_SITE);
				$result = $db->Execute($q);

				while(!$result->EOF)
				{
					# delete the group methods...
					$q  = "DELETE FROM ".AGILE_DB_PREFIX."group_method WHERE
							module_id = ".$db->qstr($module_id)." OR
							method_id = ".$db->qstr($result->fields['id'])." AND
							site_id = ".$db->qstr(DEFAULT_SITE);
					$db->Execute($q);
					$result->MoveNext();
				}

				# delete each module_method
				$db = &DB();
				$q  = "DELETE FROM ".AGILE_DB_PREFIX."module_method WHERE
						module_id = ".$db->qstr($module_id)." AND
						site_id = ".$db->qstr(DEFAULT_SITE);
				$db->Execute($q);

				# delete the module record
				$db = &DB();
				$q  = "DELETE FROM ".AGILE_DB_PREFIX."module WHERE
					   id = ".$db->qstr($module_id)." AND
					   site_id = ".$db->qstr(DEFAULT_SITE);
				$db->Execute($q);


				# drop the associated database for this module
				### Load the construct XML file to get the table name...
				$C_xml = new CORE_xml;
				$xml_construct = PATH_MODULES . "" . $module_name . "/" . $module_name . "_construct.xml";
				$construct = $C_xml->xml_to_array($xml_construct);	


				### Check that this Module has any db installation required...
				if(isset($construct["construct"]["table"]))
				{
					### Create the module DB table
					$table = $construct["construct"]["table"];
					$db = &DB();
					$dict = NewDataDictionary($db);
					$sql = $dict->DropTableSQL(AGILE_DB_PREFIX.''.$table);
					$db->Execute($sql[0]);

					$table = $construct["construct"]["table"].'_id';
					$sql = $dict->DropTableSQL(AGILE_DB_PREFIX.''.$table);
					$db->Execute($sql[0]);
				}
			}					
		}
	}		

	##############################
	##	     SEARCH FORM        ##
	##############################
	function search_form($VAR)
	{
		$type = "search";
		$this->method["$type"] = split(",", $this->method["$type"]);
		$db = new CORE_database;
		 $db->search_form($VAR, $this, $type);
	}

	##############################
	##		    SEARCH		    ##
	##############################
	function search($VAR)
	{	
		$type = "search";
		$this->method["$type"] = split(",", $this->method["$type"]);
		$db = new CORE_database;
		 $db->search($VAR, $this, $type);
	}

	##############################
	##		SEARCH SHOW	        ##
	##############################

	function search_show($VAR)
	{	
		$type = "search";
		$this->method["$type"] = split(",", $this->method["$type"]);
		$db = new CORE_database;
		 $db->search_show($VAR, $this, $type);
	}	


	###################################
	##	INSTALL ERROR CHECKING: MODULE ##
	###################################
	function install_error_check($VAR)
	{
		global $smarty, $C_translate;

		###########################################
		### Check that the module name is defined:
		if(!isset($VAR["install_name"]))
		{
			 $error[] = $C_translate->translate('install_enter_name','module','');
		}
		else if ($VAR["install_name"] == '')
		{
			 $error[] = $C_translate->translate('install_enter_name','module','');
		}
		$module = trim($VAR["install_name"]);


		###########################################
		### Check that at least one group is defined:
		if(!isset($VAR["module_group"]))
			 $error[] = $C_translate->translate('install_select_group','module','');


		###########################################
		### Check if the module already exists in the Database:
		$db = &DB();
		$q  = 'SELECT name FROM '.AGILE_DB_PREFIX.'module WHERE
				name    = '.$db->qstr($module).' AND
				site_id = '.$db->qstr(DEFAULT_SITE);
		$result = $db->Execute($q);
		if($result->RecordCount() > 0)
			$error[] = $C_translate->translate('install_module_exists','module','');

		#######################################################
		### Check if the module exists in the file structure:
		if (!is_dir(PATH_MODULES . '' . $module))
			$error[] = $C_translate->translate('install_missing_dir','module','');

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '.inc.php'))
			$error[] = $C_translate->translate('install_missing_class','module','');

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '_construct.xml'))
			$error[] = $C_translate->translate('install_missing_construct','module','');

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '_install.xml'))
			$error[] = $C_translate->translate('install_missing_install','module','');

		if(isset($error))
		{
			$error[] = $C_translate->translate('install_failed','module','');

			# set the errors as a Smarty Object
			$smarty->assign('form_validation', $error);	
			return false;
		}


		###########################################
		### Load the install XML file...
		$xml_construct = PATH_MODULES . "" . $module . "/" . $module . "_install.xml";
		$C_xml = new CORE_xml;
		$install = $C_xml->xml_to_array($xml_construct);
		$this->install = $install;

		/*
		echo "<pre>";
		print_r($install);
		echo "</pre>";
		*/

		###########################################
		### Get the module properties:
		$name           = $install["install"]["module_properties"]["name"];

		if(isset($install["install"]["module_properties"]["parent"]))
		$parent         = $install["install"]["module_properties"]["parent"];
		else
		$parent         = 0;


		############################################                                          		
		### Get dependancies.... 
		if(isset($install["install"]["module_properties"]["dependancy"]))
			$dependancy     = $install["install"]["module_properties"]["dependancy"];
		else
			$dependancy     = false;

		if($dependancy)
		{
			if(ereg(',', $dependancy))
				$depend = split(',', $dependancy);
			else
				$depend[0] = $dependancy;

			###################################################
			### Check to be sure the dependancies are installed:

			for($i=0; $i < count($depend); $i++)
			{
				$db = &DB();
				$q  = 'SELECT name FROM '.AGILE_DB_PREFIX.'module WHERE
						name    = '.$db->qstr($depend["$i"]).' AND
						status  = '.$db->qstr("1").' AND
						site_id = '.$db->qstr(DEFAULT_SITE);
				$result = $db->Execute($q);
				if($result->RecordCount() == 0)
					$error[] = $C_translate->translate('install_module_depend','module','depend='.$depend["$i"]);
			}
		}

		# check for error:
		if(isset($error))
		{
			$error[] = $C_translate->translate('install_failed','module','');

			# set the errors as a Smarty Object
			$smarty->assign('form_validation', $error);	
			return false;
		}

		return true;
	}


	#####################################
	##	INSTALL ERROR CHECKING: MODULE ##
	#####################################
	function install_error_check_sub($module)
	{	
		global $smarty;

		if ($module == '')
		{
			return true;
		}

		########################################################
		### Check if the module already exists in the Database:
		$db = &DB();
		$q  = 'SELECT name FROM '.AGILE_DB_PREFIX.'module WHERE
				name    = '.$db->qstr($module).' AND
				site_id = '.$db->qstr(DEFAULT_SITE);
		$result = $db->Execute($q);
		if($result->RecordCount() > 0)
			$error[] = 'This module already exists in the database!';

		######################################################
		### Check if the module exists in the file structure:
		if (!is_dir(PATH_MODULES . '' . $module))
			$error[] = 'The specified module <b>directory</b> does not exist!';

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '.inc.php'))
			$error[] = 'The specified module <b>class file</b> does not exist!';

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '_construct.xml'))
			$error[] = 'The specified module <b>construct file</b> does not exist!';

		if (!file_exists(PATH_MODULES . '' . $module . '/' . $module . '_install.xml'))
			$error[] = 'The specified module <b>installation file</b> does not exist!';

		if(isset($error))
		{
			$error[] = '<B>Module Installation Failed</B>';

			# set the errors as a Smarty Object
			$smarty->assign('form_validation', $error);	
			return false;
		}

		return true;
	}


	###################################
	##	     INSTALL ERROR CHECKING  ##
	###################################
	function install_sql($module)
	{
		global $VAR, $smarty;

		###########################################
		### Load the install XML file...
		$C_xml = new CORE_xml;
		$xml_install = PATH_MODULES . "" . $module . "/" . $module . "_install.xml";			
		$install = $C_xml->xml_to_array($xml_install);

		###########################################
		### Load the construct XML file...
		$C_xml = new CORE_xml;
		$xml_construct = PATH_MODULES . "" . $module . "/" . $module . "_construct.xml";
		$construct = $C_xml->xml_to_array($xml_construct);

		### Check that this Module has any db installation required...
		if(isset($construct["construct"]["table"]))
		{
			### Create the module DB table
			$table = $construct["construct"]["table"];

			### Create the module DB fields
			$arr_field = $construct["construct"]["field"];

			### Loop through the fields to build the list:
			#$index_flds = 'id,site_id';
			$index_flds = '';
			while (list ($key, $value) = each($arr_field))
			{
				$field = $key;
				$t_s  = $arr_field["$key"]["type"];
				if(isset($arr_field["$key"]["index"]))
				{
					if(empty($index_flds))
					$index_flds .= $key;
					else
					$index_flds .= ','.$key;
				}

				if(ereg('[(]',$t_s))
				{
					$ts = split('[(]',$t_s);
					$type = $ts[0];
					$size = ereg_replace('[)]', '', $ts[1]); 
					$flds[] = Array($field, $type, $size); 
				}
				else
				{ 
					$flds[] = Array($field, $t_s);                        
				}
			}

			### Multi site?
			if(DEFAULT_SITE==1) 
			{ 
				### Create the table & colums using the ADODB Data Dictionary functions:
				$db = &DB();
				$dict = NewDataDictionary($db);
				$table_options = array('mysql' => 'TYPE=MyISAM');
				$sqlarray = $dict->CreateTableSQL(AGILE_DB_PREFIX.''.$table, $flds, $table_options); 
				$result = $db->Execute($sqlarray[0]);
				if ($result === false)
				{
					global $C_debug;
					$C_debug->error('module.inc.php','install_db (1)', $db->ErrorMsg() . ' '. print_r($sqlarray[0]));		
					return false;
				} 

				# Create unique index on site_id,id  (mysql specific)                       	 
				$db->Execute("CREATE UNIQUE INDEX IDS on ".AGILE_DB_PREFIX."$table (site_id, id)"); 

				# Create any custom indexes
				if(@$new_indexes = $construct["construct"]["index"])
				{                	
					while (list ($index, $fields) = each($new_indexes))
					{   
						$dict = NewDataDictionary($db); 
						if(eregi("fulltext", $index) && AGILE_DB_TYPE == 'mysql')
							$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields, array('FULLTEXT'));
						else
							$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields);
						$db->Execute($sqlarray[0]); 
					}
				}
			}      
		}


		##################################################################
		### Get the module properties:

		if(isset($install["install"]["module_properties"]["menu_display"]))
			$menu_display   = $install["install"]["module_properties"]["menu_display"];
		else
			$menu_display   = '';

		if(isset($install["install"]["module_properties"]["notes"]))
			$notes          = $install["install"]["module_properties"]["notes"];
		else
			$notes          = '';

		###################################################################
		### Get the parent module...

		$db = &DB();
		$module_id = $db->GenID(AGILE_DB_PREFIX . "" . 'module_id');
		if(isset($install["install"]["module_properties"]["parent"]))
		{
			$q = 'SELECT id FROM '.AGILE_DB_PREFIX.'module WHERE
				site_id     = '.$db->qstr(DEFAULT_SITE).' AND
				name        = '.$db->qstr($install["install"]["module_properties"]["parent"]);
			$result = $db->Execute($q);


			# Error checking
			if ($result === false)
			{
				global $C_debug;
				$C_debug->error('module.inc.php','install_db', $db->ErrorMsg());			
				return false;
			}

			if($result->fields["id"] == '')
				$parent_id = $module_id;
			else
				$parent_id = $result->fields["id"];

		}
		else
		{
			$parent_id = $module_id;
		}


		##################################################################
		### Create the module record, & get the module ID
		### get the ID of the parent, and create it as child if needed...
		### else the record is a child of itself...

		$q  = 'INSERT INTO '.AGILE_DB_PREFIX.'module SET
				id      = '     .$db->qstr($module_id).',
				site_id = '     .$db->qstr(DEFAULT_SITE).',
				name    = '     .$db->qstr($module).',
				parent_id = '   .$db->qstr($parent_id).',
				notes   =   '   .$db->qstr($notes).',
				status  = '     .$db->qstr('1').',
				menu_display = '.$db->qstr($menu_display);
		$result = $db->Execute($q);

		###################################################################
		### Create the module_method records, and get the ID for each one

		@$methods = $install["install"]["sql_inserts"]["module_method"];

		if(!empty($methods) && is_array($methods))
		{
			while (list ($key, $value) = each($methods))
			{

				$name       = $key;
				$method_id  = $db->GenID(AGILE_DB_PREFIX.'module_method_id');

				if(isset($methods[$key]["notes"]))
					$notes = $methods[$key]["notes"];
				else
					$notes = '';

				if(isset($methods[$key]["page"]))
					$page       = $methods[$key]["page"];
				else
					$page       = '';

				if(isset($methods[$key]["menu_display"]))
					$menu_display = '1';
				else
					$menu_display = '0';

				$q = 'INSERT INTO '.AGILE_DB_PREFIX .'module_method SET
					  id        = '.$db->qstr($method_id).',
					  site_id   = '.$db->qstr(DEFAULT_SITE).',
					  name      = '.$db->qstr($name).',
					  module_id = '.$db->qstr($module_id).',
					  notes     = '.$db->qstr($notes).',
					  page      = '.$db->qstr($page).',
					  menu_display = '.$db->qstr($menu_display);

				$result = $db->Execute($q);

				# Error checking
				if ($result === false)
				{
					global $C_debug;
					$C_debug->error('module.inc.php','install_db :: module_method', $db->ErrorMsg());
					return false;
				}


				###############################################################
				### Create the group_method records, with the ID from each
				### of the above methods...
				### Get the groups to add to (FROM THE install.tpl form!)

				for($i=0; $i<count($VAR["module_group"]); $i++)
				{
					$group_method_id  = $db->GenID(AGILE_DB_PREFIX  . 'group_method_id');
					$q = 'INSERT INTO '.AGILE_DB_PREFIX .'group_method SET
						  id        = '.$db->qstr($group_method_id).',
						  site_id   = '.$db->qstr(DEFAULT_SITE).',
						  method_id = '.$db->qstr($method_id).',
						  module_id = '.$db->qstr($module_id).',
						  group_id  = '.$db->qstr($VAR["module_group"][$i]);

					$result = $db->Execute($q);

					# Error checking
					if ($result === false)
					{
						global $C_debug;
						$C_debug->error('module.inc.php','install_db :: group_method_id', $db->ErrorMsg());
						return false;
					}
				}
			}
		} 

		//$db->Execute ( sqlDelete(&$db, 'module', "name IS NULL or name = '' OR parent_id IS NULL or parent_id = ''")  );

		# all done!
		return true;
	}


	##############################################
	##	     INSTALL DEFAULT DATA               ##
	##############################################
	function install_sql_data($module)
	{
			# check the file:
			$f = PATH_MODULES . '' . $module . '/' . $module . '_install_data.xml';

			if(is_file($f))
			{
				# open the XML backup file:
				$C_xml = new CORE_xml;
				$backup = $C_xml->xml_to_array($f);        			
				$db = &DB();
				$arr =  $backup['install'];  			

				# loop through each table in this array
				if(is_array($arr) )
				{
					while (list ($table,$records) = each ($arr))
					{
						$runsql = false;
						$sqls = 'INSERT INTO '.AGILE_DB_PREFIX.'' . $table . ' SET ';

						if (is_array($records) )
						{        			
							# loop through each of the fields for this module
							$sql = '';
							$sqlcount = 0;
							while (list ($fld,$val) = each ($records))
							{
								if (is_array($val))
								{
									# loop through each of the fields for this module
									$sql = '';
									$sqlcount = 0;
									while (list ($fld2,$val2) = each ($val))
									{
										if ($sqlcount != 0) $sql .= ', ';
										$sql .= $fld2 .' = '.$db->qstr($val2);
										$sqlcount++;
									}
									## echo '<BR>' . $sqls. ' ' . $sql;
									$result = $db->Execute($sqls. ' ' . $sql);

								}
								else
								{
									if ($sqlcount != 0) $sql .= ', ';
									$sql .= $fld .' = '.$db->qstr($val);
									$sqlcount++;
									$runsql = true;
								}

							}
							if ($runsql)
							{
								## echo '<BR>' . $sqls. ' ' . $sql;
								$result = $db->Execute($sqls. ' ' . $sql);
								if($result === false)
								@$this->error .= "<BR>". $sqls. ' ' . $sql;
							}
						}
					}
				} 
			}
	}


	###################################
	##         MAIN INSTALLER        ##
	###################################
	function install($VAR)
	{
		global $smarty, $C_translate;

		# check this module for any errors:
		if($this->install_error_check($VAR))
		{

			### Get sub_modules of this package
			if(isset($this->install["install"]["module_properties"]["sub_modules"]))
			{
				### Check Each Sub-module:
				$arr_sub = $this->install["install"]["module_properties"]["sub_modules"];

				if(ereg(',', $arr_sub))
					$arr_s = split(',', $arr_sub);
				else
					$arr_s[] = $arr_sub;

				for($i=0; $i<count($arr_s); $i++)
				{
					if(!$this->install_error_check_sub($arr_s[$i]))
						$error[] = $C_translate->translate('install_sub_module_err','module','sub_module='.$arr_s[$i]);
				}
			}

			# check for error:
			if(isset($error))
			{
				$error[] = $C_translate->translate('install_failed','module','');

				# set the errors as a Smarty Object
				$smarty->assign('form_validation', $error);	
				return false;
			}


			### install the SQL...
			$module = trim($VAR["install_name"]);
			if($this->install_sql($module))
			{
				### Loop through the sub-modules and install each of them
				if(isset($arr_s))
				{
					for($i=0; $i<count($arr_s); $i++)
					{
						if(!$this->install_sql($arr_s[$i]))
						{
							### Errors in install_sql(), then delete any SQL changes!
							### set smarty error
							return;
						}

					}
				}
			}
			else
			{
				### Errors in install_sql(), then delete any SQL changes!
				### set smarty error
				return;
			}

			### Insert default data: 
			$this->install_sql_data($module);
		}

		# update the current user's authentication so the update group access applies
		# to them
		global $C_auth;
		$C_auth->auth_update();
	}


	###################################
	##     AUTO UPGRADER             ##
	###################################
	function upgrade($VAR)
	{
		if(!isset($VAR['module_name']) || !isset($VAR['module_group']))
		{
			echo "You must select both the module(s) to upgrade and the groups to grant access to new methods to.";
			return;
		}

		$module_count = 0;
		$method_count = 0;
		$fields_count = 0;
		$method_new_count = 0;
		$fields_new_count = 0;

		# loop through each module
		$modules = $VAR['module_name'];

		for($i=0; $i<count($modules); $i++)
		{             
			# increment module count
			$module_count++;

			# get the module details
			$db     = &DB();
			$db_module = $db->Execute(sqlSelect($db,"module","*","id=::{$modules[$i]}:: or name=::{$modules[$i]}::"));                
			$module_name = $db_module->fields['name'];
			$module_id   = $db_module->fields['id'];

			#########################################################################
			# Update the Methods from the <module>_install.xml file
			# get the install xml file
			#########################################################################

			$install_xml = PATH_MODULES.$module_name.'/'.$module_name.'_install.xml';
			if(is_file($install_xml))
			{
				$C_xml = new CORE_xml;
				@$methods = $C_xml->xml_to_array($install_xml);
				@$methods = $methods['install']['sql_inserts']['module_method'];

				# loop through the methods
				if(is_array($methods))
				{
					while (list ($key, $value) = each($methods))
					{
						# increment method count
						$method_count++;

						# see if this method exists
						$sql    = 'SELECT * FROM ' . AGILE_DB_PREFIX . 'module_method WHERE
								   name         =  ' . $db->qstr( $key ) . ' AND
								   module_id    =  ' . $db->qstr( $module_id ) . ' AND
								   site_id      =  ' . $db->qstr(DEFAULT_SITE);
						$method_db  = $db->Execute($sql);                             
						if ($method_db === false)  {
							global $C_debug;
							$C_debug->error('module.inc.php','upgrade', $db->ErrorMsg());
						}
						if($method_db->RecordCount() == 0)
						{
							# increment method count
							$method_new_count++;

							### add this method
							@$notes          = $methods[$key]["notes"];
							@$page           = $methods[$key]["page"];
							@$menu_display   = $methods[$key]["menu_display"];

							$method_id = sqlGenID($db, 'module_method');
							$fields=Array('name'=>$key, 'module_id'=>$module_id, 'notes'=>$notes, 'page'=>$page, 'menu_display'=>$menu_display);
							$db->Execute(sqlInsert($db,"module_method",$fields, $method_id));                           
							if ($result === false)  {
								global $C_debug;
								$C_debug->error('module.inc.php','upgrade', $db->ErrorMsg());
							}

							### Create the group_method records, with the ID from each
							for($ii=0; $ii<count($VAR["module_group"]); $ii++)
							{
								$group_method_id  = $db->GenID(AGILE_DB_PREFIX . "" . 'group_method_id');
								$q = 'INSERT INTO '.AGILE_DB_PREFIX .'group_method SET
									  id        = '.$db->qstr($group_method_id).',
									  site_id   = '.$db->qstr(DEFAULT_SITE).',
									  method_id = '.$db->qstr($method_id).',
									  module_id = '.$db->qstr($module_id).',
									  group_id  = '.$db->qstr($VAR["module_group"][$ii]);
								$result = $db->Execute($q);                                     
								if ($result === false) {
									global $C_debug;
									$C_debug->error('module.inc.php','upgrade', $db->ErrorMsg());
								}
							}
						}
					}
				} 
			}


			#########################################################################
			# Update the DB Fields from the <module>_construct.xml file
			# get the install xml file
			#########################################################################

			$construct_xml = PATH_MODULES.$module_name.'/'.$module_name.'_construct.xml';
			if(is_file($construct_xml))
			{
				$C_xml = new CORE_xml;
				$construct = $C_xml->xml_to_array($construct_xml);
				@$fields = $construct['construct']['field'];

				### Check that this Module has any db installation required...
				if(!empty($construct["construct"]["table"]) && $construct["construct"]["table"] == $module_name)
				{
					### Create the module DB table
					$table = $construct["construct"]["table"];
					$db = &DB();
					$db_fields = $db->MetaColumns(AGILE_DB_PREFIX.$table, true);

					### Create the module DB fields
					$arr_field = $construct["construct"]["field"];

					### Loop through the fields to build the list: 
					while (list ($key, $value) = each($arr_field))
					{
						$field = $key;
						$FIELD = strtoupper($key);
						if(!isset($db_fields[$FIELD]))
						{
							# increment field count
							$fields_new_count++;

							$t_s  = $arr_field["$key"]["type"]; 
							if(ereg('[(]',$t_s))
							{
								$ts = split('[(]',$t_s);
								$type = $ts[0];
								$size = ereg_replace(')', '', $ts[1]);
								$flds[] = Array($field, $type, $size); 
							}
							else
							{ 
								$flds[] = Array($field, $t_s); 
							}
						}
					}

					### Add any new columns:
					if(is_array(@$flds))
					{
						$dict = NewDataDictionary($db);
						$sqlarray = $dict->AddColumnSQL(AGILE_DB_PREFIX.$table, $flds);
						$result = $db->Execute($sqlarray[0]);
						if ($result === false) {
							global $C_debug;
							$C_debug->error('module.inc.php','install_db', $db->ErrorMsg());
							echo $db->ErrorMsg();
						}
						unset($flds);
					}


					### Remove any unused columns
					while (list ($key, $value) = each($db_fields))
					{
						$fieldname = strtolower($key);
						if(!isset($construct["construct"]["field"][$fieldname])) $flds[] = $key;

					}
					if(is_array(@$flds))
					{
						$dict = NewDataDictionary($db);
						$sqlarray = $dict->DropColumnSQL(AGILE_DB_PREFIX.$table, $flds);

						$sqlarray[0];
						$result = $db->Execute($sqlarray[0]);
						if ($result === false) {
							global $C_debug;
							$C_debug->error('module.inc.php','install_db', $db->ErrorMsg());
							echo $db->ErrorMsg();
						}
						unset($flds);
					} 


					####################################################
					### Update Indexes: 

					# Get old database indexes
					$dict = NewDataDictionary($db);
					$oldindex = $dict->MetaIndexes(AGILE_DB_PREFIX.$table);

					# check if the 'site_id' index exists:
					if(!empty($oldindex['site_id']) && $oldindex['site_id'] = 'id,site_id') { 
						$dict = NewDataDictionary($db);
						$sqlarray = $dict->DropIndexSQL('site_id', AGILE_DB_PREFIX.$table); 
						$db->Execute($sqlarray[0]);
					}

					# check that that UNIQUE index for site_id,id exists
					if(empty($oldindex['IDS']) || $oldindex['IDS']['unique'] != 1) 
					{ 	  
						$db=&DB();
						$db->Execute("alter table ".AGILE_DB_PREFIX."$table drop primary key");                         	 
						$db->Execute("CREATE UNIQUE INDEX IDS on ".AGILE_DB_PREFIX."$table (site_id, id)"); 
					}

					$dict = NewDataDictionary($db);
					$oldindex = $dict->MetaIndexes(AGILE_DB_PREFIX.$table);

					# Current construct invoices 
					if(@$new_indexes = $construct["construct"]["index"])
					{
						while (list ($index, $fields) = each($new_indexes))
						{   
							if(is_array(@$oldindex[$index]))
							{
								# already exists - compare fields: 
								$oldfields = implode(",", $oldindex[$index]['columns']);

								if($oldfields != $fields)
								{    
									# index changed - drop: 
									$dict = NewDataDictionary($db);
									$sqlarray = $dict->DropIndexSQL($index, AGILE_DB_PREFIX.$table); 

									$db->Execute($sqlarray[0]); 

									# create index
									$dict = NewDataDictionary($db); 

									if(eregi("fulltext", $index) && AGILE_DB_TYPE == 'mysql')                  
										$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields, array('FULLTEXT')); 
									else 
										$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields); 				                        
									$db->Execute($sqlarray[0]); 
								} 
							} 
							else 
							{  
								# index does not exist - create!
								$dict = NewDataDictionary($db);

								if(eregi("fulltext", $index) && AGILE_DB_TYPE == 'mysql')                  
									$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields, array('FULLTEXT')); 
								else 	                        		
									$sqlarray = $dict->CreateIndexSQL($index, AGILE_DB_PREFIX.$table, $fields); 
								$db->Execute($sqlarray[0]);
							}

							$verify_index[] = $index;
						}

						# Check for removed indexes:
						if(!empty($oldindex))
						{
							reset($oldindex);
							while (list ($index, $fields) = each($oldindex))
							{
								if(!isset($new_indexes[$index]) && $index != 'IDS')
								{
									$dict = NewDataDictionary($db);
									$sqlarray = $dict->DropIndexSQL($index, AGILE_DB_PREFIX.$table); 
									$db->Execute($sqlarray[0]);                     			
								}
							} 
						}
					}
					else
					{
						# remove all old indexes
						if(!empty($oldindex))
						{ 
							reset($oldindex);
							while (list ($index, $fields) = each($oldindex))
							{
								if($index != 'IDS')
								{
									$dict = NewDataDictionary($db);
									$sqlarray = $dict->DropIndexSQL($index, AGILE_DB_PREFIX.$table);  
									$db->Execute($sqlarray[0]);           
								}         			
							} 
						}
					}                        
				}
			}
		}

		$msg =  "Successfully checked $module_count module(s), $method_count method(s), ".
				"and $fields_count db fields. <BR>".
				"Added $method_new_count method(s) and $fields_new_count db field(s).";


		if(!empty($fields_new_count) > 0) {
			$js = '<script language="javascript">document.getElementById("module_add").submit();</script>';
			global $smarty;
			if(is_object($smarty))
				$smarty->assign('js', $js);
			else
				echo '<script language="javascript">document.refresh();</script>';
		}


		# Display the message.
		global $C_debug;
		if(is_object($C_debug)) 
			$C_debug->alert($msg);
		else
			echo $msg;

		# update the current user's authentication so the update group access applies
		# to them
		global $C_auth;
		if(is_object($C_auth)) $C_auth->auth_update();

	}


	# Create the install XML file for specified modules
	function dev_install_gen($VAR)
	{

		# loop through each module passed...
		include_once('dev.inc.php');
		$db = &DB();

		if(is_array($VAR['module'])) 
		{
			for($ix = 0; $ix<count($VAR['module']); $ix++)
			{ 
				$sql  = "SELECT * FROM ".AGILE_DB_PREFIX."module  WHERE 
						id 		= ".$db->qstr($VAR['module'][$ix])." AND
						site_id = ".$db->qstr(DEFAULT_SITE);
				$result = $db->Execute($sql);
				while(!$result->EOF)
				{ 
						# update the {module}_install.xml file data
						$xml = dev_install_xml_gen($result->fields['name'],$result->fields['id']);

						# write the file
						$file = fopen(PATH_MODULES . '' . $result->fields['name'] . '/'. $result->fields['name'] . "_install.xml", "w+");
						fputs($file, $xml);
						fclose($file);

						$do = true;
						for($i=0; $i<count($this->dev_inst_excl); $i++)
						{
							if ( $this->dev_inst_excl[$i] == $result->fields['name'])
							{
								$do = false;
							}
						}

						if ($do)
						{
							# update/create the {$module}_install_data.xml file data
							$xml = dev_install_xml_data($result->fields['name'],$result->fields['id']);
						}
						else
						{
							/*
							$xml = '<?xml version="1.0" encoding="ISO-8859-1" ?'.''.'>';
							$xml .= '
<install>
</install>';
							*/
							$xml = false;
						}

						# write the file
						if($xml != false)
						{
							$file = fopen(PATH_MODULES . '' . $result->fields['name'] . '/'. $result->fields['name'] . "_install_data.xml", "w+");
							fputs($file, $xml);
							fclose($file);
						}

						# next module
						$result->MoveNext();
				}
			}
		}
	}


	# add a new module construct
	function dev_add($VAR)
	{

		# check if the needed directories exist & attempt to create...

		if (!is_dir(PATH_MODULES . '' . $VAR["module"])) {
			echo "<BR>Path does not exist, attempting to create: ".PATH_MODULES . '' . $VAR["module"];
			if(!mkdir(PATH_MODULES . '' . $VAR["module"])) {
				echo "<BR><BR>Error: Module creation failed, please check path permissions...<BR>";
				return false;
			}
		}

		if (!is_dir(PATH_LANGUAGE . '' . $VAR["module"])) {
			echo "<BR>Path does not exist, attempting to create: ".PATH_LANGUAGE . '' . $VAR["module"];
			if(!mkdir(PATH_LANGUAGE . '' . $VAR["module"])) {
				echo "<BR><BR>Error: Module creation failed, please check path permissions...<BR>";
				return false;
			}
		}


		if (!is_dir(PATH_THEMES . 'default/blocks/' . $VAR["module"])) {
			echo "<BR>Path does not exist, attempting to create: ".PATH_THEMES . 'default/blocks/' . $VAR["module"];
			if(!mkdir(PATH_THEMES . 'default/blocks/' . $VAR["module"])) {
				echo "<BR><BR>Error: Module creation failed, please check path permissions...<BR>";
				return false;
			}
		}


		# include the dev functions:
		include('dev.inc.php');

		$construct_xml = dev_construct_xml($VAR);
			# write the consruct XML
			$file = fopen(PATH_MODULES . '' . $VAR["module"] . '/'. $VAR["module"] . "_construct.xml", "w+");
			fputs($file,$construct_xml);
			fclose($file);


		$construct_php  = dev_construct_php($VAR);
			# write the construct PHP
			$file=fopen(PATH_MODULES . '' . $VAR["module"] . '/'. $VAR["module"] . ".inc.php", "w+");
			fputs($file,$construct_php);
			fclose($file);


		$language_xml   = dev_language_xml($VAR);
			# write the language packs
			$file=fopen(PATH_LANGUAGE . '' . $VAR["module"] . "/english_" . $VAR["module"] . ".xml", "w+");
			fputs($file, $language_xml);
			fclose($file);


		$install_xml   = dev_install_xml($VAR);
			# write the language packs
			$file = fopen(PATH_MODULES . '' . $VAR["module"] . '/'. $VAR["module"] . "_install.xml", "w+");
			fputs($file, $install_xml);
			fclose($file);


		# generate the main block
		$main_tpl   = dev_block_main($VAR);
			# write the block
			$file = fopen(PATH_THEMES . 'default/blocks/' . $VAR["module"] . "/main.tpl", "w+");
			fputs($file, $main_tpl);
			fclose($file);

		# generate the add block
		$add_tpl   = dev_block_add($VAR);
			# write the block
			$file = fopen(PATH_THEMES . 'default/blocks/' . $VAR["module"] . "/add.tpl", "w+");
			fputs($file, $add_tpl);
			fclose($file);

		# generate the view block
		$view_tpl   = dev_block_view($VAR);
			# write the block
			$file = fopen(PATH_THEMES . 'default/blocks/' . $VAR["module"] . "/view.tpl", "w+");
			fputs($file, $view_tpl);
			fclose($file);

		# generate the search_form block
		$search_form_tpl   = dev_block_search_form($VAR);
			# write the block
			$file = fopen(PATH_THEMES . 'default/blocks/' . $VAR["module"] . "/search_form.tpl", "w+");
			fputs($file, $search_form_tpl);
			fclose($file);

		# generate the search_show block
		$search_show_tpl   = dev_block_search_show($VAR);
			# write the block
			$file = fopen(PATH_THEMES . 'default/blocks/' . $VAR["module"] . "/search_show.tpl", "w+");
			fputs($file, $search_show_tpl);
			fclose($file);
	}
}
?>