Common Functions

Common functions for database and other stuffs.
<?php

class common {

	
		static private $link = NULL;
		static private $linki = NULL;
		private $config = NULL;

		function __construct() {

			// ini_set('include_path', ini_get('include_path').';'.BASEPATH.'application/my_classes/');
			// ini_set('register_globals','off');
			// ini_set('max_input_time','600');

			include("./config.php");
			$this->config = $config;
		}
	
		
		function check_user() {
		
			$user_id = "";
			$id = "";
			$user_id = $this->common->get_encrypted_id();
			$uid = $this->common->value('uid');
	
			if( (empty($user_id)) ) {
				$session_id = '';
				$session_id = $_SESSION['userid'];
				if(!empty($session_id)) {
					$msg = "<BR/>session exists($session_id)";
					$id = $session_id;
				}
				else if(!empty($uid)) {
					$msg = "<BR/>uid found($uid)";
		   			$id = $uid;
				}
			}
			else {
	
				$session_id = '';
				$session_id = $_SESSION['userid'];
				if(!empty($session_id)) {
				
					if( $user_id == $session_id ) {
						$msg = "<BR/>Session($session_id) & user_id($user_id) matches";
						$id = $session_id;
					}
					else {
						$msg = "<BR/>Session($session_id) exist but not matches with user_id($user_id)";
			   			$id = $user_id;
					}		
				}
				else {
					$msg = "<BR/>Session not exist, user_id($user_id)";
		   			$id = $user_id;
				}
			}
			
//			echo $msg.", User_id=".$id; exit;
			
			if(empty($id)) {
				// Redirecting into login page
				$url = "http://www.google.co.in";
				header("location:".$url);
			}
			else {
				$_SESSION['userid'] = $id;
				return true;
			}
		}
		
		
		function get_body($body, $type) {
			
			$body = $this->get_absolute_value($body);
			$newline="\n";
			$content_type = strtolower($type);
			$company_address = $this->config->config['organisation_details'];
			$unsubscribe_ar  = $this->config->config['unsubscribe_ar'];
			
			
			if($content_type == "plain") {
					$str = "";
					
					$str .= $newline. $body . $newline.$newline.$newline.$this->remove_html(html_entity_decode($company_address));
					
					return $str;
			}
			
			
			if($content_type == "html") {
				
					$str = "";
					$html_head = "";
					$html_foot = "";
					
					$html_head .= $newline.$newline.'<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
					$html_head .= $newline.'<html xmlns="http://www.w3.org/1999/xhtml">';
					$html_head .= $newline.'<head>';
					$html_head .= $newline.'<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />';
					$html_head .= $newline.'<title>Test document</title>';
					$html_head .= $newline.'</head>';
					$html_head .= $newline.'<body>';
					
					$html_foot .= $newline.$newline.$newline.$company_address;
					$html_foot .= $newline.$newline.$newline.$unsubscribe_ar;
					
					$html_foot .= $newline.'</body>';
					$html_foot .= $newline.'</html>';
					
					$str .= $html_head . $body . $html_foot;
					
					return $str;
			}
		}
		
		
		function replace_personalized_text($body, $buyer_array, $user_array, $mail_type="html") {
			
			$content = $this->get_body($body, $mail_type);
			$access_code = $this->encode($buyer_array->first_name, $buyer_array->last_name);
			
			$replace = array(
							'buyer_first_name' 	=> $this->value('first_name', '', $buyer_array),
							'buyer_last_name' 	=> $this->value('last_name', '', $buyer_array),
							'buyer_email' 		=> $this->value('email', '', $buyer_array),
							'buyer_phone' 		=> $this->value('phone', '', $buyer_array),
							'my_first_name' 	=> $this->value('first_name','',$user_array),
							'my_last_name' 		=> $this->value('last_name','',$user_array),
							'my_email' 			=> $this->value('email','',$user_array),
							'my_phone' 			=> $this->value('phone','',$user_array),
							'subscribe_ar'		=> BASEURL.'guest/subscribe/'.$buyer_array->id.'/'.$access_code,
						);
			
			while( is_array($replace) && list($key,$value) = each($replace) ) {

						$patterns[] = '/&lt;&lt; ' . $key . ' &gt;&gt;/';
						$patterns[] = '/<< ' . $key . ' >>/';
						
						
						foreach ($patterns as $pattern) {
							$content = preg_replace($pattern, $value, $content);
						}
			}
			
			return $content;
		}
		
		
		function remove_html($str) {
			$patterns = "/<\/?[^>]*>/";
			$content = preg_replace($patterns, "", $str);
			return htmlspecialchars($content);
		}
		
		
		function connect_smtp() {
				try {
	
				require_once "./libraries/swift/Swift.php";
				require_once "./libraries/swift/Swift/Connection/SMTP.php";
				require_once "./libraries/swift/Swift/Authenticator/LOGIN.php";				
	
				$smtp =& new Swift_Connection_SMTP($this->config['smtp_host']);
				
				//Continue like normal
				$smtp->setUsername($this->config['smtp_user']);
				$smtp->setPassword($this->config['smtp_pass']);
				
				$swift =& new Swift($smtp);
				return $swift;
				 
				}
				catch (Swift_ConnectionException $e) {
	  				echo "There was a problem communicating with SMTP: " . $e->getMessage();
	  				exit;
				}	
		}		
		
		
		/**
		 * Enter description here...
		 * 
		 * ex - $result = $this->common->send_mail(array('Manoj Verma' => 'manoj.verma@hytechpro.com', 'Manu' => 'manabendra.sarkar@hytechpro.com'), array('Manojkumar' => 'manoj.verma@hytechpro.com'), 'test', 'testing purpose mail');
		 *
		 * @param array $to
		 * @param array $from
		 * @param string $sub
		 * @param text $body
		 * @param string $mail_type
		 * @param object $swift
		 * @return mixed
		 */
		function send_mail($to=array(), $from=array(), $sub, $body, $mail_type='html', $swift=false, $undisclosed=true, $attachment=array('browse_field_name' => 'attachment')) {
		
			$return = false;
			
			if(!$swift) {
				$swift = $this->connect_smtp();
			}
			
			
			$content_type = "text/html";
			if(strtolower($mail_type) == "plain") {
				$content_type = "text/plain";
			}
			
			try {
					
				//Create the message
				$message =& new Swift_Message($sub, $body, $content_type);
				
				// preparing from address
				if($this->check_array($from)) {
					foreach ($from as $from_name => $from_email) {
						
						if(is_string($from_name)) {
							$from_address = new Swift_Address($from_email, $from_name);
						}
						else {
							$from_address = new Swift_Address($from_email);
						}
					}
				}
				else {
					$this->log_msg('Common::send_mail() --> Please mention from email address.');
					return false;
				}
				
				// Preparing to addressess
				$recipients =& new Swift_RecipientList();
				if($this->check_array($to)) {
					
					if(count($to) > 1) {
						if($undisclosed == true) {
							$message->setTo("undisclosed-recipients:;");
						}
					}
					else {
						$to_email = array_values($to);
						// setting header
						$message->headers->set("To", array($to_email[0]));
					}
					
					foreach ($to as $to_name => $to_email) {
						if(is_string($to_name)) {
							$recipients->addTo($to_email, $to_name);
						}
						else {
							$recipients->addTo($to_email);
						}
					}
				}
				else {
					$this->log_msg('Common::send_mail() --> Please mention to email address.');
					return false;
				}

				
				// Attachment
				if($this->check_array($_FILES)) {
					$attachment_fieldname = $attachment['browse_field_name'];
				    $attachment_name = $_FILES[$attachment_fieldname]['name'];
				    if(!empty($attachment_name)) {
				    	
						    $arr = explode(".", $attachment_name);
						    $extentsion = $arr['1'];
						  	$attachment_type = "application/".$extentsion;
						   	$attachment_path = $_FILES[$attachment_fieldname]['tmp_name'];
	
							$swift_file = new Swift_File($attachment_path);
							$part =& new Swift_Message_Part($body, $content_type);
							$message->attach(new Swift_Message_Attachment($swift_file, $attachment_name, $attachment_type));
							$message->attach($part);
				    }
				}

				
				if ($number_sent = $swift->send($message, $recipients, $from_address)) {
					$msg = "Mail has been sent to ($number_sent) users.";
					$return = $number_sent;
				}
				else {
					$msg = "Unexpected error occured when sending mail.";
					$return = false;
				}
				
			}
			catch (Swift_Message_MimeException $e) {
	  			$msg = "There was an unexpected problem building the email:" . $e->getMessage();
	  			$return = false;
			}
			
			$this->log_msg($msg);
		
			return $return;
		}
		
		
		function check_email($address){

			// check an email address is possibly valid
			  if(ereg("^[^@ ]+@[^@ ]+\.[^@ ]+$",$address,$trashed))
			    return true;
			  else 
			    return false;
		}


