एक PHP5 फ्रेमवर्क बनाएँ - भाग 2

<?php

/**

 * Database management and access class

 * This is a very basic level of abstraction

 */

class database {

	/**

	 * Allows multiple database connections

	 * probably not used very often by many applications, but still useful

	 */

	private $connections = array();

	/**

	 * Tells the DB object which connection to use

	 * setActiveConnection($id) allows us to change this

	 */

	private $activeConnection = 0;

	/**

	 * Queries which have been executed and then "saved for later"

	 */

	private $queryCache = array();

	/**

	 * Data which has been prepared and then "saved for later"

	 */

	private $dataCache = array();

	/**

	 * Record of the last query

	 */

	private $last;

	/**

	 * Hello

	 */

    public function __construct()

    {

    }

    /**

     * Create a new database connection

     * @param String database hostname

     * @param String database username

     * @param String database password

     * @param String database we are using

     * @return int the id of the new connection

     */

    public function newConnection( $host, $user, $password, $database )

    {

    	$this->connections[] = new mysqli( $host, $user, $password, $database );

    	$connection_id = count( $this->connections )-1;

    	if( mysqli_connect_errno() )

    	{

    		trigger_error('Error connecting to host. '.$this->connections[$connection_id]->error, E_USER_ERROR);

		} 	

    	return $connection_id;

    }

    /**

     * Close the active connection

     * @return void

     */

    public function closeConnection()

    {

    	$this->connections[$this->activeConnection]->close();

    }

    /**

     * Change which database connection is actively used for the next operation

     * @param int the new connection id

     * @return void

     */

    public function setActiveConnection( int $new )

    {

    	$this->activeConnection = $new;

    }

    /**

     * Store a query in the query cache for processing later

     * @param String the query string

     * @return the pointed to the query in the cache

     */

    public function cacheQuery( $queryStr )

    {

    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )

    	{

		    trigger_error('Error executing and caching query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);

		    return -1;

		}

		else

		{

			$this->queryCache[] = $result;

			return count($this->queryCache)-1;

		}

    }

    /**

     * Get the number of rows from the cache

     * @param int the query cache pointer

     * @return int the number of rows

     */

    public function numRowsFromCache( $cache_id )

    {

    	return $this->queryCache[$cache_id]->num_rows;	

    }

    /**

     * Get the rows from a cached query

     * @param int the query cache pointer

     * @return array the row

     */

    public function resultsFromCache( $cache_id )

    {

    	return $this->queryCache[$cache_id]->fetch_array(MYSQLI_ASSOC);

    }

    /**

     * Store some data in a cache for later

     * @param array the data

     * @return int the pointed to the array in the data cache

     */

    public function cacheData( $data )

    {

    	$this->dataCache[] = $data;

    	return count( $this->dataCache )-1;

    }

    /**

     * Get data from the data cache

     * @param int data cache pointed

     * @return array the data

     */

    public function dataFromCache( $cache_id )

    {

    	return $this->dataCache[$cache_id];

    }

    /**

     * Delete records from the database

     * @param String the table to remove rows from

     * @param String the condition for which rows are to be removed

     * @param int the number of rows to be removed

     * @return void

     */

    public function deleteRecords( $table, $condition, $limit )

    {

    	$limit = ( $limit == '' ) ? '' : ' LIMIT ' . $limit;

    	$delete = "DELETE FROM {$table} WHERE {$condition} {$limit}";

    	$this->executeQuery( $delete );

    }

    /**

     * Update records in the database

     * @param String the table

     * @param array of changes field => value

     * @param String the condition

     * @return bool

     */

    public function updateRecords( $table, $changes, $condition )

    {

    	$update = "UPDATE " . $table . " SET ";

    	foreach( $changes as $field => $value )

    	{

    		$update .= "`" . $field . "`='{$value}',";

    	}

    	// remove our trailing ,

    	$update = substr($update, 0, -1);

    	if( $condition != '' )

    	{

    		$update .= "WHERE " . $condition;

    	}

    	$this->executeQuery( $update );

    	return true;

    }

