Zack LivePHP | Best Premium WordPress Themes - Zack Live

Fuel: Band New PHP Framework Based on PHP 5.3

Zack — Sun, 24 Apr 2011 16:05:44 +0000

Fuel is a simple, flexible, community driven PHP 5.3 web framework based on the best ideas of other frameworks with a fresh start.

The framework was started in late 2010 by Dan Horrigan then shortly after the team grew to include Phil Sturgeon, Jelmer Schreuder and Harro Verton. The team has decades of PHP experience between them and have all been involved with Open-Source projects such as CodeIgniter, PyroCMS, ExciteCMS and DataMapper ORM to name but a few.

VISIT Fuel PHP Framework

DOWNLOAD Fuel PHP Framework

Free jQuery Offline Learning Kit

Zack — Sun, 16 Jan 2011 16:06:29 +0000

Addy Osmani released a Free jQuery Offline Learning Kit to help people to learn jQuery 1.4.3. The pack includes printable reference sheets so that whenever you’re wondering what selector or method might be best to use, you’ll have access to material that can assist with that.

The pack also comes with all the 1.4.3 documentation in an easily browseable offline format (with all our API examples included).

If you’re looking to start working with jQuery Mobile, it can be nice to have a minimalist example at your fingertips to start off with. That’s why this pack also includes a jQuery Mobile demo application – one for PHP developers and another for Rails developers.

The Offline Learning Kit Includes

My 1.4.3 Selectors Printable that explains what each selector does and how it should be used (PDF)
The FutureColours 1.4.3 Cheatsheet showing all the different methods supported by 1.4.3 (PDF)
The jQAPI 1.4.3 Offline Documentation pack that lets you browse the documentation and API examples on your desktop (thanks to the guys at yayQuery and the awesome Ben Alman)
A Complete Developer’s jQuery 1.4.3 Mobile Demo Application (PHP courtesy of DevGrow, Rails courtesy Fuel)
Rebecca Murphy’s excellent jQuery Fundamentals book and exercises (PDF)
1.4.3 and our 1.4.4 Release Candidate Preview

DOWNLOAD jQuery Offline Learning Kit

VISIT Addy Osmani’s Blog

Health Check for WordPress 3.2

Zack — Sat, 15 Jan 2011 04:56:55 +0000

It’s for sure that WordPress will no longer support PHP 4 and MySQL 4, WordPress 3.1 is the last version that support PHP 4. It requires PHP 5.2 since WordPress 3.2.

That means some hosting on which your WordPress is running now, may not be able to upgrade to WordPress 3.2. Thus WordPress releases an official plugin Health Check to help you to find out if you host is capable for WordPress 3.2.

How to Health Check?

Go to the Plugin page in your WordPress Admin, search for Health Check plugin, and install it.

This plugin only does one thing, to check if you host is ready for WordPress 3.2. So if you see this, you are ready to go.

And then, you can Deactivate the plugin and Delete it.

PrestaShop: Open Source E-commerce Software

Zack — Thu, 06 Jan 2011 03:58:57 +0000

PrestaShop is a free open-source PHP and MySQL based e-commerse software. It was built to take advantage of essential Web 2.0 innovations such as dynamic AJAX-powered features and next-generation ergonomy. PrestaShop guides users through your product catalog intelligently and effortlessly, turning intrigued visitors into paying customers.

VISIT PrestaShop

DOWNLOAD PrestaShop

PHP.js Brings PHP Functions to JavaScript

Zack — Mon, 03 Jan 2011 04:26:37 +0000

php.js is an open source project that brings high-level PHP functions to low-level JavaScript platforms such as web browsers, browser extensions ( Mozilla/Firefox, Chrome ), AIR, and SSJS engines like V8 ( node.js,v8cgi ), Rhino, and SpiderMonkey ( CouchDB ).

Find out more on phpjs.org.

FUEL CMS: CMS Based on CodeIgniter PHP Framework