		function find_client_ip()
		{

			global $_SERVER;

			// No IP found (will be overwritten by for
			// if any IP is found behind a firewall)
			$ip = FALSE;

//			$this->print_rr($_SERVER);

			// If HTTP_CLIENT_IP is set, then give it priority
			if (!empty($_SERVER["HTTP_CLIENT_IP"])) {
				$ip = $_SERVER["HTTP_CLIENT_IP"];
			}
		   
			// User is behind a proxy and check that we discard RFC1918 IP addresses
			// if they are behind a proxy then only figure out which IP belongs to the
			// user.  Might not need any more hackin if there is a squid reverse proxy
			// infront of apache.
			if (!empty($_SERVER['HTTP_X_FORWARDED_FOR'])) {

				// Put the IP's into an array which we shall work with shortly.
				$ips = explode (", ", $_SERVER['HTTP_X_FORWARDED_FOR']);
				if ($ip) { array_unshift($ips, $ip); $ip = FALSE; }

				for ($i = 0; $i < count($ips); $i++) {
					// Skip RFC 1918 IP's 10.0.0.0/8, 172.16.0.0/12 and
					// 192.168.0.0/16
					if (!preg_match('/^(?:10|172\.(?:1[6-9]|2\d|3[01])|192\.168)\./', $ips[$i])) {
						if (version_compare(phpversion(), "5.0.0", ">=")) {
							if (ip2long($ips[$i]) != false) {
								$ip = $ips[$i];
								break;
							}
						} else {
							if (ip2long($ips[$i]) != -1) {
								$ip = $ips[$i];
								break;
							}
						}
					}
				}
			}
			// Return with the found IP or the remote address
			return ($ip ? $ip : $_SERVER['REMOTE_ADDR']);
		}

		
		#######################
		## MYSQL_I api Start
		#######################

		function connect_mysqli() {
			
			$link = mysqli_connect($this->config["db_host"], $this->config["db_user"], $this->config["db_pass"], $this->config["db_name"]);
			if (!$link) {
			   die ('i Mysqli connection failed: ' . mysqli_connect_error());
			}
			else {
				$this->linki = $link;
			}
		}

	
		function execute_queryi($query='') {
			
			if (empty($query)) {
				
				$this->log_msg("Common::execute_queryi() --> Query can not be empty.", "#888888");
				return '';
			}
			else {
				if( self::$linki == NULL ) {
					$this->connect_mysqli();
				}				
			}
			
			// execute query
			$mtime = explode(" ", microtime());
			$start = doubleval($mtime[1]) + doubleval($mtime[0]); 
			
			$result = @mysqli_query($this->linki, $query);
			
			$mtime = explode(" ", microtime());
			$end   = doubleval($mtime[1]) + doubleval($mtime[0]);
			$time_elapsed = number_format(abs($start - $end), 5, '.', '');
			
			// if error occured
			if (!$result) {
				$error = @mysqli_error($this->linki);
				$this->log_msg("Common::execute_queryi() --> Error in query: [ $query ] ($time_elapsed), Mysqli error: ".$error);
			}
			else {
				if(is_object($result)) {
					$num_rows = @mysqli_num_rows($result);
					$this->log_msg("Common::execute_queryi() --> Num Rows: $num_rows, [ $query ] ($time_elapsed)", "#8686D9");
				}
				else {
					$affected_rows = @mysqli_affected_rows($this->linki);
					$this->log_msg("Common::execute_queryi() --> Affacted Rows: $affected_rows, [ $query ] ($time_elapsed)", "#8686D9");
				}
			}
			
			return $result;	
		}
		
		
		function get_primarykeyi($table) {
			
		    $sql = "SELECT * FROM `".$table."`;";
		    // execute query
		    $result = $this->execute_queryi($sql);
		  
		    if($result) {
		  		$fields = @mysqli_fetch_fields($result);
//	  			$this->print_rr($fields);
		  		foreach ($fields as $field) {
		  			if($field->type == 253) {
		  				$pk = $field->orgname;
		  				return $pk;
		  			}
		  		}
			}
			return false;
		}
		
		#######################
		## MYSQL_I api Ends
		#######################
		
		
		/**
		 * Returns a string representation of the date, of differing format
		 * depending on how recent the date is.
		 *
		 * @param  int    		$_date Unix timestamp of the date.
		 * @return string		String representation of the date.
		 */
		function nice_date( $_date ) {
			$date_ymd = date( "Ymd", $_date );
			$now = time();
			
			if ( $date_ymd == date( "Ymd", $now + 86400 ) ) { // tomorrow
				return "Tomorrow";
			} elseif ( $date_ymd == date( "Ymd", $now ) ) { // today
				return "Today";
			} elseif ( $date_ymd == date( "Ymd", $now - 86400 ) ) { // yesterday
				return "Yesterday";
			} elseif ( ( $now < $_date ) && ( abs( $now - $_date ) < 518400 ) ) { // next week
				return "Next ".date( "l", $_date );
			} elseif ( ( $now > $_date ) && ( abs( $now - $_date ) < 518400 ) ) { // previous week
				return "Last ".date( "l", $_date );
			} elseif ( date( "Y", $now ) == date( "Y", $_date ) ) { // this year
				return date( "j M", $_date );
			} else {
				return date( "j M Y", $_date );
			}
		}
		