    /**

     * Insert records into the database

     * @param String the database table

     * @param array data to insert field => value

     * @return bool

     */

    public function insertRecords( $table, $data )

    {

    	// setup some variables for fields and values

    	$fields  = "";

		$values = "";

		// populate them

		foreach ($data as $f => $v)

		{

			$fields  .= "`$f`,";

			$values .= ( is_numeric( $v ) && ( intval( $v ) == $v ) ) ? $v."," : "'$v',";

		}

		// remove our trailing ,

    	$fields = substr($fields, 0, -1);

    	// remove our trailing ,

    	$values = substr($values, 0, -1);

		$insert = "INSERT INTO $table ({$fields}) VALUES({$values})";

		$this->executeQuery( $insert );

		return true;

    }

    /**

     * Execute a query string

     * @param String the query

     * @return void

     */

    public function executeQuery( $queryStr )

    {

    	if( !$result = $this->connections[$this->activeConnection]->query( $queryStr ) )

    	{

		    trigger_error('Error executing query: '.$this->connections[$this->activeConnection]->error, E_USER_ERROR);

		}

		else

		{

			$this->last = $result;

		}

    }

    /**

     * Get the rows from the most recently executed query, excluding cached queries

     * @return array 

     */

    public function getRows()

    {

    	return $this->last->fetch_array(MYSQLI_ASSOC);

    }

    /**

     * Gets the number of affected rows from the previous query

     * @return int the number of affected rows

     */

    public function affectedRows()

    {

    	return $this->$this->connections[$this->activeConnection]->affected_rows;

    }

    /**

     * Sanitize data

     * @param String the data to be sanitized

     * @return String the sanitized data

     */

    public function sanitizeData( $data )

    {

    	return $this->connections[$this->activeConnection]->real_escape_string( $data );

    }

    /**

     * Deconstruct the object

     * close all of the database connections

     */

    public function __deconstruct()

    {

    	foreach( $this->connections as $connection )

    	{

    		$connection->close();

    	}

    }

}

?>

// insert record

$registry->getObject('db')->insertRecords( 'testTable', array('name'=>'Michael' ) );

// update a record

$registry->getObject('db')->updateRecords( 'testTable', array('name'=>'MichaelP' ), 'ID=2' );

// delete a record (well, upto 5 in this case)

$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );

// our second database connection (let's assume we already have a connection to our main DB)

$newConnection = $registry->getObject('db')->newConnection('localhost', 'root', 'password', 'secondDB');

// delete from the primary db connection

$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );

// change our active db connection, to allow future queries to be on the second connection

$registry->getObject('db')->setActiveConnection( $newConnection );

// delete from the secondary db connection

$registry->getObject('db')->deleteRecords( 'testTable', "name='MichaelP'", 5 );

// revert the active connection so future queries are on the primary db connection

$registry->getObject('db')->setActiveConnection( 0 );

<?php

// prevent this file being called directly

if ( ! defined( 'PCAFW' ) ) 

{

	echo 'This file can only be called via the main index.php file, and not directly';

	exit();

}

/**

 * Template manager class

 */

class template {

	private $page;

	/**

	 * Hello!

	 */

    public function __construct() 

    {

	    include( APP_PATH . '/PCARegistry/objects/page.class.php');

	    $this->page = new Page();

    }

    /**

     * Add a template bit onto our page

     * @param String $tag the tag where we insert the template e.g. {hello}

     * @param String $bit the template bit (path to file, or just the filename)

     * @return void

     */

    public function addTemplateBit( $tag, $bit )

    {

		if( strpos( $bit, 'skins/' ) === false )

		{

		    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;

		}

		$this->page->addTemplateBit( $tag, $bit );

    }

    /**

     * Put the template bits into our page content

     * Updates the pages content

     * @return void

     */

    private function replaceBits()