Zack — Thu, 16 Dec 2010 16:17:03 +0000

CodeIgniter is one of the best PHP frameworks, I personally prefer Kohana, but Kohana is developed from CodeIgniter.

What I want to talk about is a CMS(Content Management System) built upon CodeIgniter – FUEL CMS.

FUEL CMS is a modular-based hybrid of a framework and a content management system. It’s developed on the popular CodeIgniter PHP web framework and allows you to create your models, views and controllers like normal and only use the CMS part when and if you need it.

As an open source project, it’s totally free.

You can find out more about FUEL CMS on its official page.

Visit FUEL CMS.

Redirect Users According to Browser Language

Zack — Thu, 04 Mar 2010 04:20:36 +0000

I started a new blog Gearor.com, which is a gadgets and tech blog. I also set up a Chinese version using sub domain cn.Gearor.com. So I tried to do one thing, if visitors come with a Chinese browser, the website will automatically redirect them to the Chinese page.

At the first time, I simply check the browser language, if it’s Chinese, the page will redirect to Chinese page. There is one problem with this method. I made a English link in Chinese page so that Chinese users can visit English page if they want, but after I added the redirection, Chinese users can’t visit English page, every time they click the link, they will be redirect to Chinese page.

This means I also need to check the referral URL, if it’s from my own website, geaor.com or cn.gearor.com, we don’t need to do the redirection. Jasonbar from StackOverFlow helps me to fix this. By the way, StackOverFlow is a really great website, there are a lot of great programmers there, and they are all willing to help you. Here is my final code which is working fine on my website:

if (!preg_match('%gearor.com%i', $_SERVER['HTTP_REFERER']))
	{
		if (!preg_match('%cn.gearor.com%i', $_SERVER['HTTP_REFERER']))
		{
			if (preg_match('/zh-cn/i', $_SERVER['HTTP_ACCEPT_LANGUAGE']))
				wp_redirect('http://cn.gearor.com');
		}
	}

If you are developing multi languages website, this may help you too.

Say Hello to Kohana 3

Zack — Sat, 27 Feb 2010 04:37:46 +0000

Kohana 3 has been released for a while. This is a redesign version of Kohana. Kohana 3 and 2 will both be in active, if you are new to Kohana, I suggest you to start with Kohana 3. The most important difference between these two version is that Kohana 3 uses a new design pattern HMVC rather than MVC as Kohana 2 is using. What is HMVC? These two articles may help you understand it:

You can download Kohana 3 here:

Kohana 3 Download

As usual, it’s extremely easy to install Kohana, unzip the download file, put the Kohana folder to your web server, change permissions of following folders to 777:

application/cache
application/logs

Finally make some changes to application/bootstrap.php:

Change timezone
Set the base_url

That’s it, your Kohana is ready to go. Visit your website which should be the base_url you set above, you will see the Environment Tests page:

Notice the green background text, it’s telling you to delete the install.php file in you Kohana root. And then refresh the page, you will see “hello, world!” text. Where is the text come from? Open application->classes->controller, there is a welcome.php there. Double click the file, Here is the code:

request->response = 'hello, world!';
	}

} // End Welcome

This is the Welcome controller, the only thing it do is to print the text ‘hello, world!’ to the screen. You can try to output other text by change:

$this->request->response = 'hello, world!';

to:

$this->request->response = 'hello, Kohana 3! I am Zack from ZackLive.com~';

Now you’ve got your Kohana installed, try to get your hands dirty.

Some useful resource for Kohana 3:

If you’ve got any questions about Kohana 3, feel free to ask me by commenting here or post on Kohana forum.

Addslashes or Mysql_real_escape_string to use to Avoid SQL Injection

Zack — Wed, 24 Feb 2010 04:25:29 +0000