		/**
		 * Returns a string representation of the date and time, of differing format
		 * depending on how recent the date is.
		 *
		 * @param  int    $_datetime Unix timestamp of the date.
		 * @return string            String representation of the date and time.
		 */
		function nice_datetime( $_datetime ) {
			$datetime_ymd = date( "Ymd", $_datetime );
			return $this->nice_date( $_datetime ).", ".date( "g:ia", $_datetime );
		}
		
		
		/**
		 * This function returns difference between two days.
		 *
		 * @param timestamp $start
		 * @param timestamp $end
		 * @return integer
		 */
		function daysInSpan($start,$end='')
		{
			if(empty($end)) {
				$today=getdate();
//    			$yesterday=mktime(0,0,0,$today[mon],$today[mday]-1,$today[year]);
    			$today=mktime(0,0,0,$today['mon'],$today['mday'],$today['year']);
    			
    			$end = $today;
			}
		    return (($end-$start)/86400);
		}
		
		
#################################################################################################		
#################################################################################################
#################################################################################################
#################################################################################################
#################################################################################################
		
		
		function get_primarykey($table) {
			
		    $sql = "SELECT * FROM `".$table."`;";
		    // execute query
		    $result = $this->execute_query($sql);
		  	
		    if($result)
		    for($i = 0; $i < @mysql_num_fields($result); $i++) {
		      if(eregi(".*primary_key.*", @mysql_field_flags($result, $i))){
		        $pk=@mysql_field_name($result, $i);
						@mysql_free_result($result);
						return $pk;
					}
		    }
		    
		    return false;
		}
		
		
		function connect_mysql() {
			
			$link = mysql_connect($this->config["db_host"], $this->config["db_user"], $this->config["db_pass"]);
			if (!$link) {
			   die ('Mysql connection failed: ' . mysql_error());
			}
			$db_selected = mysql_select_db($this->config["db_name"], $link);
			if (!$db_selected) {
			   die ('Can not able to open database : ' . mysql_error());
			}
			else {
				$this->link = $link;
			}
		}

	
		function execute_query($query='') {
			
			if (empty($query)) {
				
				$this->log_msg("Common::execute_query() --> Query can not be empty.", "#888888");
				return '';
			}
			else {
				if( self::$link == NULL ) {
					$this->connect_mysql();
				}				
			}
			
			// execute query
			$mtime = explode(" ", microtime());
			$start = doubleval($mtime[1]) + doubleval($mtime[0]); 
			
			$result = @mysql_query($query);
			
			$mtime = explode(" ", microtime());
			$end   = doubleval($mtime[1]) + doubleval($mtime[0]);
			$time_elapsed = number_format(abs($start - $end), 5, '.', '');
			
			// if error occured
			if (!$result) {
				$error = @mysql_error();
				$this->log_msg("Common::execute_query() --> Error in query: [ $query ] ($time_elapsed), Mysql error: ".$error);
			}
			else {
				if(is_resource($result)) {
					$num_rows = @mysql_num_rows($result);
					$this->log_msg("Common::execute_query() --> Num Rows: $num_rows, [ $query ] ($time_elapsed)", "#8686D9");
				}
				else {
					$affected_rows = @mysql_affected_rows();
					$this->log_msg("Common::execute_query() --> Affacted Rows: $affected_rows, [ $query ] ($time_elapsed)", "#8686D9");
				}
			}
			
			return $result;	
		}
		
		
		function fetch_result($result, $fetch_type="") {
			
			$returnValue = array();
			if(is_resource($result)) {
				if(@mysql_num_rows($result) > 0 ) {
						switch($fetch_type)
						{
							case '0':
								$array = array();
								while($row = @mysql_fetch_row($result)) {
									$array[] = $row;
								}
							break;
							case '1':
								// returns associative array
								$array = array();
								while($row = @mysql_fetch_assoc($result)) {
									$array[] = $row;
								}
							break;							
							case '2':
								// returns object type
								$array = array();
								while($row = @mysql_fetch_object($result)) {
									$array[] = $row;
								}
							break;
							case '3':
								$array = @mysql_fetch_row($result);
							break;							
							case '4':
								$array = @mysql_fetch_assoc($result);
							break;
							case '5':
								$array = @mysql_fetch_object($result);
							break;							
							default:
								$array = @mysql_fetch_assoc($result);
							break;
						}
					// gets momory free
					@mysql_free_result($result);
					if($this->check_array($array)) {
						$returnValue = $array;
						return $returnValue;
					}
					else {
						return false;
					}
				}
				else {
					return false;
				}
			}
			else {
				return false;
			}
		}
		
		
		function get_row($table, $id="", $fields="") {
			
			if(empty($fields)) $fields="*";
			
			if (!empty($id)) {
				$pk = $this->get_primarykey($table);
				if(!$pk) return false;
				$sql = "SELECT $fields FROM $table WHERE $pk='$id'";
			}
			else {
				$sql = "SELECT $fields FROM $table LIMIT 0 , 1";
			}
			
			$rs = $this->execute_query($sql);
			$row = $this->fetch_result($rs);

		   	if($fields != '*') {
		   		return $row[$fields];
		   	}
	
	   	   	return $row;
		}
		
		
		function get_rows($table, $condition="", $fields="", $fetch_type='1') {
			
			if(empty($fields)) $fields="*";
			
			if (!empty($condition)) {
				$sql = "SELECT $fields FROM $table WHERE $condition";
			}
			else {
				$sql = "SELECT $fields FROM $table";
			}
			
			$rs = $this->execute_query($sql);
			$rows = $this->fetch_result($rs, $fetch_type);
			
			return $rows;
		}
		
		
		function get_result($sql="", $fetch_type="1") {
			
			$rs = $this->execute_query($sql);
			$rows = $this->fetch_result($rs, $fetch_type);
				
			return $rows;			
		}
		
		
		function select($table='', $arr=array(), $where='') {
			
			if(empty($table)) {
				return false;
			}
			
			$result = self::execute_query("SELECT * FROM $table LIMIT 0,1");
			$columns = @mysql_num_fields($result);
			// getting list of columns of the specified table.
			for ($i = 0; $i < $columns; $i++) {
			  $fieldarr[] = @mysql_field_name($result, $i);
			}		

			$fields = '';
			$i=1;
			if($this->check_array($arr)) {
				
					foreach ($arr as $key => $field_name) {
						
					  $total = count($arr);
					  
					  // Appending ',' after field name
					  if (in_array ($field_name, $fieldarr)) {
					  	$fields .= $field_name;
					  	if($i != $total) {
							$fields .= ",";
					  	}
					  }
					  $i++;
					}
			}
			else {
				$fields = '*';
			}
			
			$sql = "SELECT $fields FROM $table";
			
			if(!empty($where))
			$sql .= " where ".$where;
             
			// executing query.
			$result = self::get_result($sql);
			return $result;				
					
		}
		
		
		function insert($table, $arr) {
				
			$result = self::execute_query("SELECT * FROM $table LIMIT 0,1");
			$columns = @mysql_num_fields($result);
			// getting list of columns of the specified table.
			for ($i = 0; $i < $columns; $i++) {
			  $fieldarr[] = @mysql_field_name($result, $i);
			}
			
			// building insert statement.
			$sqla = "INSERT INTO $table ( ";
			$sqlb = ") VALUES ( ";
			foreach ($arr as $name => $value) {
			  if (in_array ($name, $fieldarr)) {
				$sqla .= "$name,";
				if (is_array($value)) {
				  $sqlb .= "'|";
				  $j = count($value);
				  for ($i = 0; $i < $j-1; $i++) {
					$sqlb .= addslashes($value[$i]) . "|,|";
				  }
				  $k = $j-1;
				  $sqlb .= addslashes($value[$k]) . "|',";
				} else {
				  	if( $value == null ){
			      		$sqlb .= 'null'.",";
			      	}
			      	else
			        	$sqlb .= "'" . addslashes($value) . "',";
				}
			  }
			}
			$sqlb .= ")";
			$sql = $sqla . $sqlb;
			$sql = str_replace(",)", ")", $sql);
             
			// executing query.
			$result = self::execute_query($sql);
			return $result;
		}
		
		
		function update($table, $arr, $where) {
			
			  $result = $this->execute_query("SELECT * FROM $table LIMIT 0,1");
			  $columns = @mysql_num_fields($result);
			  // getting list of columns of the specified table.
			  for ($i = 0; $i < $columns; $i++) {
			    $fieldarr[] = @mysql_field_name($result, $i);
			  }
			  // building update statement.
			  $sql = "UPDATE $table SET ";
			  foreach ($arr as $name => $value) {
					if (in_array ($name, $fieldarr)) {
			      $sql .= "$name = ";
			      
			      if (is_array($value)) {
			        $sql .= "'|";
			        $j = count($value);
			        for ($i = 0; $i < $j-1; $i++) {
			          $sql .= addslashes($value[$i]) . "|,|";
			        }
			        $k = $j-1;
			        $sql .= addslashes($value[$k]) . "|',";
			      } else {
			      	if( $value == null ){
			      		$sql .= 'null'.",";
			      	}
			      	else
			        	$sql .= "'" . addslashes($value) . "',";
			      }
			    }
			  }
			  $sql .= ";";
			  $sql = str_replace(",;", " ", $sql);

		  	$sql .= " where ".$where;

		  	$result = self::execute_query($sql);
		  
			return $result;
		}

			
		function value($key='', $default='', $arr=array()) {

			if(gettype($arr) == 'object') {
				$arr = get_object_vars($arr);
			}

			if(! $this->check_array($arr) ) {
				global $_REQUEST;
				$arr = $_REQUEST;
			}
			
			if(!$this->check_empty($key)) {
				
					if( (!isset($arr[$key])) || (trim($arr[$key] == '')) ) {
						return $this->get_absolute_value($default, "Common::value() --> Element ($key) not found in array and default value not exist.");
					}else{
						return $this->get_absolute_value($arr[$key]);
					}
			}
			else {
					return $this->get_absolute_value($default, "Common::value() --> Key is missing.");
			}
		}
		
		
		function get_absolute_value($val='', $msg='') {
			
			if($this->check_empty($val)) {
				if(empty($msg)) {
					$this->log_msg('Common::get_absolute_value() --> Value is Empty.');
				}
				else {
					$this->log_msg($msg);
				}
				
				return null;
			}
			else {
				if(is_string($val) ) {
					return htmlspecialchars_decode(stripslashes(trim($val)), ENT_QUOTES);
				}
				else {
					return $val;
				}
			}
		}


