<?php
/** example usage **/
$f = new fxConverter();
$result = $f->convert('USD', 'GBP', 1, '1 October 1999');
print_r($result);
/** end example usage **/
class fxConverter{
 
	/**
	 * constructor
	 * @return 
	 */
	public function __construct(){
		date_default_timezone_set('UTC');
		$this->pdo = new PDO ('sqlite:fxrates.sqlite');
		$this->pdo->exec('create table if not exists fxRates  (fxDate int, fxCurrency text, fxRate real, primary key (fxDate, fxCurrency) on conflict replace)');
		$this->pdo->exec('create table if not exists fxTime (updateID integer primary key autoincrement, updateDate int)');
		if ( 0 < ($lastUpdate = $this->needsUpdate())) $this->updateFx($lastUpdate);
	}
 
	/**
	 * helper method to set the required date.  
	 * @param object $date in unixtimestamp or text based format
	 * @return 
	 */	
	public function setDate($date){
		if(is_string($date)) $this->date = date('Y-m-d', strtotime($date));
		if(is_numeric($date)) $this->date = date('Y-m-d', $date);
	}
 
	/**
	 * main public method for converting amounts from one currency to another
	 * @param string $from - a supported currency
	 * @param string $to - a supported currency
	 * @param float $amount [optional] - the amount to be converted, defaults to 1
	 * @param int|string $date [optional] - the date for the conversion, specified in text form ('2011-01-01', '1 Jan 2011') or a unix timestamp
	 * @param int|string $offset [optional] - an offset to apply.  can be a percentage between 0 and 5 or one of the following string 'bank, 'credit card', 'cash')
	 * @return either an error object or an array with the converted amount and the date of the currency pair used.
	 */
	public function convert($from, $to, $amount = 1, $date = NULL, $offset = NULL){
		if(!$this->supportedCurrency($from, $to)) return $this->raiseError('This currency pair is not supported');
		if($amount == 0) return 0;
		if (empty($date) && empty($this->date)) $this->setDate(time());
		if(!empty($date)) $this->setDate($date);
		switch (strtolower($offset)):
			case 'creditcard':
				$offset = 0.97;
			break;	
			case 'atm':
				$offset = 0.98;
			break;
			case 'bureau':
			case 'kiosk':
				$offset = 0.95;
			break;
			case '':
			case NULL:
				$offset = 1;
			break;
			default:
				$offset = 1 - $offset/100;
		endswitch;
		//get conversion rate for $from and $to
		$rate = $this->getFX($from, $to, $amount, $offset);
		return $rate;
	}
 
	/**
	 * private method to ensure that the requested currency pairs are retrievable
	 * @param object $from
	 * @param object $to
	 * @return 
	 */
	private function supportedCurrency($from, $to){
		$sql = <<<SQL
SELECT	COUNT(DISTINCT fxCurrency) as c
FROM 	fxRates
WHERE	fxCurrency IN (?, ?)
SQL;
		$s = $this->pdo->prepare($sql);
		$s->execute(array(strtoupper($from), strtoupper($to)));
		$row = $s->fetchObject();
		return ($row->c == 2); 
	}
 
	/**
	 * private method to convert the requested amount by the rxrate.
	 * 
	 * @param object $from
	 * @param object $to
	 * @param object $amount
	 * @param object $offset [optional]
	 * @return 
	 */
	private function getFX($from, $to, $amount, $offset=NULL){
		$sql = <<<SQL
SELECT 		(b.fxRate/a.fxRate) * ? AS convertedAmount,
			(b.fxRate/a.fxRate) * ? * ? AS adjustedConvertedAmount, 
			a.fxDate as fxDate,
			? as 'interbank rate' 
FROM 		fxRates a 
JOIN		fxRates b 
ON 			a.fxDate = b.fxDate 
WHERE 		a.fxCurrency=?
			AND 
			b.fxCurrency=?
			AND
			a.fxDate <= round(julianday(?)) 
			AND 
			a.fxDate >= round(julianday(?)) - 5
ORDER BY	a.fxDate DESC 
LIMIT 		1
SQL;
		$s = $this->pdo->prepare($sql);
		$s->execute(array(	 $amount, $amount, $offset, $offset, $from, $to, $this->date, $this->date));
		$row = $s->fetchObject();
		if(is_null($row) || $row === false) return $this->raiseError('No recent rate for this currency pair');
		return get_object_vars($row); //$row;
	}
 