    {

	    $bits = $this->page->getBits();

	    foreach( $bits as $tag => $template )

	    {

		    $templateContent = file_get_contents( $bit );

		    $newContent = str_replace( '{' . $tag . '}', $templateContent, $this->page->getContent() );

		    $this->page->setContent( $newContent );

	    }

    }

    /**

     * Replace tags in our page with content

     * @return void

     */

    private function replaceTags()

    {

	    // get the tags

	    $tags = $this->page->getTags();

	    // go through them all

	    foreach( $tags as $tag => $data )

	    {

		    if( is_array( $data ) )

		    {

			    if( $data[0] == 'SQL' )

			    {

				    // it is a cached query...replace DB tags

				    $this->replaceDBTags( $tag, $data[1] );

			    }

			    elseif( $data[0] == 'DATA' )

			    {

				     // it is some cached data...replace data tags

				    $this->replaceDataTags( $tag, $data[1] );

			    }

	    	}

	    	else

	    	{	

		    	// replace the content	    	

		    	$newContent = str_replace( '{' . $tag . '}', $data, $this->page->getContent() );

		    	// update the pages content

		    	$this->page->setContent( $newContent );

	    	}

	    }

    }

    /**

     * Replace content on the page with data from the DB

     * @param String $tag the tag defining the area of content

     * @param int $cacheId the queries ID in the query cache

     * @return void

     */

    private function replaceDBTags( $tag, $cacheId )

    {

	    $block = '';

		$blockOld = $this->page->getBlock( $tag );

		// foreach record relating to the query...

		while ($tags = PCARegistry::getObject('db')->resultsFromCache( $cacheId ) )

		{

			$blockNew = $blockOld;

			// create a new block of content with the results replaced into it

			foreach ($tags as $ntag => $data) 

	       	{

	        	$blockNew = str_replace("{" . $ntag . "}", $data, $blockNew); 

	        }

	        $block .= $blockNew;

		}

		$pageContent = $this->page->getContent();

		// remove the seperator in the template, cleaner HTML

		$newContent = str_replace( '<!-- START ' . $tag . ' -->' . $blockOld . '<!-- END ' . $tag . ' -->', $block, $pageContent );

		// update the page content

		$this->page->setContent( $newContent );

	}

	/**

     * Replace content on the page with data from the cache

     * @param String $tag the tag defining the area of content

     * @param int $cacheId the datas ID in the data cache

     * @return void

     */

    private function replaceDataTags( $tag, $cacheId )

    {

	    $block = $this->page->getBlock( $tag );

		$blockOld = $block;

		while ($tags = PCARegistry::getObject('db')->dataFromCache( $cacheId ) )

		{

			foreach ($tags as $tag => $data) 

	       	{

		       	$blockNew = $blockOld;

	        	$blockNew = str_replace("{" . $tag . "}", $data, $blockNew); 

	        }

	        $block .= $blockNew;

		}

		$pageContent = $this->page->getContent();

		$newContent = str_replace( $blockOld, $block, $pageContent );

		$this->page->setContent( $newContent );

    }

    /**

     * Get the page object

     * @return Object 

     */

    public function getPage()

    {

	    return $this->page;

    }

    /**

     * Set the content of the page based on a number of templates

     * pass template file locations as individual arguments

     * @return void

     */

    public function buildFromTemplates()

    {

	    $bits = func_get_args();

	    $content = "";

	    foreach( $bits as $bit )

	    {

		    if( strpos( $bit, 'skins/' ) === false )

		    {

			    $bit = 'skins/' . PCARegistry::getSetting('skin') . '/templates/' . $bit;

		    }

		    if( file_exists( $bit ) == true )

		    {

			    $content .= file_get_contents( $bit );

		    }

	    }

	    $this->page->setContent( $content );

    }

    /**

     * Convert an array of data (i.e. a db row?) to some tags

     * @param array the data 

     * @param string a prefix which is added to field name to create the tag name

     * @return void

     */