		function check_empty($value='') {
		
			  if(empty($value)) {
				  if( ($value === 0) || ($value === '0') ) {
					  return false;
				  }
				  else {
					  return true;
				  }
			  }
			  else {
				  return false;
			  }
		}
		
		
		function check_array($arr = array()) {
			
			if( (is_array($arr)) || (is_object($arr)) ){
				
				if(count($arr) > 0) {
					
					foreach ($arr as $val) {
		  				if(!$this->check_empty($val)) return true;
		  			}
				}
			}
			
			return false;
		}
		
		
#################################################################################################		
#################################################################################################
#################################################################################################
#################################################################################################
#################################################################################################
		

		function getxml($array=array(), $fields = array()) {

			$sql = "select eid,ename from emp";
			$result = $this->execute_query($sql);
			if(is_resource($result)){
				$numRows = mysql_num_rows($result);
				if($numRows >= '1'){
					$xml  =	"<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n";
					$xml .=	"<MyXML>\n";
					while($arr=mysql_fetch_assoc($result)) {
						$xml.= " <ROW>\n";
						foreach ($arr as $key => $value) {
							if($key == 'thumbImagePath') {
								$xml.= "  <titleThumbPath>Title_Thumb/{$value}</titleThumbPath>\n";	
							}
						}
						 $xml.= " </ROW>\n";
					}
					
					$xml.= "</MyXML>\n";
					
				} else {
					$xml = '<reply ok="false" reason="No data in table" />';
				}
			} else {
				$xml = '<reply ok="false" reason="Database connection not established" />';
			}

			header('Content-Type: text/xml');
			echo $xml;
		}



