Are you looking forward to a Fast Tax Return this year? A key place to start is organizing your information. If you break the  process down into many small steps you will be able to get everything done faster and may even come away feeling like you have accomplished something!

I hate to admit this – and I’m sure this has never happened to anyone but me! – but I have had to take a dive on a few tax credits because I couldn’t find my receipts, even electronic receipts.   For Example, When I am “filing” emails and paperwork I always think that I can easily remember where I deposited them. Eight months later when I go to my email “business” folder to find all of the online receipts and confirmations, I don’t see the big donation I made to the SPCA! After sifting through all of the extraneous emails that wound up in my business folder because I needed to quickly clear out my exploding inbox, I remember that for the first few months of the year I was using the previous year’s tax folder to file business items! Sounds confusing I know, but you get the picture; a lot of info is processed over the course of a year and a little organization will keep us from pulling our hair out trying to find it! Below is my suggestion for gathering 2011 tax info and setting yourself up for an easier time preparing for 2012 taxes.

Info gathered online

~ Break out a new sheet on “notepad” or one of your other favorite place to write lists on your computer.
~ Start by taking a quick review of every folder for every email address you have. The task at hand is to establish a base from which you can get the info you need.  This list is just for you so don’t worry about whether they do or don’t have tax info in them at this point.
~ Jot down the email addresses and the folders you will need to have a look at.
~ Now create a folder on your main email address that is labeled ’2011 Taxes’
~ Over the next few days check the folders for Tax info.
~ Move anything into the ’2011 Taxes’ folder that could possibly relate to taxes.
~ Now you can tackle the items in your ’2011 Taxes’ folder and drill down even further.
~ Once the sorting is finished you should have a “pure” ’2011 Taxes’ folder that can be used to prepare your own tax return or send it off to a tax professional.
~ Continue to add to the ’2011 Taxes’ folder any correspondence or documents that are sent your way. This is a great thing to have if you are ever audited!

Do the same sorting with Hard-copy information

Gather up anything that looks like it might be tax related and deposit it into a folder or basket, grocery bag or anything that can hold it all temporarily.  Once you have scoured the house and your basket is full, sit down and go through everything in the basket until you have a good set of paperwork to either take to your tax professional or process yourself. (Tax professionals are very good at sifting through paperwork so if you have included something that cant be used it won’t hurt anything)

2012 tax year

Start now by creating a ’2012 Tax’ email folder.  Throughout the year move anything into it that could possibly be used on your tax return. Do the same for hard copy information: Get a folder or bin going right away and you will be glad that most of the above steps wont be needed when January 2013 rolls around.

Looking for more information?  Check out these articles:

~ Looking for additional information on organizing your paper piles? Check out this article by Home Goes Strong – “Getting Organized: Learning How to Deal with Paper Piles”
~ There are people out there who will take your piles and sort through them for you – PilesofPaper.com advertises that for a fee they will process your documents and return them to you organized!
~ Maybe there is a Tax Deduction you didn’t know about?  Check out Kiplinger’s article “The Most-Overlooked Tax Deductions” or MSN Money’s “The 19 most-overlooked tax deductions“

The first thing we need to do is create a folder named “vendors” under “application”. In the “vendors” folder, create another folder named “Zend” (yes, with a capital “Z”). Next we’ll need to download the latest version of Zend Framework, so click here to download 1.10.5. Open the archive up and extract everything from “ZendFramework-1.10.5-minimal/library/Zend/” into “application/vendors/Zend”.

Open the “application/bootstrap.php” file and add the following above the line which reads “echo Request::getInstance()”:

[php]
$path = Kohana::find_file(‘vendors’, ‘Zend/Loader’);

if($path)
{
ini_set(‘include_path’,
ini_get(‘include_path’) . PATH_SEPARATOR . dirname(dirname($path)));

require_once ‘Zend/Loader/Autoloader.php’;
Zend_Loader_Autoloader::getInstance();
}
[/php]

Open “application/views/pages/ko3.php” and put the following at the bottom:

[php]
<?php $validator = new Zend_Validate_Isbn();?>
<br />978-3-16-148410-0 <?php echo ($validator->isValid(’978-3-16-148410-0′)) ? ‘is’ : ‘is not’;?> valid.
<br />9783161484100 <?php echo ($validator->isValid(’9783161484100′)) ? ‘is’ : ‘is not’;?> valid.
[/php]

Now if you load “http://yourserver/mykohana3/ko3″ in your browser, you should see the two tests at the bottom.

Until next time, when I go over forms, happy coding.

If you enjoyed this tutorial, please check out our tech blog and computer related coupons.

Part 8

Here’s a couple links to get you up to speed:
Installing Mongo
MongoDB PHP Extension

If you have issues with MongoD not starting – something about “/data/db” missing, then you should create the directory. In *Nix: “mkdir /data/db”, in Win “mkdir c:data” then “mkdir c:datadb”.

Connecting
MySQL

[php]
<?php
$host = ‘localhost’;
$user = ‘root’;
$pass = “”;
$link = mysql_connect($host, $user, $pass, 1) or die(“Could not connect to: {$host}. Check your settings and try again.”);
[/php]

MongoDB

[php]
<?php
try
{
$link = new Mongo();
}
catch(MongoConnectionException $e)
{
die(‘Could not connect. Check to make sure MongoDB is running.’);
}
[/php]

As you can see, Mongo DB automatically will connect to the local host and default port. Yes, MySQL will do the same if you have the directives in your “php.ini” setup to do this. IE. “mysql.default_host”, “mysql.default_user” and “mysql.default_password”. You might notice that by default MongoDB doesn’t have a user name or password setup. I will go over how to set that up in part 2.

Creating and using a DB
MySQL

[php]$db = ‘testdb’;
$sql = “CREATE DATABASE `$db`”;

mysql_query($sql, $link);
mysql_select_db($db, $link);
[/php]

MongoDB

[php]$db = $link->testdb;
[/php]

In one line of code, MongoDB will create a DB automatically if it doesn’t already exists and select (use) it.

Create a Table / Collection
MySQL