	/**
	 * private function to determine whether a new set of fx rates should be retrieved
	 * @return true|false
	 */
	private function needsUpdate(){
		$s = $this->pdo->prepare(<<<SQL
SELECT
		IFNULL(
			(CASE 
				WHEN 	(round(julianday('now')) > max(updateDate)) 
				THEN 	(round(julianday('now')) - max(updateDate))
				ELSE	0
			END), 
			10000
			)  as lastUpdate 
FROM 	fxTime
SQL
		);
		if(!$s) die(print_r($this->pdo->errorInfo()));
		$s->execute();
		$o = $s->fetchObject();
		return isset($o->lastUpdate) ? $o->lastUpdate : 0;
	}
 
	/**
	 * private method to retrieve and update currency pairs from the ECB website
	 * @param object $lastUpdate [optional]
	 * @return 
	 */
	private function updateFx($lastUpdate = NULL){
		if( $lastUpdate > 90 || is_null($lastUpdate)):
			$url = 'http://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist.xml';
		else:
			$url = 'http://www.ecb.europa.eu/stats/eurofxref/eurofxref-hist-90d.xml';
		endif;
		$XML=simplexml_load_file($url);
		if($XML === false) return $this->raiseError('Cannot update fxRates');
		$query = 'insert into fxRates (fxDate, fxCurrency, fxRate) values (round(julianday(?)),?,?)';
		$s = $this->pdo->prepare($query);
		if($s === false) print_r($this->pdo->errorInfo());
		//work out the comparitive date
		$cDate = strtotime('-' . ($lastUpdate + 1) .' day' );
		foreach($XML->Cube->Cube as $data):
			set_time_limit(30);	
			$i = $data->attributes();
			$date = $i['time'];
			if(strtotime($date) < $cDate) continue;
			$s->execute(array($date, 'EUR', 1));
			foreach ($data->children() as $blob):
				set_time_limit(10);
				$d = $blob->attributes();
				$s->execute(array( $date, $d['currency'], $d['rate']));
			endforeach;
		endforeach;
		$this->pdo->exec("insert into fxTime values (NULL, round(julianday('now')))");
		$this->pdo->exec('VACUUM');
	}
 
	private function raiseError($message){
		$this->hasErrors = true;
		$this->errors[] = new fxError($message); 
		return $this->errors;
	}
}
class fxError{
	public function __construct($message){ $this->message = $message; }
}

<?php
/**
 * this class offers the following public interface methods
 * in each case the $params argument should be null or an associative array of fieldname=>value pairs.
 *
 *
 * getAll($sql, $params) -	returns all the rows returned by the sql as a numeric array of objects
 * getOne($sql, $params) -	returns the first row of the recordset (as filtered by the params) as an object
 * getVar($sql, $params) - 	returns the first column of the first row of the recordset as a variable
 * for the above methods:
 * 	used with a sql string as the first argument the $params should be a numeric array of arguments in the same order as the sql placeholders in the query
 * 	used with a table name as the first argument, the $params should be an associative array of field_names to values to be used in a where clause
 *
 * save ($table, $params) - will save the data in the specified table.  if a primary key is present in the $params, the record will be updated. otherwise a new record will be added.
 * 							NOTE see update for behaviour with $params
 * 							returns false on failure and either the last insert id (if an insert) or true (if an update)
 * replace($table, $params) - as for update but it issues a replace command rather than update in mysql. in sqlite it issues a delete then a replace.
 * insert($table, $params) - ignore the fact that there is a $fields argument.  it is not used for static calls.
 * 							this method inserts a record into the database.  it returns false on failure or the last insert id on success
 * delete($table, $params) - deletes records from database table where the $params are met
 *
 * setlimit($limit, $offset) - $limit and $offset are integers.  $offset may be omitted.
 * getFoundRows() - used to obtain the unfiltered row count in a limit/offset query.  returns null if not a limit query.
 *
 * doQuery($sql, $params) - use with caution.  this is a direct pipe to the $pdo->prepare function.  it returns false on failure or an executed PDO_STATEMENT object if not.  you will then need to iterate over the object with a PDO_STATEMENT::fetch_* method
 *
 * //for limit/offset queries
 * $sql = "Select * from tablename";
 * $where = array('mymonth'=>5, 'myYear'='2009');
 * $db->setLimit(20, 40);
 * $rows = $db->getAll($sql, $where);
 * $unfilteredResults =  $db->getFoundRows();
 *
 *
 * //error handling
 * if false is returned by a function there has been an error;
 * so you somecode like this
 * $results = $db->getAll('mytableName');
 * if (!$results && $db->isError){
 * 	echo nl2br($db->getErrors());
 * }
 *
 * if you want code execution to stop after an error then
 * pass an argument in getErrors: echo nl2br($db->getErrors(true));
 *
 */
class myPDO extends PDO{
 