		/**
		 * xml2array() will convert the given XML text to an array in the XML structure.
		 * Link: http://www.bin-co.com/php/scripts/xml2array/
		 * Arguments : $contents - The XML text
		 *                $get_attributes - 1 or 0. If this is 1 the function will get the attributes as well as the tag values - this results in a different array structure in the return value.
		 *                $priority - Can be 'tag' or 'attribute'. This will change the way the resulting array sturcture. For 'tag', the tags are given more importance.
		 * Return: The parsed XML in an array form. Use print_r() to see the resulting array structure.
		 * Examples: $array =  xml2array(file_get_contents('feed.xml'));
		 *              $array =  xml2array(file_get_contents('feed.xml', 1, 'attribute'));
		 */
		function xml2array($contents, $get_attributes=1, $priority = 'tag') {
			if(!$contents) return array();

			if(!function_exists('xml_parser_create')) {
				//print "'xml_parser_create()' function not found!";
				return array();
			}

			//Get the XML parser of PHP - PHP must have this module for the parser to work
			$parser = xml_parser_create('');
			xml_parser_set_option($parser, XML_OPTION_TARGET_ENCODING, "UTF-8"); # http://minutillo.com/steve/weblog/2004/6/17/php-xml-and-character-encodings-a-tale-of-sadness-rage-and-data-loss
			xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
			xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
			xml_parse_into_struct($parser, trim($contents), $xml_values);
			xml_parser_free($parser);

			if(!$xml_values) return;//Hmm...

			//Initializations
			$xml_array = array();
			$parents = array();
			$opened_tags = array();
			$arr = array();

			$current = &$xml_array; //Refference

			//Go through the tags.
			$repeated_tag_index = array();//Multiple tags with same name will be turned into an array
			foreach($xml_values as $data) {
				unset($attributes,$value);//Remove existing values, or there will be trouble

				//This command will extract these variables into the foreach scope
				// tag(string), type(string), level(int), attributes(array).
				extract($data);//We could use the array by itself, but this cooler.

				$result = array();
				$attributes_data = array();
				
				if(isset($value)) {
					if($priority == 'tag') $result = $value;
					else $result['value'] = $value; //Put the value in a assoc array if we are in the 'Attribute' mode
				}

				//Set the attributes too.
				if(isset($attributes) and $get_attributes) {
					foreach($attributes as $attr => $val) {
						if($priority == 'tag') $attributes_data[$attr] = $val;
						else $result['attr'][$attr] = $val; //Set all the attributes in a array called 'attr'
					}
				}

				//See tag status and do the needed.
				if($type == "open") {//The starting of the tag '<tag>'
					$parent[$level-1] = &$current;
					if(!is_array($current) or (!in_array($tag, array_keys($current)))) { //Insert New tag
						$current[$tag] = $result;
						if($attributes_data) $current[$tag. '_attr'] = $attributes_data;
						$repeated_tag_index[$tag.'_'.$level] = 1;

						$current = &$current[$tag];

					} else { //There was another element with the same tag name

						if(isset($current[$tag][0])) {//If there is a 0th element it is already an array
							$current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;
							$repeated_tag_index[$tag.'_'.$level]++;
						} else {//This section will make the value an array if multiple tags with the same name appear together
							$current[$tag] = array($current[$tag],$result);//This will combine the existing item and the new item together to make an array
							$repeated_tag_index[$tag.'_'.$level] = 2;
							
							if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well
								$current[$tag]['0_attr'] = $current[$tag.'_attr'];
								unset($current[$tag.'_attr']);
							}

						}
						$last_item_index = $repeated_tag_index[$tag.'_'.$level]-1;
						$current = &$current[$tag][$last_item_index];
					}

				} elseif($type == "complete") { //Tags that ends in 1 line '<tag />'
					//See if the key is already taken.
					if(!isset($current[$tag])) { //New Key
						$current[$tag] = $result;
						$repeated_tag_index[$tag.'_'.$level] = 1;
						if($priority == 'tag' and $attributes_data) $current[$tag. '_attr'] = $attributes_data;

					} else { //If taken, put all things inside a list(array)
						if(isset($current[$tag][0]) and is_array($current[$tag])) {//If it is already an array...

							// ...push the new element into that array.
							$current[$tag][$repeated_tag_index[$tag.'_'.$level]] = $result;
							
							if($priority == 'tag' and $get_attributes and $attributes_data) {
								$current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
							}
							$repeated_tag_index[$tag.'_'.$level]++;

						} else { //If it is not an array...
							$current[$tag] = array($current[$tag],$result); //...Make it an array using using the existing value and the new value
							$repeated_tag_index[$tag.'_'.$level] = 1;
							if($priority == 'tag' and $get_attributes) {
								if(isset($current[$tag.'_attr'])) { //The attribute of the last(0th) tag must be moved as well
									
									$current[$tag]['0_attr'] = $current[$tag.'_attr'];
									unset($current[$tag.'_attr']);
								}
								
								if($attributes_data) {
									$current[$tag][$repeated_tag_index[$tag.'_'.$level] . '_attr'] = $attributes_data;
								}
							}
							$repeated_tag_index[$tag.'_'.$level]++; //0 and 1 index is already taken
						}
					}

				} elseif($type == 'close') { //End of tag '</tag>'
					$current = &$parent[$level-1];
				}
			}
			