    public function dataToTags( $data, $prefix )

    {

	    foreach( $data as $key => $content )

	    {

		    $this->page->addTag( $key.$prefix, $content);

	    }

    }

    public function parseTitle()

    {

	    $newContent = str_replace('<title>', '<title>'. $page->getTitle(), $this->page->getContent() );

	    $this->page->setContent( $newContent );

    }

    /**

     * Parse the page object into some output

     * @return void

     */

    public function parseOutput()

    {

	    $this->replaceBits();

	    $this->replaceTags();

	    $this->parseTitle();

    }

}

?>

<?php

/**

 * This is our page object

 * It is a seperate object to allow some interesting extra functionality to be added

 * Some ideas: passwording pages, adding page specific css/js files, etc

 */

class page {

	// room to grow later?

	private $css = array();

	private $js = array();

	private $bodyTag = '';

	private $bodyTagInsert = '';

	// future functionality?

	private $authorised = true;

	private $password = '';

	// page elements

	private $title = '';

	private $tags = array();

	private $postParseTags = array();

	private $bits = array();

	private $content = "";

	/**

	 * Constructor...

	 */

    function __construct() { }

    public function getTitle()

    {

    	return $this->title;

    }

    public function setPassword( $password )

    {

    	$this->password = $password;

    } 

    public function setTitle( $title )

    {

	    $this->title = $title;

    }

    public function setContent( $content )

    {

	    $this->content = $content;

    }

    public function addTag( $key, $data )

    {

	    $this->tags[$key] = $data;

    }

    public function getTags()

    {

	    return $this->tags;

    }

    public function addPPTag( $key, $data )

    {

	    $this->postParseTags[$key] = $data;

    }

    /**

     * Get tags to be parsed after the first batch have been parsed

     * @return array

     */

    public function getPPTags()

    {

	    return $this->postParseTags;

    }

    /**

     * Add a template bit to the page, doesnt actually add the content just yet

     * @param String the tag where the template is added

     * @param String the template file name

     * @return void

     */

    public function addTemplateBit( $tag, $bit )

    {

	    $this->bits[ $tag ] = $bit;

    }

    /**

     * Get the template bits to be entered into the page

     * @return array the array of template tags and template file names

     */

    public function getBits()

    {

	    return $this->bits;

    }

    /**

     * Gets a chunk of page content

     * @param String the tag wrapping the block ( <!-- START tag --> block <!-- END tag --> )

     * @return String the block of content

     */

    public function getBlock( $tag )

    {

		preg_match ('#<!-- START '. $tag . ' -->(.+?)<!-- END '. $tag . ' -->#si', $this->content, $tor);

		$tor = str_replace ('<!-- START '. $tag . ' -->', "", $tor[0]);

		$tor = str_replace ('<!-- END '  . $tag . ' -->', "", $tor);

		return $tor;

    }

    public function getContent()

    {

	    return $this->content;

    }

}

?>

public function storeCoreObjects()

{

	$this->storeObject('database', 'db' );

	$this->storeObject('template', 'template' );

}

// require our registry

require_once('PCARegistry/pcaregistry.class.php');

$registry = PCARegistry::singleton();

// store those core objects

$registry->storeCoreObjects();

// create a database connection

$registry->getObject('db')->newConnection('localhost', 'root', '', 'pcaframework');

// set the default skin setting (we will store these in the database later...)

$registry->storeSetting('default', 'skin');

// populate our page object from a template file

$registry->getObject('template')->buildFromTemplates('main.tpl.php');

// cache a query of our members table

$cache = $registry->getObject('db')->cacheQuery('SELECT * FROM members');

// assign this to the members tag

$registry->getObject('template')->getPage()->addTag('members', array('SQL', $cache) );

// set the page title

$registry->getObject('template')->getPage()->setTitle('Our members');

// parse it all, and spit it out

$registry->getObject('template')->parseOutput();

print $registry->getObject('template')->getPage()->getContent();