	public $isError = false;
	public $killSwitch = false;
 
	public function __construct($dsn, $user=null, $pass=null){
		parent::__construct($dsn, $user, $pass);
		$this->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_SILENT);
		$this->setAttribute(PDO::ATTR_STRINGIFY_FETCHES, true);
	}
 
	public function setKillSwitch($val){
		$this->$killSwitch = (bool) $val;
	}
 
 
	public function doQuery($sql, $params=array(), $override = false){
		$params = array_values($params);
		$this->flush();
		if (!empty($this->limit) && ! $override){
			$rawSql = $sql;
			$sql .= "LIMIT $this->limit OFFSET $this->offset";
			$sql = preg_replace('/select (distinct)?\s+/im', 'select \1 SQL_CALC_FOUND_ROWS ', $sql, 1);
		}
		$s = $this->prepare($sql);
		if (DBTYPE == 'sqlite') {
			$pattern = '/select\s+(distinct)?\s+(.*?)from(.*?)$/im';
			$countQuery = preg_replace($pattern, 'select \1 count(*) from \3', $rawSql);
		}
		$y = $this->prepare($rawSql);
		if (!$s){
			$i = $this->errorInfo();
			$this->setError ($sql, $params, $i[2]);
			return false;
		} else {
			$result = $s->execute($params);
			if (!$result){
				$i = $s->errorInfo();
				$this->setError ($sql, $params, $i[2]);
				return false;
			} else {
				if (!empty($this->limit)){
					$this->limit=$this->offset = null;
					switch (DBTYPE){
						case 'sqlite':
							$s = $this->query('select found_rows()');
							$this->numRows = $s->fetchColum();
							break;
						case 'mysql':
							$this->numRows = $this->getVar($countQuery);
							break;
					}
				}
				return $s;
			}
		}
	}
 
	public function setLimit($limit, $offset = 0){
		$this->limit = $limit;
		$this->offset = $offset;
	}
 
	public function getFoundRows(){
		return empty( $this->numRows) ? NULL : $this->numRows;
	}
 
	private function getAllFromTable($table, $params=array()){
		$where = array();
		$fields = $this->getStruct($table);
		foreach ($params as $key=>$value){
			$where[] = "$key=?";
			$values[] = $value;
		}
		$whereClause = empty($where) ? '' : "where " . implode(',' , $where);
		$sql = "Select * from $table $whereClause";
		return $this->_getAll ($sql, $values);
	}
 
	private function _getAll($sql, $params){
		return $this->doQuery($sql, $params);
	}
 
	public function getAll($sql, $params=array(), $raw=false){
		$sql = trim($sql);
		$words = explode(' '. $sql);
		if (count($words) < 2){
			$r = $this->getAllFromTable($sql, $params);
		} else {
			$r = $this>_getAll($sql,$params);
		}
		if (!$r){
			return false;
		} else {
			if($raw) return $r;
			return $r->fetchAll(PDO::FETCH_OBJ);
		}
	}
 
	private function flush (){
		$this->isError = false;
		$this->errors = array();
	}
 
	private function setError($sql, $params, $message){
		$this->errors[] = array('query'=>$sql, 'parameters'=>print_r($params, true), 'message'=>$message, 'time'=>date('r'));
		$this->isError = true;
	}
 
	public function getErrors($kill = false){
		if (count($this->errors) < 1) return;
		foreach($this->errors as $e){
			$message[] = <<<hh
 
Error with a query.
Time: {$e['time']}
Query was: {$e['query']}
Supplied params were: {$e['parameters']}
Error message was: {$e['message']}
HH;
		}
 
		return (implode("\n", $message));
	}
 
	public function __destruct(){
		if (DEBUG && $this->isError) {
			$message = $this->getErrors();
			file_put_contents(BASE . DIRECTORY_SEPARATOR . 'debugLog.txt', implode("\n", $message), FILE_APPEND);
		}
	}
	private function getStruct($table){
		if (DBTYPE == 'sqlite'){
			$fields =  $this->getAll('pragma table_info(?)', array($table));
			foreach ($fields as $f){
				$_fields[$f->name] = $f;
				if ($f['pk'] == 1){
					$_fields['pk'] = $f->name;
				}
			}
		} else {
			$sql = 'Show Columns from ' . $table;
			$fields = $this->getAll($sql);
			foreach ($fields as $f){
				$f->name = $f->Field;
				$_fields[$f->Field] = $f;
				if ($f->Key == 'PRI'){
					$_fields['pk'] = $f->Field;
				}
			}
		}
		return $_fields;
	}
 
	public function update($table, $params = array(), $fields=array()){
		if (empty($fields)) $fields = $this->getStruct($table);
		$fields = $this->getStruct($table);
		$where = "where $primary = ?";
		$sql = "Update $table set ";
		foreach ($params as $param=>$value){
			if (isset($fields[$param]) && $param != $fields['pk']){
				$q[] = "$param = ?";
				$p[] = $value;
			}
		}
		$sql .= implode(',', $q) . $where;
		$p[] = $params[$fields['pk']];
		$result = $this->doQuery($sql, $p);
		return ($result === false) ? false : true;
	}
 
	public function insert($table, $params=array(), $fields=array()){
		if (empty($fields)) {
			$fields = $this->getStruct($table);
		}
		$_f = array();
		foreach ($fields as $type => $f){
			if ($type == 'pk') continue;
			$_f[] = $f->name;
			$placeHolder[] = '?';
			if (empty($params[$f->name])){
				$_p[] = null;
			} else {
				$_p[] = trim($params[$f->name]);
			}
		}
		$sql = "Insert into $table (".implode(',',$_f) .") values (".implode(',', $placeHolder) . ")";
		$r = $this->doQuery($sql, $_p);
		return ($r === false) ? false : $this->lastinsertid();
	}
 
	public function save($table, $params = array()){
		$struct = $this->getStruct($table);
		$primary = $struct['pk'];
		if (empty($params[$primary])){
			return $this->insert($table, $params, $struct);
		} else {
			return $this->update($table, $params, $struct);
		}
	}
 
	public function delete($table, $params=array()){
		$sql = "delete from $table where ";
		$sql .= implode ('=? AND ', array_keys($field));
		$r = $this->doQuery($sql, array_values($params));
		return ($r===false) ? false : true;
	}
 
	public function getOne($sql, $params = array()){
		$this->setLimit(1);
		$results = $this->getAll($sql, $params, true);
		if ($results !== false){
			return $results->fetchObject();
		} else {
			return false;
		}
	}
 
	public function getVar($sql, $params=array()){
		$results = $this->getAll($sql, $params, true);
		if ($result === false) return false;
		return $result->fetchColumn();
	}
 
	public function replace($table, $params=array()){
		switch (DBTYPE){
			case 'mysql':
				$sql = "Replace into $table set ";
				$sql .= implode ("=?,", array_keys($params));
				return $this->doQuery($sql, array_values($params));
				break;
			case 'sqlite':
				$sql = "Update or replace $table set ";
				$sql .= implode ("=?,", array_keys($params));
				return $this->doQuery($sql, array_values($params));
				break;
		}
	}
}
define ('DBTYPE', 'mysql');
define('DEBUG', true);
$host = '';
$database = '';
$user = '';
$pass = '';
$db = new myPDO("mysql:host=$host;dbname=$database",$user, $pass);
?>