			return($xml_array);
		}


		/**
		 * This function helps to populate the form fields as well as Table fields.
		 *
		 * @param array $arrToAssign
		 * @param array $arrFromAssign
		 * @param integer $modeOfAssigning
		 * @param array $replaceArray
		 * @return array
		 * @access public
		 */
		function assignValueToFormElements($arrToAssign, $arrFromAssign='', $modeOfAssigning='', $replaceArray='') {
			
			global $_POST;
			
			$is_return = 0;
			// checking for replace array passed as parameter or not
			if(is_array($replaceArray) && (count($replaceArray) > 0))
			{
				// if replace array passed as parameter no need to return anything.
				$replace = &$replaceArray;
			}else{
				// if replace array not passed as parameter return array $arr;
				$is_return = 1;
				$arr = array();
				$replace = &$arr;
			}
			$formArray = $arrToAssign;
			if(empty($arrFromAssign)){
				// if $arrFromAssign not passed peak the value from post array.
				$arrFromAssign = $_POST; 
			}
			switch ($modeOfAssigning){
				
				case '0':
					// 0 for populating database fields with respect to database fields.
					// used when needs to populate form fields with values stored in database.
					foreach($formArray as $key => $value){
						if(!empty($value)){
							$replace[$value] = self::value($value, '', $arrFromAssign);
						}
					}				
				break;
				
				case '1':
					// 1 for populating form fields with respect to database fields
					// used when needs to populate database values in form.
					foreach($formArray as $key => $value){
						if(!empty($key)){
							$replace[$key] = self::value($value, '', $arrFromAssign);
						}
					}				
				break;
				
				case '2':
					// 2 for populating database fields with respect to form fields
					// used when needs to insert form data into database table.
					foreach($formArray as $key => $value){
						if(!empty($value)){
							$replace[$value] = self::value($key, '', $arrFromAssign);
						}
					}				
				break;
				
				default:
					// populating form fields with respect to form fields, ($arr[key] = $arr[$key])
					// used when server error occured to preserve the form value
					foreach($formArray as $key => $value){
						if(!empty($key)){
							$replace[$key] = self::value($key, '', $arrFromAssign);
						}
					}
				break;
			} // Switch Ends
			
			if($is_return == '1'){
				return $replace;
			}
		}
		// Function assignValueToFormElements Ends
		
		
		/**
		 * Select or remove array elements from an array.
		 * Source array could be either one dimensional or muti dimensional.
		 *
		 * @param array $existingArray like array('first_name'=>'Manoj', 'last_name'=>'Verma', 'username'=>'abc', 'password'=>'abcpwd')
		 * @param array $removingElementArray like array('first_name', 'password')
		 * @param strinf ($action != 2) if u want to remove the element from existing array and ($mode==2) if u want to select those elements from the existing array.
		 * @return array
		 * @access public
		 */
		function operateArrayElements($sourceArray, $targetArray, $action='select') {
			
	          $arr = array();
	          
	          if((is_array($sourceArray)) && (is_array($targetArray))) {
	               if((count($targetArray) > 0) && (count($sourceArray) > 0)){
	                         switch($action){
	                              case 'select':
	                                   foreach ($targetArray as $key) {
	                                        foreach($sourceArray as $key2 => $value2){
	                                             if($key == $key2){
	                                                  $arr[$key] = $value2;
	                                                  break;
	                                             }
	                                        }
	                                   }
	                              break;
	                              
	                              case 'remove':
	                                   foreach ($targetArray as $key) {
	                                        foreach($sourceArray as $key2 => $value2){
	                                             if($key == $key2){
	                                                  unset($sourceArray[$key]);
	                                                  break;
	                                             }
	                                        }
	                                   }                                   
	                              break;
	                              
	                              case 'modify':
	                                   foreach ($targetArray as $key => $value) {
	                                        foreach($sourceArray as $key2 => $value2){
	                                             if($key == $key2){
	                                                  $sourceArray[$key] = $value;
	                                                  break;
	                                             }
	                                        }
	                                   }                                   
	                              break;
	                              
	                              /**
	                               * searching for value in $targetArray
	                               * if value not found return false
	                               * if value found, check value
	                               *           if value is empty
	                               *                return false;
	                               *           if value is not empty
	                               *                return true;
	                               * if value not found
	                               *           return false;
	                               */
	                              case 'checkempty':
	                                   foreach ($targetArray as $key) {
	                                        foreach($sourceArray as $key2 => $value2){
	                                             if($key == $key2){
	                                                  if(empty($value2)){
	                                                       // if value found empty
	                                                       return '0';
	                                                  }
	                                             }
	                                        }
	                                   }
	                              break;                              
	                              
	                              // Default operation is 'select'
	                              default:
	                                   foreach ($targetArray as $key) {
	                                        foreach($sourceArray as $key2 => $value2){
	                                             if($key == $key2){
	                                                  $arr[$key] = $value2;
	                                                  break;
	                                             }
	                                        }
	                                   }                         
	                              break;
	                         }
	                         
	                         switch($action){
	                              case 'select':
	                                   return $arr;
	                              break;
	                              
	                              case 'remove':
	                                   return $sourceArray;
	                              break;
	                              
	                              case 'modify':
	                                   return $sourceArray;
	                              break;
	                              
	                              case 'checkempty':
	                              		return '1';
	                              break;
	                              
	                              // Default operation is 'select'
	                              default:
	                                   return $arr;
	                              break;
	                         }
	               }else{
	                    // if $targetArray is empty.
	                    return '0';
	               }
	          }else{
	               // if $sourceArray is empty.
	               return '0';
	          }
	     }
	
	     
		/**  Function to find a single value or list of values(Array) from source array
	   	 *	 e.g., Capture the value and occurance of 'stage' field comes in source array
		 *	 @Param $sourceArray -- array() -- Single or Multidimensional array
		 *	 @Param $toFindValue -- Single value or an array(one dimensional)
		 *	 @Param $parentLevel -- Tells that the value which i have to search, found in which Level of Source Array
		 *	 @Param $parentLevel -- no need to pass as parameter when call this function
		 *	 @Param $parentLevel -- no need to pass as parameter when call this function
		 *	 Rest of two parameter need not to pass in function calling
		 *	 ### THIS FUNCTION IS COPY OF getValueFromArray() IN nsLIB FILE.
	   	 */	
		function getValueFromArray($sourceArray, $toFindValue='', $parentLevel='', $arr=array(), $level=0) {
			$returnValue = '';
			$levelFound = true;
			
			if((!empty($toFindValue)) && ($toFindValue != '')){
					foreach($sourceArray as $key => $value) {
	
						// If value == array() 
		        		if (is_array($value) && (count($value)>0)) {
		        				$level++;
		        				$this->getValueFromArray($value, $toFindValue, $parentLevel, &$arr, $level);
		        				$level--;
		        		}else{
		        			
		        			//  Set value $levelFound either true or false after checking it is passed as parameter or not
		        			
		    				if((!empty($parentLevel)) && ($parentLevel != '')){
								if($parentLevel == $level){
									$levelFound = true;
								}else{
									$levelFound = false;
								}
							}
							
							//  If parentLevel is passing as parameter and found then block runs or if parentLevel is not passing as parameter then also block is running
							
							if($levelFound == true){
			        			if(is_array($toFindValue)){
			    					foreach($toFindValue as $value2){ // $toFindvalue array is like array('stage', 'name', 'roll') -- 1 dimensional
			    						if($key == $value2){
			    							$arr[$key] = $value;
			    						}
			    					}
			        			}else{
			        				
			        				//  $Searching Value is not array
			        				
				        			if($key == $toFindValue){
				        				$arr[$key] = $value;
				        			}
			        			}
							}
		        		}
					}
				}
			
			if(count($arr) > 0){
				$returnValue = $arr;
			}
			return $returnValue;
		}
	     
	
		/**
		  Function to output a separator either through whitespace, or with an image
		 */
		function putSpace($height='1', $image , $type="hor", $y){
			
			if($y != '100%') {
				$y = $y.'px';
			}
			
			if(($type == 'hor') || (empty($type))) {
				return '<img src="images/'.$image.'" border="0" alt="" width="'.$y.'" height="'.$height.'px" >';
			}
			else {
				return '<img src="images/'.$image.'" border="0" alt="" height="'.$y.'" width="'.$height.'px" >';
			}
		}
		
		
		/**
		 * 	$this->putWhiteSpaces(array('14'),&$replace);
		 *	$this->putWhiteSpaces(array('5','14'), &$replace, 'pixel_silver.gif', true, 'silverSpace');
		 *	$this->putWhiteSpaces(array('5','14', '30', '80'), &$replace, 'pixel_black.gif', false, 'blackSpace');
		 *  In template -- <!whiteSpace14> or <!silverSpace10> or <!blackSpace80>
		 */
		function putWhiteSpaces($arr, $replace, $image='', $y='100%', $type="hor", $range=true, $text='whitespace'){
			switch($image){
				case '':
					$img = 'pixel_trans.gif';
				break;
				case 'silver':
					$img = 'pixel_silver.gif';
				break;
				case 'black';
					$img = 'pixel_black.gif';
				break;
				default:
					$img = $image;
				break;
			}
			if($range == true){
				$min = (count($arr) == 2) ? $arr[0] : '0';
				$max = (count($arr) == 2) ? $arr[1] : $arr[0];
				for($height=$min; $height<=$max; $height++){
					$key = $text.$height;
					$replace[$key] = $this->putSpace($height, $img, $type, $y);
				}
			}else{
				foreach($arr as $height){
					$key = $text.$height;
					$replace[$key] = $this->putSpace($height, $img, $type, $y);
				}
			}
		}
		
		/**
		 * Function to generate string like '1','2','3' to use in "IN Query"
		 * e.g, SELECT * FROM user as u WHERE u.user_id IN ('44','48','47','53','27','29')
		 * 
		 * @param array $array
		 * @return string
		 * @access public
		 *
		*/
		function generateInQueryParameter($array) {
			
			// counts the no of elements in array
			$count_rows = count($array);
			$str = "";
			$counter = 0;
			foreach($array as $value){
				
					$str .= "'".$value."'";
					$counter++;
					if($counter != $count_rows){
						$str .= ",";
					}
			}
			return $str;
		}
		
		
		/**
		 *	format must be like - mm/dd/yy or mm/dd/yyyy
		 */
		function check_date($date) {
			
			if(!empty($date)) {
				$arr = explode("/", $date);
				if( (count($arr) > 3) || (count($arr) < 3) ){ 
					return false;
				}
				else {
					foreach ($arr as $val) {
						if(! is_numeric($val)) return false;
					}
				}
				
				$mydate = date("m-d-Y", mktime(0, 0, 0, $arr[0], $arr[1], $arr[2]));
				$arr2 = explode("-", $mydate);
				
				$check = checkdate($arr2[0], $arr2[1], $arr2[2]);
				if(!$check) {
					return false;
				}
			}
			return true;
		}
		
		
		function html_drop_down($name="", $values=array(), $default = '', $parameters = '') {
			
			if(empty($name)) $name="select";
			
		    $field = '<select name="' . $name . '" id="' . $name . '"';
		
		    if (!empty($parameters)) $field .= ' ' . $parameters;
		
		    $field .= '>';
		
		    if($this->check_array($values))
		    foreach ($values as $key => $value) {
		      $field .= '<option value="' . htmlspecialchars($key) . '"';
		      
		      if ((!empty($default)) && ($default == $key)) {
		        $field .= ' SELECTED';
		      }
			
		      $field .= '>' . htmlspecialchars($value) . '</option>';
		    }
		    $field .= '</select>';
			
		    return $field;
		}
		
		
		/**
		 * Function to add the elements in array on specified position.
		 * If position is not specified it will add array at end.
		 * Ex - $arr = $common->array_add_element(array('Manoj', 'Manu', 'Koushal'), array('Ratnesh', 'Janki'), '0');
		 *
		 * @param array $arr - ex. array('Manoj', 'Manu', 'Koushal', 'Janki');
		 * @param array $element - ex. array('Ratnesh') || array('Ratnesh', 'Sanjay');
		 * @param integer $position
		 */
		function array_add_element($arr=array(), $element=array(), $position='') {
			
			if($this->check_array($arr)) {
				if($this->check_array($element)) {
					if($this->check_empty($position)) {
						$position = count($arr);
					}
					array_splice($arr, $position, 0, $element);
				}
			}
			
			return $arr;
		}
		
		
		#####################################################
		##  Functions for two way encryption and decryption
		#####################################################
		
		function generate_code($length=6) {

        	$chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPRQSTUVWXYZ0123456789";

        	$code = "";

        	while (strlen($code) < $length) {

            	$code .= $chars[mt_rand(0,strlen($chars))];

        	}

        	return $code;
    	}
    	##--------------------------------------------------
    	## SIMPLE FUNCTION TO ENCODE & DECODE STRING
    	function encode($string,$key) {
		    $key = sha1($key);
		    $strLen = strlen($string);
		    $keyLen = strlen($key);
		    $j="";
		    $hash="";
		    for ($i = 0; $i < $strLen; $i++) {
		        $ordStr = ord(substr($string,$i,1));
		        if ($j == $keyLen) { $j = 0; }
		        $ordKey = ord(substr($key,$j,1));
		        $j++;
		        $hash .= strrev(base_convert(dechex($ordStr + $ordKey),16,36));
		    }
		    return $hash;
		}
		##--------------------------------------------------
		function decode($string,$key) {
		    $key = sha1($key);
		    $strLen = strlen($string);
		    $keyLen = strlen($key);
		    $j="";
		    $hash="";		    
		    for ($i = 0; $i < $strLen; $i+=2) {
		        $ordStr = hexdec(base_convert(strrev(substr($string,$i,2)),36,16));
		        if ($j == $keyLen) { $j = 0; }
		        $ordKey = ord(substr($key,$j,1));
		        $j++;
		        $hash .= chr($ordStr - $ordKey);
		    }
		    return $hash;
		}
		##--------------------------------------------------
		## Function to converting hexadecimal number into binary form.
		function hex2bin($hexdata) {
			$bindata='';
		    for ($i=0;$i<strlen($hexdata);$i+=2) {
		        $bindata.=chr(hexdec(substr($hexdata,$i,2)));
		    }  
		    return $bindata;
		}
		##--------------------------------------------------
		function get_decrypted_id($encrypted_value, $key='Test') {
			
			$id = "";
			
			$query = "select AES_DECRYPT(unhex('".$encrypted_value."'),'".$key."') as id";
			$row = $this->get_result($query, '2');
			if($this->check_array($row))
			$id = $row[0]->id;
			
			return $id;
		}
		##--------------------------------------------------
		function set_encrypted_id($id, $key='Test') {
			
			$encrypted_id = "";
			
			$query = "select hex(AES_ENCRYPT('".$id."', '".$key."')) as encrypted_id";
			$row = $this->get_result($query);
			if($this->check_array($row))
			$encrypted_id = $row[0]->encrypted_id;
			
			return $encrypted_id;
		}
		##**************************************************
		
		
		//Get the result of the query as a CSV stream.
		function CSVExport($query) {
		    $sql_csv = $this->execute_query($query);
		    
		    header("Content-type:text/octect-stream");
		    header("Content-Disposition:attachment;filename=data.csv");
		    while($row = $this->fetch_result($sql_csv)) {
		        print '"' . stripslashes(implode('","',$row)) . "\"\n";
		    }
		    exit;
		}

		/**
		 * Import the contents of a CSV file after uploading it
		 * http://www.bin-co.com/php/scripts/csv_import_export/
		 * Aruguments : $table - The name of the table the data must be imported to
         *       $fields - An array of fields that will be used
		 * 		ex - $fields = array('first_name, last_name, country, address, city, state, zip, phone, fax, email','status','priority','mail_subscription','user_id','created_at','updated_at');
         *      $auto_fields - An array of fields that will be used -- Not mandatory
		 * 		ex - $cur_date = date("Y-m-d H:i:s", time());
		 * 			 $auto_fields = array('ACTIVE', 'NORMAL', 'new', '1', $cur_date, $cur_date);
         *      $csv_fieldname - The name of the CSV file field
         */
		function upload_csv($table='buyers', $fields=array(), $csv_fieldname='buyercsv', $auto_fields=array()) {
			
			$return = FALSE;
			global $_FILES;
			
			if(count($fields) <= 0) {
				$this->log_msg("Common::upload_csv() --> Please specify corrospondant database fields."); return false;
			}

			if( (count($_FILES) <= 0) || ($_FILES[$csv_fieldname]['name'] == '') ) {
				$this->log_msg("Common::upload_csv() --> Please upload a csv file."); return false;
			}
			
		    $file_name = $_FILES[$csv_fieldname]['name'];
		    
		    $arr = explode(".", $file_name);
		    $extentsion = $arr['1'];
		    if(strtolower($extentsion) != 'csv') { $this->log_msg('Common::upload_csv() --> Please upload only csv files.'); return false; }
		    
		    $handle = fopen($_FILES[$csv_fieldname]['tmp_name'],'r');
		    if(!$handle) die('Cannot open uploaded file.');
		
		    $row_count = 0;
		    $sql_query = "INSERT INTO $table(". implode(',',$fields) .") VALUES(";
		
		    $rows = array();
		
		    //Read the file as csv
		    while (($data = fgetcsv($handle, 1000, ",")) !== FALSE) {
		    	
		    	if( $this->check_array($data) ) {
		    		
			        $row_count++;
			        $data = array_merge($data, $auto_fields);
			        foreach($data as $key=>$value) {
			            $data[$key] = "'" . addslashes($value) . "'";
			        }
			        if(count($data) != count($fields)) { $this->log_msg('Common::upload_csv() --> Some fields are missing in csv, Please check.'); $return=TRUE; }
			        
//			        $this->print_rr($data); exit;
	
			        $rows[] = implode(",",$data);
		    	}
		    } 
//		    $this->print_rr($rows); exit;
		    $sql_query .= implode("),(", $rows);
		    $sql_query .= ")";
		    fclose($handle);
		    
		    if($return == TRUE) {
		    	return false;
		    }
		    
//		    echo $sql_query; exit;
		    
		    if(count($rows)) { //If some recores  were found,
		    	
		        $this->execute_query($sql_query);
		
		        $this->log_msg('Common::upload_csv() --> Successfully imported '.$row_count.' record(s)');
		        
		        return true;
		        
		    } else {
		        $this->set_message('Cannot import data - no records found.');
		        
		        return false;
		    }
		}


		function print_rr($arr = array(), $arr_name='') {
			
			if( $this->check_array($arr) ) {
					
					$rows = count($arr);
		
					echo "<br/><strong>Total elements in array ($arr_name) = ".$rows."</strong></br>";
					
					echo "<pre>";
					print_r($arr);
					echo "</pre>";
			}
			else {
				
				if(is_array($arr)) {
					
					echo "<br/><strong>Empty array having '".count($arr)."' Keys.</strong></br>";
					
					echo "<pre>";
					print_r($arr);
					echo "</pre>";
					
				}
				else if($this->check_empty($arr)) {
					echo "<br/><strong>Parameter is not an array or object, Type = (".gettype($arr)."), Empty value.</strong></br>";
				}
				else {
					echo "<br/><strong>Parameter is not an array or object, Type = (".gettype($arr)."), value = ($arr).</strong></br>";
				}
			}

			echo "<hr>";
		}


		function log_msg($msg="Error occured.", $color="red", $size="3") {
			
			$str = '['.date("D M d H:i:s Y", time()).'] : '. $msg;
//			echo $my_msg = '<br/><font color="'.$color.'" size="'.$size.'"><strong>'.$str.'</strong></font>';

			$source_file = "tmp/mylog.txt";
			@chmod($source_file, 0777);
			
			$handle = @fopen($source_file, "a+"); // w+ is used to write every time from begining.
			if($handle) {
				
				$str2 = "\n $str";
				if (@fwrite($handle, $str2) === FALSE) {
					echo "Cannot able to write into file ($source_file)";
				}
				fclose($handle);
			}
			else {
				echo "Cannot able to open file - ($source_file)";
			}
		}

		function echoo($str, $exit=false) {
			$msg = '<br/><font color="#9900FF"><strong>Track Message : '.$str.'</strong></font>';
			echo $msg;

			if($exit != false) {
				exit;
			}
		}
		
} // Common Class Ends