I was reading some articles about avoiding SQL injection. People used to use addslashes() function, and later more and more programmers are using mysql_real_escape_string(). What’s the difference between these two functions? Alan Storm from StackOverFlow gives a description which is the best as I know:

PHP’s mysql_real_escape_string function will, more or less, ask mysql what character(s) needs to be escaped, where the addslashses function will just add a backslash in front of and any single quote (‘), double quote (“), backslash (\) or NUL (the NULL byte) character.

In the same post, Waage says that:

mysql_real_escape_string adds slashes to:
\x00, \n, \r, \, ‘, ” and \x1a. characters.
Where addslashes only adds slashes to:
‘ \ and NUL

So that means mysql_real_escape_string() is better than addslashes(), I thought. If you still prefer addslashes(), you may like to have a look at this function from php5.idv.tw:

function quotes($content)
{
	//if magic_quotes_gpc=Off
	if (!get_magic_quotes_gpc())
	{
		//if $content is an array
		if (is_array($content))
		{
			foreach ($content as $key=>$value)
			{
				$content[$key] = addslashes($value);
			}
		} else
		{
			//if $content is not an array
			addslashes($content);
		}
	} else
	{
		//if magic_quotes_gpc=On do nothing
	}
	return $content;
}

This function checks if magic_quotes_gpc is on, if so, we don’t need to do addslashes(). if not, we do addslashes() in different way for array and non-array content.

Of course, you can write a similar function using mysql_real_escape_string(). Here is my version:

function quotes($content)
{
	//if $content is an array
	if (is_array($content))
	{
		foreach ($content as $key=>$value)
		{
			$content[$key] = mysql_real_escape_string($value);
		}
	} else
	{
		//if $content is not an array
		mysql_real_escape_string($content);
	}
	return $content;
}

Basically, just replace addslashes() with mysql_real_escape_string(). You can use this function like this:

$name = quotes($_POST['user']);
$password = quotes($_POST['password']);

An OOP Way to Work with MySQL Database in PHP

Zack — Mon, 15 Feb 2010 19:30:46 +0000

This is my learning note of PHP and OOP(Object Oriented Programming) from Brian Muse’s tutorial, if you are new to OOP, you may find something helpful in this post. If you are a professional, I would appreciate it if you can give me some further advices or refer me for further tutorials.

Create a Demo Database with a users table

Basically, an oop way to work with database means to create a class for database. Let’s create a new file named DB.class.php for our database class. We also need a demo database with a users table, here is the SQL:

CREATE TABLE IF NOT EXISTS `users` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL,
  `password` varchar(50) NOT NULL,
  `email` varchar(50) NOT NULL,
  `join_date` datetime NOT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `username` (`username`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1;

The DB Class and its Properties

We have a class named DB in DB.class.php, at the very beginning we can write the follow codes:

And then, we need to consider about the properties and functions of the class. In this case, we need the following properties:

$db_name: database name
$db_user: database username
$db_pass: database password
$db_host: host of the database

Because these variables are not necessary to be accessed from outside the class, we will define them as “protected”:

They can be used inside the class by using $this->db_name, $this->db_user, etc. That’s all properties we need, and now we need to think about what functions we need.

Functions of DB Class

While using database, the first thing we need to do is to connect to the database, so the first function should be connect(). There are several common operations we also need: insert, update, select and delete. One more thing we need to think about is that the select function will pull some data out from the database, the database normally returns row set, it is better that we convert row set into associative array for later use. So we add a function processRowSet() for this. Let’s code the first function, connect():

    //Connect to the database.
    //You need to call this on every page using database

    public function connect() {
        $connection = mysql_connect($this->db_host, $this->db_user, $this->db_pass);
        mysql_select_db($this->db_name);  

        return true;
    }

Not thing special in this function, just connect to the database using mysql_connect(), select database by using mysql_select_db(), and then return true telling the function executed successfully. The next function is insert(), here is codes:

    //Inserts a new row into the database.
    //takes an array of data, where the keys in the array are the column names
    //and the values are the data that will be inserted into those columns.
    //$table is the name of the table.
    public function insert($data, $table) {  

        $columns = "";
        $values = "";  

        foreach ($data as $column => $value) {
            $columns .= ($columns == "") ? "" : ", ";
            $columns .= $column;
            $values .= ($values == "") ? "" : ", ";
            $values .= $value;
        }  

        $sql = "insert into $table ($columns) values ($values)";  

        mysql_query($sql) or die(mysql_error());  

        //return the ID of the user in the database.
        return mysql_insert_id();  

    }

The foreach loop is to combine each column and value in $data into columns and values, separating each other by comma, so that we can use one query to insert all data. After inserting, we return the id of the new row(which should be user in this tutorial).

Before we go to select(), we need to write the codes of processRowSet():

    //takes a mysql row set and returns an associative array, where the keys
    //in the array are the column names in the row set. If singleRow is set to
    //true, then it will return a single row instead of an array of rows.
    public function processRowSet($rowSet, $singleRow=false)
    {
        $resultArray = array();
        while($row = mysql_fetch_assoc($rowSet))
        {
            array_push($resultArray, $row);
        }  

        if($singleRow === true)
            return $resultArray[0];  

        return $resultArray;
    }

This function loops through each row in $rowSet, converts each row into an associative array($row) using mysql_fetch_assoc() function, and then pushes each array into one array($resultArray) which will be returned in the end of the function. If the $singleRow is set to true, only the first array will be returned.

Now let’s see the select() function:

    //Select rows from the database.
    //returns a full row or rows from $table using $where as the where clause.
    //return value is an associative array with column names as keys.
    public function select($table, $where) {
        $sql = "SELECT * FROM $table WHERE $where";
        $result = mysql_query($sql);
        if(mysql_num_rows($result) == 1)
            return $this->processRowSet($result, true);  

        return $this->processRowSet($result);
    }

This function select some data from the database, converts row set into associative array using processRowSet(), here you can see how the $singleRow parameter is used.

The next function is update():

    //Updates a current row in the database.
    //takes an array of data, where the keys in the array are the column names
    //and the values are the data that will be inserted into those columns.
    //$table is the name of the table and $where is the sql where clause.
    public function update($data, $table, $where) {
        foreach ($data as $column => $value) {
            $sql = "UPDATE $table SET $column = $value WHERE $where";
            mysql_query($sql) or die(mysql_error());
        }
        return true;
    }

This function loops through $data, update each $column with $value according to $where, if everything goes well, return true, otherwise, die with MySQL error message.

The final one is the delete() function:

   public function delete($table, $where) {
        $sql = "DELETE * FROM $table WHERE $where";
        mysql_query($sql) or die(mysql_error());
        return true;
}

This may be the simplest one, just run the query and return true or die with error message.

Using DB Class

As a result, the DB class should be like this:

db_host, $this->db_user, $this->db_pass);
        mysql_select_db($this->db_name);  

        return true;
    } 

    //Inserts a new row into the database.
    //takes an array of data, where the keys in the array are the column names
    //and the values are the data that will be inserted into those columns.
    //$table is the name of the table.
    public function insert($data, $table) {  

        $columns = "";
        $values = "";  

        foreach ($data as $column => $value) {
            $columns .= ($columns == "") ? "" : ", ";
            $columns .= $column;
            $values .= ($values == "") ? "" : ", ";
            $values .= $value;
        }  

        $sql = "insert into $table ($columns) values ($values)";  

        mysql_query($sql) or die(mysql_error());  

        //return the ID of the user in the database.
        return mysql_insert_id();  

    } 

    //takes a mysql row set and returns an associative array, where the keys
    //in the array are the column names in the row set. If singleRow is set to
    //true, then it will return a single row instead of an array of rows.
    public function processRowSet($rowSet, $singleRow=false)
    {
        $resultArray = array();
        while($row = mysql_fetch_assoc($rowSet))
        {
            array_push($resultArray, $row);
        }  

        if($singleRow === true)
            return $resultArray[0];  

        return $resultArray;
    } 

    //Select rows from the database.
    //returns a full row or rows from $table using $where as the where clause.
    //return value is an associative array with column names as keys.
    public function select($table, $where) {
        $sql = "SELECT * FROM $table WHERE $where";
        $result = mysql_query($sql);
        if(mysql_num_rows($result) == 1)
            return $this->processRowSet($result, true);  

        return $this->processRowSet($result);
    } 

    //Updates a current row in the database.
    //takes an array of data, where the keys in the array are the column names
    //and the values are the data that will be inserted into those columns.
    //$table is the name of the table and $where is the sql where clause.
    public function update($data, $table, $where) {
        foreach ($data as $column => $value) {
            $sql = "UPDATE $table SET $column = $value WHERE $where";
            mysql_query($sql) or die(mysql_error());
        }
        return true;
    } 

   public function delete($table, $where) {
        $sql = "DELETE * FROM $table WHERE $where";
        mysql_query($sql) or die(mysql_error());
        return true;
    }

}