[php]
// Create the Table
$tbl = ‘user’;
$sql = “CREATE TABLE `$tbl` (`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY, `login` VARCHAR (24)NOT NULL, `password` CHAR(32) NOT NULL, `email` VARCHAR(255)) TYPE=innodb;”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Create the collection (AKA Table)
$col = $db->user;
[/php]

Once again, MongoDB will automatically create something for us if it doesn’t exist. In this example, it create our “user” table. You might notice we didn’t define how the table is formatted, this is because MongoDB is schema-less and doesn’t need column definitions. “Tables” in MongoDB are called “collections”.

Insert Data
MySQL

[php]
// Insert a row into the table
$sql = “INSERT INTO `$tbl` SET `login` = ‘jsmith’, `password` = ’5f4dcc3b5aa765d61d8327deb882cf99′, `email` = ‘jsmith@example.com’”;
mysql_query($sql);

$sql = “INSERT INTO `$tbl` SET `login` = ‘psmith’, `password` = ’5f4dcc3b5aa765d61d8327deb882cf99′, `email` = ‘psmith@example.com’”;
mysql_query($sql);

// Get the ID of last insert
$id = mysql_insert_id($link);
[/php]

MongoDB

[php]
// Insert a document (row) into the collection (table)
$doc = array(‘login’ => ‘jsmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘jsmith@example.com’);
$col->insert($doc, true);

$doc = array(‘login’ => ‘psmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘psmith@example.com’);
$col->insert($doc, true);

// Get the id of last insert
$id = $doc['_id'];
[/php]

You might have noticed that we used an array to define our “row” of data, which are called “documents”. On the insert method, the second argument will set the query to do a “safe insert”. This will allow us to find out if the query executed properly. If not set, it will not get that information. So I would set it to true if you want to be able to debug your queries. If you are wondering about the password, it’s the MD5 hash for “password”.

Querying Data
MySQL

[php]
// Get all rows
$sql = “SELECT * FROM `$tbl`”;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}
}

// Query for the row matching the last insert ID
$sql = “SELECT * FROM `$tbl` WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);
$row = mysql_fetch_assoc($qry);

echo ‘Single row (id = $id):&lt;br/&gt;&lt;pre&gt;’;
print_r($row);
echo ‘</pre>
[/php]

MongoDB

[php]
// Get all documents
$res = $col->find();

echo ‘All documents:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for the document matching the last insert ID
$doc = $col->findone(array(‘_id’ => $id));

echo ‘Single document (_id = $id):<br/><pre>’;
print_r($doc);
[/php]

The MongoDB support in PHP has function to pull a single document, or all the documents. Once again, we use arrays to define something, in this example, we define our constraint.

Upading Data
MySQL

[php]
$sql = “UPDATE `$tbl` SET `password` = ‘b497dd1a701a33026f7211533620780d’ WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);

$sql = “SELECT * FROM `$tbl` WHERE `id` = {$id}”;
$qry = mysql_query($sql, $link);
$row = mysql_fetch_assoc($qry);

echo ‘Updated row (id = $id):<br/><pre>’;
print_r($row);
echo ‘</pre>
[/php]

MogoDB

[php]
// Update a document
$col->update(array(‘_id’ => $id), array(‘$set’ => array(‘password’ => ‘b497dd1a701a33026f7211533620780d’)));

// Query the updated docuemnt
$doc = $col->findone(array(‘_id’ => $id));

echo ‘Updated docuement:<br/><pre>’;
print_r($doc);
echo ‘</pre>’;
[/php]

The MongoDB extension has a function to perform updates. The first argument is an array of constraints, IE “WHERE {expression}”. The second is the data we want to update and what we want to update it with. Pretty simple, right?

Indexing data
MySQL

[php]
// Create a unique index
$sql = “ALTER TABLE `$db`.`$tbl` ADD UNIQUE `login` (`login`)”;
$qry = mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Create a unique index
$col->ensureIndex(array(“login” => 1), array(“unique” => true, “dropDups” => true));
[/php]

MongoDB has method for creating index name “ensureIndex”. The first parameter is an array of what we want to index and the value is ether 1 or -1. 1 means that the index will sort the data for this in an ascending manor, while -1 will sort it in a descending manor. The second parameter are extra options. In this example I tell it to make what ever I’m indexing as a unique index, that way I don’t end up with multiple “jsmith” entries. Also, I’ve told it to drop any documents that have duplicates of the data in the “login” “column”. Another note is that “columns” in MongoDB should be called “elements”, since we are really dealing with arrays.

Lets make sure our index is working shall we?
MongoDb

[php]
// Test our unique index
try
{
$doc = array(‘login’ => ‘jsmith’, ‘password’ => ‘ 5f4dcc3b5aa765d61d8327deb882cf99′, ‘email’ => ‘jsmith@example.com’);
$col->insert($doc, true);
}
catch(MongoCursorException $e)
{
echo ‘Could not insert document. Double check values.<br />’;
}
[/php]

If all works, we should get an error message.

Limiting Results
MySQL

[php]
// Limits
$sql = “SELECT * FROM `$tbl` LIMIT 1″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Limit by 1:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}
}
[/php]

MongoDB

[php]
// Limits
$res = $col->find()->limit(1);

echo ‘All documents – Limited to 1:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Offsetting
MySQL

[php]
// Limits
$sql = “SELECT * FROM `$tbl` OFFSET 1 LIMIT 1″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Limit by 1 – Offset by 1:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
[/php]

MongoDB

[php]
// Offsets
$res = $col-&gt;find()-&gt;skip(1)-&gt;limit(1);

echo ‘All documents – Limited to 1, Offset by 1:<br/ >’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
</pre>
[/php]

To offset a your query start point, we used the method “skip” with an integer value to create the offset.

Sorting
MySQL

[php]
// Sorting
$sql = “SELECT * FROM `$tbl` ORDERBY `login` DESC”;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All rows – Sorted by login descending:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’
}while(–$cnt > 0);
}
[/php]

MongoDB

[php]
// Sorting
$res = $col->find()->sort(array(‘login’ => -1));

echo ‘All documents – Sorted by login descending:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Here we used the sort method, told it what element to sort on and which direction, -1 being descending. The record for “psmith” should show up first. A word of caution here, there is a 4MB limit if sorting on non-indexed element.

Advanced Queries
MySQL

[php]
// Advanced queries
// Add new column
$sql = “ALTER `$db`.`$tbl` ADD COLUMN `age` INT UNSIGNED”;
mysql_query($sql, $link);

// Add values
$sql = “UPDATE `$tbl` SET `age` = 40 WHERE `login` = ‘jsmith’”;
mysql_query($sql, $link);

$sql = “UPDATE `$tbl` SET `age` = 24 WHERE `login` = ‘psmith’”;
mysql_query($sql, $link);

// Query for anyone under 30
$sql = “SELECT * FROM `$tbl` WHERE `age` < 30″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone under 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone over 30
$sql = “SELECT * FROM `$tbl` WHERE `age` > 30″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone over 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query from anyone 25 and over
$sql = “SELECT * FROM `$tbl` WHERE `age` >= 25″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 25 and over:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
// Query for anyone 25 and under
$sql = “SELECT * FROM `$tbl` WHERE `age` <= 25″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 25 and under:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone not 40
$sql = “SELECT * FROM `$tbl` WHERE `age` != 40″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone not 30:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}

// Query for anyone 20-50
$sql = “SELECT * FROM `$tbl` WHERE `age` >= 20 AND `age` <= 50″;
$qry = mysql_query($sql, $link);
$cnt = mysql_num_rows($qry);

echo ‘All documents – Anyone 20-50:<br/>’;

if($cnt > 0)
{
do
{
$row = mysql_fetch_assoc($qry);

echo ‘<pre>’;
print_r($row);
echo ‘</pre>’;
}
}
[/php]

MongoDB

[php]
// Advanced queries
// Add a new element and value
$col->update(array(‘login’ => ‘jsmith’), array(‘$set’ => array(‘age’ => 40)));
$col->update(array(‘login’ => ‘psmith’), array(‘$set’ => array(‘age’ => 24)));

// Confirm
$res = $col->find();

echo ‘All documents – Confirming age element:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone under 30
$res = $col->find(array(‘age’ => array(‘$lt’ => 30)));

echo ‘All documents – Anyone under 30:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone over 30
$res = $col->find(array(‘age’ => array(‘$gt’ => 30)));

echo ‘All documents – Anyone over 30:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query from anyone 25 or over
$res = $col->find(array(‘age’ => array(‘$gte’ => 25)));

echo ‘All documents – Anyone 25 or older:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone 25 and under
$res = $col->find(array(‘age’ => array(‘$lte’ => 25)));

echo ‘All documents – Anyone 25 or younger:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone not 40
$res = $col->find(array(‘age’ => array(‘$ne’ => 40)));

echo ‘All documents – Anyone not 40:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}

// Query for anyone 20-50
$res = $col->find(array(‘age’ => array(‘$gte’ => 20, ‘$lte’ => 50)));

echo ‘All documents – Anyone 20-50:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

With MongoDB you can do “<,<=, >, >=” conditional operator based queries. Only thing is that you can’t just use “<,<=, >, >=” in your constraints, you have to use MongoDB’s version. Those are “$lt” (less than), “$lte” (less than or equal), “$gt” (greater than), “$gte” (greater than or equal). Yes, you need the dollar sign. Other conditional operators are “$ne” (not equal to), “$in” (like MySQL’s IN statement), “$nin” (NOT IN), “$mod” (Modulo operation), “$all” (like in, but all values much be matched to a document), “$size” (Match of number of elements), “$exists” (element exists), “$type” (matches element type – int, string, etc) and there are couple more.

Deleting a Row / Docuement
MySQL

[php]
// Delete a row
$sql = “DELETE FROM `$tbl` WHERE `login` = ‘psmith’”
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Delete a document
$col->remove(array(‘age’ => 24), array(‘justOne’ => true, ‘safe’ => true));

// Confirm delete
$res = $col->find();

echo ‘All documents:<br/>’;

foreach($res as $doc)
{
echo ‘<pre>’;
print_r($doc);
echo ‘</pre>’;
}
[/php]

Here we use the “remove” method. First argument has the constraints and the second tell it to only remove one item and also to run a “safe” query.

Dropping a Table / Collection
MySQL

[php]
// Drop table
$sql = “DROP TABLE `$db`.`$tbl`”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Drop collection
$col->drop();
[/php]

Dropping a database
MySQL

[php]
// Drop DB
$sql = “DROP DATABASE `$db`”;
mysql_query($sql, $link);
[/php]

MongoDB

[php]
// Drop DB
$db->drop();
[/php]

Disconnect
MySQL

[php]
// Disconnect
mysql_close($link);
[/php]

MongoDB

[php]
// Disconnect
$link->close();
[/php]

Until next time, when I will go over more stuff, happy coding.

Sources:
PHP.net, MongoDB

Part 2

Before we get into views, we’ll want to update the KO3 code base. Go in to “application” directory and rename your “bootstrap.php” to “bootstrap.bak.php”. Now point your browser to http://kohanaframework.org/download (Yes there is a new site), download the latest stable (3.0.4.2), open it and extract everything inside the “kohana” folder to “mykohana3″. Once you have done that, delete or rename the “install.php” in your “mykohana3″ folder. Next, delete the “bootstrap.php” file in the “application” folder and rename the “bootstrap.bak.php” to “bootstrap.php”.

So what is a module? A module is pretty much just a plug in. It can extend the core, give you whole new section to your project (IE. blogs and forums), or just give you a set of classes that are available globally. So lets jump right in!

Add a new directory to the “modules” directory and name it “fortune”. In the “module/fortune” directory add the following directories “classes” and “views”. In “/module/fortune/classes” create a folder named “kohana”. In “/module/fortune/views” create a folder named “fortune”. So you should have a directory that looks something like this:
[php]
modules
+– fortune
|– classes
| +– kohana
+– views
+– fortune
[/php]
Create a new file in “/module/fortune/classes/” named “fortune.php” and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);
class Fortune extends Kohana_Fortune{}
[/php]
This is pretty simple. Just extends another class. If you’ve gone through the code base for KO3, this will probably look familiar. Now lets create the main class file, so open a new file and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

/**
* Fortune Cookie Module
*/
class Kohana_Fortune
{
// Merged configuration settings
protected $config = array(‘view’ => ‘fortune/default’);
protected $fortune = "";

/**
* Creates a new Fortune object.
*
* @return Forune
*/
public static function factory(array $config = array())
{
return new Fortune($config);
}

public function __construct(array $config = array())
{
// Overwrite system defaults with application defaults
$this->config = $this->config_group() + $this->config;
}

/**
* Retrieves a fortune config group from the config file. One config group can
* refer to another as its parent, which will be recursively loaded.
*
* @param STRING fortune config group; "default" if none given
* @return ARRAY config settings
*/
public function config_group($group = ‘default’)
{
// Load the fortune config file
$config_file = Kohana::config(‘fortune’);

// Initialize the $config array
$config = array(‘group’ => (string)$group);

// Recursively load requested config groups
while(isset($config['group']) && isset($config_file->$config['group']))
{
// Temporarily store config group name
$group = $config['group'];
unset($config['group']);

// Add config group values, not overwriting existing keys
$config += $config_file->$group;
}

// Get rid of possible stray config group names
unset($config['group']);

// Return the merged config group settings
return $config;
}

/**
* Randomly pick a fortune
*
* @return STRING fortune text
*/
public function getFortune()
{
// Stolen from: http://fortunes.cat-v.org/plan_9/
$fortunes = array(’2 is always smaller than 3, even for large values of 2.’,
‘A penny saved is a political breakthrough.’,
‘Avoid reality at all costs.’,
‘Bad taste is timeless.’);

$this->fortune = $fortunes[array_rand($fortunes, 1)];
}

/**
* Renders the fortune.
*
* @param MIXED string of the view to use, or a Kohana_View object
* @return STRING fortune output (HTML)
*/
public function render($view = NULL)
{
if($view === NULL)
{
// Use the view from config
$view = $this->config['view'];
}

if(!$view instanceof Kohana_View)
{
// Load the view file
$view = View::factory($view);
}

$this->getFortune();

// Pass on the whole Fortune object
return $view->set(get_object_vars($this))->set(‘page’, $this)->render();
}

/**
* Renders the fortune.
*
* @return STRING fortune output (HTML)
*/
public function __toString()
{
return $this->render();
}
}
[/php]
Save this as “fortune.php” in “/modules/fortune/classes/kohana”. For the most part this looks like a simple Kohana core. We have 2 protected properties, config and fortune. The config property is for, well, a configuration. We only use the view configuration value here. The fortune property is hopefully the land that my house sits on… er… It is used to store a single fortune for our output.

Next we have our factory method so we can do the factory pattern. Then we have our constructor which pulls in a configuration from the config variable and recreates the config property with default configurations from a file, set array element and from what has been passed to it with the help of the next method called “config_group”.

The heart of this class is the getFortune method. I cheated here and used an array instead of creating a model and pulling stuff from the db. So I pull a random element and place it in our fortune property. Next up is the render method. This just runs the getFortune method and then renders the view. The last one, __toString calls the render method.

Create a new file and put the following into it:
[php]
<div style="width: 250px; height: 52px; vertical-align: middle; display: table-cell; text-align: center; border: 1px solid #CCCCCC; border-right-color: #666666; border-bottom-color: #666666;">
<p><?php echo $fortune;?></p>
</div>
[/php]
Save this as “default.php” under “/modules/fortune/views/fortune/default.php”. Pretty simple. You might notice that I’m echoing out $fortune, which happens to the protected property in our class. In the render method, we pass all the properties to the view. Makes things simple.

Next up is to edit a couple files. Open up the “/application/bootstrap.php” file and locate the section with “Kohana::modules” in it. Now replace that with:
[php]Kohana::modules(array(// ‘auth’ => MODPATH.’auth’, // Basic authentication
// ‘codebench’ => MODPATH.’codebench’, // Benchmarking tool
‘database’ => MODPATH.’database’, // Database access
// ‘image’ => MODPATH.’image’, // Image manipulation
// ‘orm’ => MODPATH.’orm’, // Object Relationship Mapping
// ‘pagination’ => MODPATH.’pagination’, // Paging of results
// ‘userguide’ => MODPATH.’userguide’, // User guide and API documentation
‘fortune’ => MODPATH.’fortune’,
));[/php]
We’ve added the new fortune module and enabled it in our system here. Now open the the “/application/views/pages/ko3.php” file and add the following to the bottom of it.
[php]
<?php echo Fortune::factory();?>
[/php]

Now if you point your browser to “http://yourserver/mykohana3/ko3/” you should see the fortune at the bottom!

Until next time, when I go over including external libraries, happy coding.

Part 7 | Part 9

So pretty much they are static methods that “help” with doing common things, IE: working with arrays or URLs. Kohana comes with quite a few “helpers” prepackaged. See the KO3 API Guide.

So how do we make a “helper”? Fire up your IDE and let get coding. The first thing we should is create a new directory called “helper” under “/application/classes”. Create a new file and put the following into it:
[php]<?php
class Helper_MyUrl
{
public static function SEOIt($str)
{
$str = preg_replace(array(‘/s/’, ‘/[$.+!*'(),"]/’), array(‘-’, “”), $str);
return $str;
}
}[/php]
Save to this as “myurl.php” under “/application/classes/helper”. Now open “/application/views/pages/ko3.php” and add the following to the bottom and save it.:
[php] <br /><?php echo Helper_MyUrl::SEOIt(‘This Is a string!!!’);?>[/php]
So if you point your browser to “http://yourserver/mykohana3/ko3/”, you should see “ThisIsastring” at the bottom. Pretty simple!

Until next time, when I go over modules, happy coding.

Sources used: Kohana PHP 2.x Docs, Kohana Forums

Part 6 | Part 8

So we’ve been design pages with a single controller as a page, with some actions that pulls data in from a model and populates a parts of a view to give us a complete browser page. Well, that can get messy with all the model calls and extra snippets we bring into with views. Using HMVC, we can organize our code a lot better, make more things reusable and with the way Kohana PHP 3 does HMVC, we can even make our application scale by calling out to other servers to give us our content for a section.

Lets go ahead and make a new controller:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Hmvc extends Controller_DefaultTemplate
{
public function action_index()
{
// Set meta data
$this->template->title = ‘Kohana 3.0 HMVC Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, HMVC’;
$this->template->meta_description = ‘A test of of the KO3 framework HMVC pattern’;

// Fill in content
$ko3 = array();
$ko3['posts'] = Request::factory(‘posts/getposts’)->execute()->response;

$this->template->content = View::factory(‘pages/hmvc’, $ko3);
}

}[/php]
Save this as “hmvc.php” in “application/classes/controller”. The above should look pretty familiar. One line should stand out:
[php]$ko3['posts'] = Request::factory(‘posts/getposts’)->execute()->response;[/php]
This line is where the HMVC magic happen. This will call the controller “posts” an invoke the action “getposts”, execute the code and get the response. We take the response and save it to the array which we fill the view with.

Talking about views, let make our view for this controller:
[php]<?php echo $posts;?>[/php]
Save this as “hmvc.php” in “application/views/pages/”

Now for the “posts” controller:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Posts extends Controller
{
public function action_index()
{
}

public function action_getposts()
{
// Load model
$posts = new Model_Post();

// Fill content array for view with last 10 posts.
$content = array();
$content['posts'] = $posts->getLastTenPosts();

// Render and output.
$this->request->response = View::factory(‘pages/hmvc_posts’, $content);
}
}[/php]
Save this as “posts.php” in “application/classes/controller”. Once again, pretty straight forward. This controller extends the basic controller, so nifty template or anything and is pretty much what we did in the last tutorial.

Now for the view.
[php]<?php foreach($posts as $post):?>
<h1><?php echo $post['title'];?></h1>
<?php echo $post['post'];?>
<hr />
<?php endforeach;?>[/php]
Save this as “hmvc_posts.php” under “applications/views/pages”.

Now if you point your browser to: “http://yourserver/mykohana3/hmvc”, you should see a couple posts up on the screen.

We can achieve the same result by calling the controller from the view instead of the controller. This is helpful for keeping it simple. So one template used all over the place, you wouldn’t have to worry about having to putting in all the HMVC stuff into the controllers that used that template.

Change the “hmvc” controller to look like this:
[php]<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_Hmvc extends Controller_DefaultTemplate
{
public function action_index()
{
// Set meta data
$this->template->title = ‘Kohana 3.0 HMVC Test’;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework, HMVC’;
$this->template->meta_description = ‘A test of of the KO3 framework HMVC pattern’;

// Fill in content
$ko3 = array();
$ko3['content'] = ‘Hello there!’;
$this->template->content = View::factory(‘pages/hmvc’, $ko3);
}
}[/php]
Now edit the “hmvc” view to look like this:
[php]<?php echo $content;?><br/>
<?php echo Request::factory(‘posts/getposts’)->execute()->response;?>[/php]
This is example is pretty simple and we could expand this to use parameters to deliver the data in different ways, say, simple html, full html, xml, json, etc..

Sources used: Unofficial Kohana 3 Wiki, iBuildings: Scaling Web Applications with HMVC

<<Part 4 | Part 6>>

As you can see the above pretty much looks like a view we have done before, a bit more expanded. I will go over the “foreach” a little bit later. Unlike a view, this will most likely be used by all of your project. Since we will point to this file for our template, or shell, this will reduce the amount of code you have to put in each view, keeping thing separated, easier to maintain, or basically “DRY”.

Now that we have a template, our system isn’t going to do anything with it until well tell it to use it. So lets go back to our IDE and create a new file and put the following into it:
[php]
<?php
defined(‘SYSPATH’) or die(‘No direct script access.’);

class Controller_DefaultTemplate extends Controller_Template
{
public $template = ‘templates/default’;

/**
* Initialize properties before running the controller methods (actions),
* so they are available to our action.
*/
public function before()
{
// Run anything that need ot run before this.
parent::before();

if($this->auto_render)
{
// Initialize empty values
$this->template->title = ”;
$this->template->meta_keywords = ”;
$this->template->meta_description = ”;
$this->template->meta_copywrite = ”;
$this->template->header = ”;
$this->template->content = ”;
$this->template->footer = ”;
$this->template->styles = array();
$this->template->scripts = array();
}
}

/**
* Fill in default values for our properties before rendering the output.
*/
public function after()
{
if($this->auto_render)
{
// Define defaults
$styles = array(‘assets/css/reset.css’ => ‘screen’);
$scripts = array(‘http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js’);

// Add defaults to template variables.
$this->template->styles = array_reverse(array_merge($this->template->styles, $styles));
$this->template->scripts = array_reverse(array_merge($this->template->scripts, $scripts));
}

// Run anything that needs to run after this.
parent::after();
}
}
[/php]
And save this as “defaulttemplate.php” under your “/application/classes/controller/” folder.

The above code extends the “Controller_Template” class and does three main things, initialize some properties (variables) to be accessable by our methods (actions) and appends default values to them and then gets associates them to our template variables before we render the final output to the screen. This is where the foreach() loop in the template comes into play. The foreach() loop uses a static method for the helper class “HTML” to load CSS style sheets and load JS files. Both of these helper methods will iterate through an array and properly wrap it in the appropriate tag. They can take a path or a URL.

You might be wondering what a “Helper” is, so here is a quick definition from the Kohana PHP 2.x documents:

Helpers are simply “handy” functions that help you with development.

Helpers are similar to library methods, but there is a subtle difference. With a library, you have to create an instance of the library’s class to use its methods. Helpers are declared as static methods of a class, so there is no need to instantiate the class. You can think of them as “global functions”.

As with libraries, the helper classes are automatically loaded by the framework when they are used, so there is no need to load them yourself.

OK, back on course. You might have noticed there is a reference to “assets/css/reset.css”, so lets go ahead and get that in place. In your root create a folder named “assets” and in that folder create one named “css”. For the actual “reset.css” file, I went to Serene Destiny and copied the code from the article titled “Create The Perfect CSS Reset” into a file and saved it as “reset.css” in the “assets/css/” folder. You might want to also set up some other folders within “/assets/”, maybe “images”, “js” and “files”. Basically the assets folder should be used to store and organize static files and such.

At this point, our application still doesn’t know what to do what we have done, so we need to modify our controller. So open “/application/classes/controller/ko3.php”.
We want to change what class we are extending, so change the line:
[php]class Controller_Ko3 extends Controller[/php]
to:
[php]lass Controller_Ko3 extends Controller_DefaultTemplate[/php]

We also need to change up our “index” action (action_index() method) to look like the following:
[php]
public function action_index()
{
$ko3_inner = array();
$ko3 = array();
$this->template->title = ‘Kohana 3.0′;

View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$this->template->content = View::factory(‘pages/ko3′, $ko3);
}
[/php]
Save it. Now you might noticed that we now have “$this->template->title = ‘Kohana 3.0′;”, this will assign a value to our templates “title” variable. The next thing you might notice is the absence of the last “render()” method. The “factory()” method actually will “auto render” it to our template’s “content” variable. Pretty simple, yes?

There is something we should probably do before loading up the page, so load up the “ko3.php” view file located in “application/views/pages/”. You might noticed that we have all the “shell” code in our view, so lets remove it. What you should only have in the view file is this:
[php]
<h1>This is my first view</h1>
<?php echo $content;?>
<?php echo $ko3_inner; ?>
<br/><?php echo $x;?>
[/php]

Now if you load it up, you should see that page has a title of “Kohana 3.0″ and the page should pretty much look the same as it did from the last tutorial. If you view the source thou, it would look much different. But you might be wondering about the other variables in the template and what to do with them. OK, let go back and edit our “index” action again. Make it look like:
[php]
public function action_index()
{
$ko3_inner = array();
$ko3 = array();
$this->template->title = ‘Kohana 3.0′;
$this->template->meta_keywords = ‘PHP, Kohana, KO3, Framework’;
$this->template->meta_description = ‘A test of of the KO3 framework’;
$this->template->styles = array(‘assets/css/red.css’ => ‘screen’);
$this->template->scripts = array(‘assets/js/jqtest.js’);

View::set_global(‘x’, ‘This is a global variable’);

$ko3_inner['content'] = ‘We have more data’;
$ko3['content'] = ‘We have data’;
$ko3['ko3_inner'] = View::factory(‘blocks/ko3_inner’, $ko3_inner)
->render();
$this->template->content = View::factory(‘pages/ko3′, $ko3);
}
[/php]
Pretty simple. You will notice I didn’t fill in the header or footer. I’m sure you know what to do there. Hint: Render a view to that variable =). Another thing you might notice is that I have put in “assets/css/red.css” and “assets/css/jqtest.js”. Lets make those two files starting with “/assets/css/red.css”:
[php]
h1
{
color: #FF0000;
}
[/php]

Next “/assets/js/jqtest.js”:
[php]
$(“document”).ready(function()
{
alert(‘Hello Kohana!’);
});
[/php]

Save them and refresh the site. You should see an alert pop up and the first line of text in red.

Today we have created a template file, extended a template controller and our controller use that template file. There is a lot of potential with what you could do with this already. So until next time when I will go over models, happy coding!
Sources used: Unofficial Kohana 3 Wiki, Kohana PHP 2.x Docs

Part 2 | Part 4

The first thing I have to is tell you is that Kohana PHP has been updated since the last tutorial. So I have gone ahead and took the last tutorial and updated the core and made sure it worked with Kohana 2.3.4. You can grab that here. Now onward to the glory!

The first thing we want to do is identify where and what the data is. Is it an XML feed, CSV, JSON, DB or something else? Well I’m going to make it easy. We are going to deal with our friend MySQL for this. The next step is to setup a MySQL DB connection.

Go into your system/config folder and copy the database.php file to your application/config folder. Edit the application/config/database.php to reflect your server settings. Mine looks like this:

$config['default'] = array
(
	'benchmark'     => TRUE,
	'persistent'    => FALSE,
	'connection'    => array
	(
		'type'     => 'mysql',
		'user'     => 'root',
		'pass'     => 'root',
		'host'     => 'localhost',
		'port'     => FALSE,
		'socket'   => FALSE,
		'database' => 'myfirstkohana'
	),
	'character_set' => 'utf8',
	'table_prefix'  => '',
	'object'        => TRUE,
	'cache'         => FALSE,
	'escape'        => TRUE
);

Now that we have a configuration a connection for our database, we should probably set up a database and a table. Here’s the SQL:

/*!40101 SET NAMES utf8 */;
/*!40101 SET SQL_MODE=''*/;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`myfirstkohana` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `myfirstkohana`;

/*Table structure for table `posts` */
DROP TABLE IF EXISTS `posts`;

CREATE TABLE `posts` (
  `id` mediumint(8) unsigned NOT NULL auto_increment,
  `title` varchar(255) default NULL,
  `post` text,
  PRIMARY KEY  (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC;

/*Data for the table `posts` */
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;

This is a pretty straight forward “Create a DB and one table” setup. You might notice that we have everything set for UTF8. This will match the DB configuration setting and also will allow us to deal with i18n (Internationalization) stuff later on.

Onward to creating an actual model. There are a couple things to keep in mind with naming conventions, well really one. From the docs “The model class name is capitalized, does have _Model appended to it and should be the singular form of the name.”. There are so other rules when you are dealing with ORM, but we won’t be dealing with ORM in this tutorial.

Create a file named post.php in the ‘application/models/’ folder and make it look like the following:

<?php
defined('SYSPATH') or die('No direct script access.');

class Post_Model extends Model
 {
    public function __construct()
    	{
		      parent::__construct();
    	}

 }

As you can tell the above really doesn’t do much, so let’s give it some functionality:

<?php
defined('SYSPATH') or die('No direct script access.');

class Post_Model extends Model
 {
    public function __construct()
    	{
		      parent::__construct();
    	}

    public function getPosts()
     {
        $sql = 'SELECT *
                FROM   `posts`
                LIMIT  0, 10';

        return $this->db->query($sql);
     }
 }

So we have a model method that pulls 10 posts from the table with a pretty simple query. We use “$this->query()” to run queries, which will return object and we return that to the calling entity. Check the query method docs here for more information.

Let’s update our ‘Hello’ controller to use this the model.

In your application/controllers/hello.php update your index() method to look like this:

    public function index()
     {
        // Load the models
        $post  = new Post_Model;
        $posts = $post->getPosts();
        $rpsts = "";

        // Loop thru the posts
        foreach($posts->result_array(FALSE) as $row)
         {
          // Simple output of
          $rpsts .= '
    <h1>'.$row['title'].'</h1>
    '.$row['post'].'<hr />';
         }

        // Put something useful in our variables.
        $this->template->header->pageTitle .= ' ::: I am on the top';
        $this->template->content->content   = $rpsts;
     }

When we run the hello controller, we won’t get much but ‘This is my second view’. We need to put stuff in the table. Use your favorite method of accessing your DB and insert some rows. Now when you run it you will see stuff!

If you notice there is a “$post->result_array()” inside a foreach loop. This allows us to loop though the results of the query easily from within the controller.

You might have notice something of bad practice. I pretty much created HTML inside the controller. As we all know, we shouldn’t do this. Let’s fix this!

Create a new view named main_posts.php and make it look like:

<?php foreach($posts as $post): ?>
<h1><?php echo $post['title'];?><h1>
<?php echo $post['post'];?><hr />
<?php endforeach; ?>

This view does a foreach on our query results and fills in our little view.

In the the index method of our controller we will need to change up the controller to use our new view.

   public function index()
     {
        // Load the models
        $post  = new Post_Model;
        $posts = $post->getPosts();

        // Put something useful in our variables.
        $this->template->header->pageTitle .= ' ::: I am on the top';

        // Posts view
        $this->template->content->content        = new View('main_posts');
        $this->template->content->content->posts = $posts->result_array(FALSE);
     }

As you can tell, it’s pretty simple and it’s clean! Here’s a quick sample on how to do an insert. We are going to add a method to the post model called addPost.

  public function addPost($title, $post)
    {
       $sql = sprintf('INSERT INTO `posts`
                       SET         `title` = %s,
                                   `post`  = %s',
                       $this->db->escape($title),
                       $this->db->escape($post));
      $this->db->query($sql);
    }

We need to add a method to handle adding of posts to our hello controller:

   public function addpost()
     {
        // Load the models
        $post  = new Post_Model;
        $post->addPost($_POST['title'], $_POST['post']);
        url::redirect('hello');
     }

And lets add a form to the end of the main_post.php in the views:

<form method="POST" action="<?php echo url::base();?>hello/addpost/">
  <table>
    <tr>
     <th>
       Title
     </th>
     <th>
       Post
     </th>
    </tr>
    <tr>
     <td>
      <input type="text" name="title" />
     </td>
     <td>
      <textarea cols="20" rows="5" name="post"></textarea>
      <input type="submit" name="submit" value="Submit"/>
     </td>
  </table>
</form>

Once again, pretty simple right? I could go on and give you how to edit entries, but I’m leaving that to you for your home work. Free free to post your results! Until next time when will go over libraries and helpers, keep on coding till your fingers bleed!

If you enjoyed this tutorial, please check out our tech deals and Computer related coupons.

Get the file for this tutorial here.

Let’s just dive straight into building our first picturesque view.
Create the file “myfirstkohana/application/views/hello.php” and put the following into it:

<html>
 <head>
  <title>Hello!</title>
 </head>
 <body>
  <h1>This is my first view</h1>
  <?php echo $content;?>
 </body>
</html>

Looking at the above, it’s pretty straight forward and simple HTML file with some simple PHP code thrown in.

Just because we put a view with the same name as our controller, it’s not going to be shown until we say so. Let’s go back to our wonderful controller “myfirstkohana/application/controllers/hello.php” and edit the index method to look like the following:

public function index()
 {
  $view          = new View('hello');
  $view->content = 'Hello World!';
  $view->render(TRUE);
 }

Let go through this line by line. The first line:

$view = new View('hello');

tells the framework to create a new “view” object and load the file :myfirstkohana/application/views/hello.php” into it. The next line:

$view->content = 'Hello World!';

creates a new property called “content” in the object that has the value “Hello World!”. The last line

$view->render(TRUE);

compiles the template with our assigned values and outputs it to the screen. What we should get when we load “http://youserver/myfirstkohana/hello” is “This is my first view” and below that should read “Hello World!”.

This might the simplist view you’ll see. Of course, I don’t think we’ll be wanting something so simple, so lets knock it up notch and create views with nested views.

Create the file “myfirstkohana/application/views/default_template.php” and put this in it:

<?php echo $header; ?>
<?php echo $content; ?>
<?php echo $footer; ?>

The above code is just a master template, or the template of templates if you will. Next lets create “myfirstkohana/application/views/default_header.php” and put the following into it:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" >
 <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <title><?php echo $pageTitle;?></title>
 </head>

and then “myfirstkohana/application/views/default_content.php”:

 <body>
  <h1>This is my second view</h1>
  <?php echo $content;?>

finally “myfirstkohana/application/views/default_footer.php”:

 </body>
</html>

Above we taken a basic HTML page and split it up “logically” into a header, footer and a content section. Let open our controller to build out our more complex view. Edit “myfirstkohana/application/controllers/hello.php” to make the index method look like this:

  public function index()
   {
    $view                    = new View('default_template');
    $view->header            = new View('default_header');
    $view->content           = new View('default_content');
    $view->footer            = new View('default_footer');
    $view->header->pageTitle = 'I am on the top';
    $view->content->content  = 'Hello World!';

    $view->render(TRUE);
   }

That wasn’t too hard was it? Basically we load our first view, which is the main template. Then we populate our properties with objects of our inner templates. It’s like working with multi-demential arrays in a sense.

With the ability to nest views/templates inside each other, things are a lot nicer to deal with. There is a problem thou. Each method (action) that needs to have a templated view, you need to do what we did to our index action to each one. Kohana does have an answer.

The Template_Controller allows to give a default view to actions, which if you have a lot of actions for a controller, it can really cut down on development and debugging time. Let go ahead and re-work out the hello controller (“myfirstkohana/application/controllers/hello.php”).

<?php
defined('SYSPATH') or die('No direct access allowed.');

class Hello_Controller extends Template_Controller
 {
    public $template    = 'default_template'; // Default template (view) to use
    public $auto_render = TRUE;               // Auto render template after controller is done

    public function __call($method, $arguments)
     {
        $this->name($method);
     }

    public function __construct()
     {
        parent::__construct(); // Has to be here!

        // Load the inner templates
        $this->template->header            = new View('default_header');
        $this->template->content           = new View('default_content');
        $this->template->footer            = new View('default_footer');
        $this->template->header->pageTitle = 'My first Kohana App';
     }

    public function index()
     {
        // Put something useful in our variables.
        $this->template->header->pageTitle .= ' ::: I am on the top';
        $this->template->content->content   = 'Hello World!';
     }

    public function america()
     {
        $this->template->content->content = 'Hello America!';
     }

    public function name($name)
     {
        $this->template->content->content = 'Hello ',$name,'!';
     }
 }

Here we have defaulted our main template, so now we didn’t have to declare it in each method. Also in our constructor method, we loaded the sub templates in and gave a default value to one of the template variable that used in the title tag. In our index method we added on to the title tag (think SEO) and put some generic content in place.

Stay tuned for the third part of our series and find out about models and working with external data!

Before we get into this tutorial, lets go over what will be required.

• *AMP (Apache MySQL PHP) install
• Knowledge of PHP
• Know what a frame work is (Framework Article)
• Know what MVC is (Wikipedia Entry)

Lets get started!
Download:
Load http://www.kohanaphp.com in your favorite browser and click the Download Kohana! button. You should be prompted to save a file. Go a head and save the file some where. At the time of this writing, the version was at 2.3.2.

Install:
Open the file we just downloaded in your favorite archive program and extract it to a temporary location. Open that temporary location and you should have a folder that is named “Kohana_v2.3.2″ or something like that. Open that folder. Open a new window and open the root directory of your *AMP install. Since I’m using WAMP Server – mine is C:wampwww. Next make a new folder in there named “myfirstkohana”. Copy the files from the “Kohana_v2.3.2″ directory to the “myfirstkohana”. Make sure your *AMP installation is up and running then point your browser to http://yourserver/myfirstkohana/ . You should have a screen stating that everything is “OK”.

If everything is “OK”, then remove or rename the “install.php” file in the “myfirstkohana” directory. Next we want to navigate into the application folder, then in the the config folder. Open the file named “config.php” in your favorite editor. There should be a line that reads: “$config['site_domain'] = ‘/kohana/’;” (Line 7 for me). We need to change the “/kohana/” part to reflect our install. So replace “/kohana/” with “/myfirstkohana/”. Also search for “$config['index_page'] = ‘index.php’;” and make the “index.php” part blank, so that line (Line 21 for me) should now read “$config['index_page'] = ”;”. Save that file.

Create a new document, cut and paste the following into it:

# Turn on URL rewriting
RewriteEngine On

# Put your installation directory here:
# If your URL is www.example.com/, use /
# If your URL is www.example.com/kohana/, use /kohana/
RewriteBase /myfirstkohana/

# Do not enable rewriting for files or directories that exist
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d

# For reuests that are not actual files or directories,
# Rewrite to index.php/URL
RewriteRule ^(.*)$ index.php/$1 [PT,L]

Save this file in the “myfirstkohana” directory as “.htaccess”.

These changes will help with creating clean URLs that help with SEO efforts.

Reload the browser page and you should get something like this:

If everything looks good, then we have successfully installed Kohana PHP. Now lets make it do stuff!

My first controller:
Open a new document and put the following into it:

<?php
defined('SYSPATH') or die('No direct access allowed.');

class Hello_Controller extends Controller
 {
  public function index()
   {
    echo 'Hello World!';
   }
 }

Save this in “myfirstkohana/application/controllers” as “hello.php”. Here’s a little explaination of what we did. The line “defined(‘SYSPATH’) or die(‘No direct access allowed.’);” basically prevents the file from being executed by itself. The next line “class Hello_Controller extends Controller” creates a class called “Hello_Controller” that extends the controller object. The rules to follow for creating controllers is as follows:

• Must reside in a controllers (sub-)directory
• Controller filename must be lowercase, e.g. articles.php
• Controller class must map to filename and capitalized, and must be appended with _Controller, e.g. Articles_Controller
• Must have the Controller class as (grand)parent
• Controller methods preceded by ‘_’ (e.g. _do_something() ) cannot be called by the URI mapping

stolen from: Kohana Docs

The first method, “index” is the default action. Pretty easy right? If you point your browser to “http://yourserver/myfirstkohana/hello/” you should see “Hello World!” on the screen now.

What if you wanted to exend the controller to do something else? Let add another method in the class that looks like:

public function america()
 {
  echo 'Hello America!';
 }

Now the hello.php should look like:

<?php
defined('SYSPATH') or die('No direct access allowed.');

class Hello_Controller extends Controller
 {
  public function index()
   {
    echo 'Hello World!';
   }

  public function america()
   {
    echo 'Hello America!';
   }
 }

Save this and open “http://yourserver/hello/america/”. Notice that is now show “Hello America!” on the screen. That wasn’t too hard, but lets make this a little more dynamic with arguements. Make a new method that will look like this:

public function name($name)
 {
  echo 'Hello ',$name,'!';
 }

Load up “http://yourserver/hello/name/monkey” and you should see “Hello monkey!” on your screen. Pretty straight forward. Let make it even more ‘friendly’. Add this to the top of the class:

public function __call($method, $arguments)
 {
  $this->name($method);
 }

If we load up “http://yourserver/myfirstkohana/hello/MrGuy/” we should get the same thing as if we loaded “http://yourserver/myfirstkohana/hello/name/MrGuy/” which would be “Hello MrGuy!”.

That’s it for this lesson. Next time we’ll be looking over Views.