################################
##  Testing
################################


$common = new common();
//$common->getxml(); exit;

//$common->execute_query("update emp set ename='Ratnesh kr' where eid=1");
//$common->execute_queryi("update emp set ename='Ratnesh kumar' where eid=1");
//$common->execute_queryi("select * from emp inner join emp_profile on emp.eid=emp_profile.id");
//$common->execute_query("select * from emp inner join emp_profile on emp.eid=emp_profile.id");
//$common->get_primarykeyi('emp');
//$row = $common->get_row('te', '1');
//$rows = $common->select('emp', array('eid','mid'));
//$replace = $common->assignValueToFormElements(array('emp_id' => 'eid', 'emp_name' => 'ename'), '', '');
//$common->print_rr($replace);


//echo $common->html_drop_down('dd', array('01'=>'Manoj'));
//$arr = $common->array_add_element(array('Manoj', 'Manu', 'Koushal'), array('Ratnesh', 'Janki'), '0');
$arr = $common->array_add_element(array('mannu'=>'Manoj', 'manu'=>'Manu', 'jha'=>'Koushal'), array('ratan'=>'Ratnesh', 'jaan'=>'Janki'), '0');
//$common->print_rr($arr); exit;


$common->upload_csv('emp_profile', array('id','address'), 'empcsv');