?>

Here is a sample of how to use the DB class:

//create an instance of the DB class
$db = new DB(); 

//connect to the database
$db->connect(); 

$data = array(
    "username" => "'Jack'",
    "email" => "'jack@email.com'"
);

//insert a new user
$db->insert($data, 'users');

//change the email of Jack
$data = array(
    "username" => "Jack",
    "email" => "jack.gmail@gmail.com"
);

//update Jack
$db->update($data, 'users', 'id = 1');

//delete Jack
$db->delete('users', 'id = 1');

Hello World Tutorial for Kohana

Zack — Tue, 01 Jul 2008 04:44:47 +0000

It seems unnecessary to write a Hello World tuorial for a PHP framework, because when someone comes to framework, he is no longer a beginner, can figure out his own Hello World. But this idea comes up in my brain, and I guess it might be helpful for someone who is the first time to work with MVC or OOP. It’s quite simple, let’s get started.

You should have installed Kohana correctly, now we create a hello.php in /application/controllers/, here is the content of the file:

/**
* Hello World controller
*/
class Hello_Controller extends Template_Controller
{
function __construct()
{
parent::__construct();
}

function index()
{
$this->template->title = “Hello World”;
$this->template->content = “Hello, welcome to Kohana World !!!”;
}
}
?>

We have a Hello Controller with a index method, so we can call this page in the URL: localhost/kohana/index.php/hello. If you cannot understand this, you may want to see ‘Show me, don’t tell me‘ section in Kohana 101. In the Hello Controller, we set the title and content of our Hello World page, of course you can change the title and content into anything.

Now we have a Controller, we also need a View to reveal the page. Create a template.php in /applicaion/views/, and type in the fellowing codes:

<?php echo $title ?>

Very simple HTML codes, echo the title and content set in the Hello Controller to the page, that’s all what it does. You can see how Kohana works, processing in Controller, sending the result to View, and the View exhibit the page.

Usually I’d like to add a profiler to a example page, so that we can see some system information. It’s very easy to do that, just add one line to the Construt function in the Controller:

$this->profiler = new Profiler;

So the Hello Controller file should look like this:

/**
* Hello World controller
*/
class Hello_Controller extends Template_Controller
{
function __construct()
{
parent::__construct();
$this->profiler = new Profiler;
}

function index()
{
$this->template->title = “Hello World”;
$this->template->content = “Hello, welcome to Kohana World !!!”;
}
}
?>

We can now visit localhost/kohana/index.php/hello, you will have a page the same as the image above.

You already have some basic concepts of Kohana now, I highly recommand you to read Kohana 101, or if you are even not sure how to setup your own Kohana, you can read my post, Install Kohana on Windows. Hope this can help you.