<?php
/*
Plugin Name: Change Email From Address/Name
Plugin URI: http://rathercurious.net
Description: changes the email from address
Version: 0.1.0
Author: Justin Adie
Author URI: http://rathercurious.net
*/
 
class emailFrom{
	public function __construct(){
		add_filter('wp_mail_from', array(&$this, 'doEmailFilter'),10, 1);
		add_filter('wp_mail_from_name', array(&$this, 'doEmailNameFilter'), 10, 1);
		add_filter('wp_mail_charset',array(&$this, 'fixCharset'), 10, 1);
		add_filter('wp_mail', array(&$this, 'decode'), 10,1);
	}
	public function decode($array){
		$array['subject'] = html_entity_decode($array['subject']);
		return $array;
	}
	public function fixCharset($data){
		return 'UTF-8';
	}
	public function doEmailFilter($data){
		return 'email@domain.com';
	}
	public function doEmailNameFilter($data){
		return 'My Name';
	}
}
$_ef = new emailFrom();
 
?>

<?php
/**
 * class to handle script timing
 *
 * usage
$timer = new timer();
$timer->start();
...code...
$timer->report();
 */
class timer{
	/**
	 * method to start the timer
	 * @return
	 */
	public function start(){
		$this->start = microtime(true);
	}
 
	/**
	 * method to pause the timer
	 * @return
	 */
	private function stop(){
		$this->stop = microtime(true);
	}
 
	/**
	 * method to stop the timer and report on the amount of time taken
	 * @return
	 * @param object $format[optional]
	 */
	public function report(){
		$this->stop();
		$this->diff();
		printf ("<hr/>Script took %s seconds", number_format($this->diff, 8));
	}
 
	/**
	 * calculate the amount of time taken.
	 */
	private function diff(){
		$this->diff = $this->stop - $this->start;
	}
}
?>