$common->putWhiteSpaces(array('1', '10'), &$hor, 'pixel_silver.gif');
$common->putWhiteSpaces(array('1', '10'), &$ver, 'verticle.gif', '100', 'ver');


//print_r($arr); exit;
/*echo '<table border="1" cellspacing="4" cellpadding="4">
  <tr>
    <td colspan="2" scope="col">1 '.$ver['whitespace1'].' 2</td>
  </tr>
  <tr>
    <td colspan="2" scope="col">1 '.$ver['whitespace10'].' 2</td>
  </tr>
  <tr>
    <td colspan="2" scope="col">1 '.$hor['whitespace1'].' 2</td>
  </tr>
  <tr>
    <td colspan="2" scope="col">1 '.$hor['whitespace10'].' 2</td>
  </tr>
</table>';
*/

/*
echo '<form name="frm" id="frm" method="post" action="'.$_SERVER['PHP_SELF'].'" enctype="multipart/form-data">
Upload csv: <input type="file" name="empcsv" id="empcsv" />
<input type="submit" name="upload" id="upload" value="Upload"  />
</form>';


echo $common->nice_datetime(strtotime('2009-05-17 14:25:50'));
echo "<br/>My Machine's IP = ".$common->find_client_ip();
echo "<br/>No of Days-".$numDays=$common->daysInSpan(mktime(0,0,0,5,1,2009));
*/
?>
Usage

Common functions for database and other stuffs.
Comments

Posted on 31.08.2009 04:33 by unknown user
IT is one of the best and most leading technology in this modern era. There are many different ways to get high level posts in any famous organization. In order to get a good post in Information Technology, you must have detailed knowledge and experience about different topics like testking. I really appreciate the best and amazing efforts like that. Well done..
Add your comment
Let us know!

We are always looking on upgrading. Please, take a second to tell us which is the feature you would like to see being added in PHPSnaps.
Login

Coder: mjv123

Rate this snap

Rating: 0 / 5 (0 votes) 783 views
Custom class generator

Selected snaps:
None selected yet.
Hot PHP snaps
