So what does a route look like? Open up “bootstrap.php” located in “application/”, and scroll down to the comment that says:

/**
 * Set the routes. Each route must have a minimum of a name, a URI and a set of
 * defaults for the URI.
 */

The next thing you should see is something like this:

Route::set('default', '(<controller>(/<action>(/<id>)))')
     ->defaults(array('controller' => 'welcome',
                      'action'     => 'index'));

So we have a route setup initially for us, but what does this tell us. If we break it down we get:
1. Set a route with the name “default”
2. ‘(<controller>(/<action>(/<id>)))’ Tells the route the controller, action and id are optional. The parentheses are containers that denote if an option is opional or not and the less / greater than symbols tell the the router to assign the value to the variable of the value in-between the less / greater than symbols.
3. The default values for the controller is “welcome” and the default value for the action is “index”

So when we go to “http://yourserver/mykohana3/”, the router see that we have not set a controller nor an action in our URL. It will go through the route rules that we have set to find a match. In our case, we have a default route, which is named “default”. This default route will replace the missing controller with “welcome” and the action with “index” and the rest of the system will process it. Simple so far?

If we were to to “http://yourserver/mykohana3/hmvc/”, the router would notice that the controller has been set, but not the action. The router then assign the default action value of “index” for us.

You might have noticed the optional “id” in the route. This I would say is pretty commonly used and we could pass an ID on to our action. Example:
“http://yourserver/mykohana3/hmvc/index/111″. Of course this example will not do anything special since we didn’t set up any logic to handle it. Now what if we browsed to “http://yourserver/mykohana3/hmvc/index/111/222″? We get an error. This is because our router rule is strict and says we can only route for upwards of 3 segments (action/controller/id) and the /222 creates a fourth. To over come this we can though in a overflow handler rule into our default route.

Route::set('default', '(<controller>(/<action>(/<id>(/<overflow>))))', array('overflow' => '.*?'))
     ->defaults(array('controller' => 'welcome',
                      'action'     => 'index'));

If you save the ‘bootstrap.php’ file and reload, you should not see an error now.

You might notice that we’ve added in an extra array “array(’overflow’ => ‘.*?’)”. This basically sets up a REGEX rules for the “overflow” option which tell the router to capture everything, including slashes and pass it as our “overflow” argument. So if slashes are captured, the router will no longer try to split out the options on slashes.

Lets go back to this “id” option we see in our route. Well, anything we put in that area will be passed to our action. If our id’s are integers, we might want to error out if we pass a non integer. One way we can do this is with the route:

Route::set('default', '(<controller>(/<action>(/<id>(/<overflow>))))', array('id' => '[[:digit:]]{1,}', 'overflow' => '.*?'))
     ->defaults(array('controller' => 'welcome',
                      'action'     => 'index'));

So now if you were go to: “http://yourserver/mykohana3/hmvc/index/xxx”, you would get an error about not being able to find the route, which should translate to a 404 in a production environment. Of course you could check the id for an integer inside the action action and decide how to handle it.

Now lets create a route that isn’t our default route. Add the following to the “bootstrap.php” before the default route:

Route::set('monkeys', 'monkeys(/<action>(/<id>))')
     ->defaults(array('controller' => 'ko3',
                      'action'     => 'posts'));

Now if you were open up “http://yourserver/mykohana3/monkeys”, you would end up with the “posts” action of the “ko3″ controller. If you notice, the “monkeys” in the controller spot is not enclosed by parentheses, meaning that is not optional. So the router see “monkeys” in the controller spot and triggers this rule set.

Here’s an example you might want to use to serve up some static pages (Totally stole this from the Unofficial Kohana 3.0 Wiki):

Route::set('static', '<page>', array('page' => 'about|faq|locations'))
	   ->defaults(array('controller' => 'page',
                      'action'     => 'static'));

There is a bit more you could do with routes, but the above should cover the majority of things you would want to use route for.

Until next time when we will go over modules and helpers, happy coding.
Sources used: Unofficial Kohana 3 Wiki

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
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);
     }

 }

Save this as “hmvc.php” in “application/classes/controller”. The above should look pretty familiar. One line should stand out:

$ko3['posts'] = Request::factory('posts/getposts')->execute()->response;

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 echo $posts;?>

Save this as “hmvc.php” in “application/views/pages/”

Now for the “posts” controller:

<?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);
     }
 }

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 foreach($posts as $post):?>
 <h1><?php echo $post['title'];?></h1>
 <?php echo $post['post'];?>
 <hr />
<?php endforeach;?>

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
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);
     }
 }

Now edit the “hmvc” view to look like this:

<?php echo $content;?><br/>
<?php echo Request::factory('posts/getposts')->execute()->response;?>

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..

If you enjoyed this series of tutorials and want to throw me a bone, click here to get your 10% off Turbo Tax coupon!

Get the file for this tutorial here

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

Models are classes designed to work with information given by or asked for by the controller. For example, you have a guestbook, the controller will ask the model to retrieve the last ten entries, the model returns those entries to the controller who passes them on to a view. The controller might also send new entries to the model, update existing ones or even delete some.

Simply a model is a data handler and manipulator.

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.

Lets open up your bootstrap file (”application/bootstrap.php”) and find the like that reads “// ‘database’ => MODPATH.’database’, // Database access” and uncomment it. The whole block of code should look like the following:

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
	));

Now save this. We’ve basically told the bootstrap to load the database module, but we need to configure it. Copy the “database.php” from “modules/database/config/” to “application/config/”. Open up the “application/config/database.php” file and edit accordingly to your settings. Mine looks like this:

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

return array
(
	'default' => array
	(
		'type'       => 'mysql',
		'connection' => array(
			/**
			 * The following options are available for MySQL:
			 *
			 * string   hostname
			 * integer  port
			 * string   socket
			 * string   username
			 * string   password
			 * boolean  persistent
			 * string   database
			 */
			'hostname'   => 'localhost',
			'username'   => 'root',
			'password'   => FALSE,
			'persistent' => FALSE,
			'database'   => 'mykohana3',
		),
		'table_prefix' => '',
		'charset'      => 'utf8',
		'caching'      => FALSE,
		'profiling'    => TRUE,
	),
	'alternate' => array(
		'type'       => 'pdo',
		'connection' => array(
			/**
			 * The following options are available for PDO:
			 *
			 * string   dsn
			 * string   username
			 * string   password
			 * boolean  persistent
			 * string   identifier
			 */
			'dsn'        => 'mysql:host=localhost;dbname=mykohana3',
			'username'   => 'root',
			'password'   => FALSE,
			'persistent' => FALSE,
		),
		'table_prefix' => '',
		'charset'      => 'utf8',
		'caching'      => FALSE,
		'profiling'    => TRUE,
	),
);

Save this. You’ll notice I have a database setup just this tutorial series named “mykohana3″, you might want to do the same if you can. Now that we have saved, let get a table set up. Here’s the SQL:

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;

Go run that in your favorite MySQL client, I personally like SQLYog. You might have noticed the “charset” is set to “utf8″ in both the config and create table statement. This will allow us to deal with i18n (Internationalization) stuff later on.

So let create a new folder under “application/classes” named “model”. Now lets create a new file and make it look like this:

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

class Model_Post extends Kohana_Model
 {
    /**
     * Get the last 10 posts
     * @return ARRAY
     */
    public function getLastTenPosts()
     {
        $sql = 'SELECT *'."\n".
               'FROM   `posts`'."\n".
               'ORDER BY `id` DESC'."\n".
               'LIMIT  0, 10';

        return $this->_db->query(Database::SELECT, $sql, FALSE)
                         ->as_array();
     }
 }

Save this as “post.php” under “application/classes/model/”. Here’s an line by line explaination of the code.

        $sql = 'SELECT *'."\n".
               'FROM   `posts`'."\n".
               'ORDER BY `id` DESC'."\n".
               'LIMIT  0, 10';

This is a basic MySQL statement that selects up to ten rows from the DB which are sorted by the ‘id’ in a descending direction.

        return $this->_db->query(Database::SELECT, $sql, FALSE)
                         ->as_array();

This return array of the result from a query. The “query” method in this example take 3 parameters. 1st being what type of query, our being select, we use the constant “Database::SELECT”. There are 3 others, “Database::INSERT”, “Database::UPDATE” and “Database::DELETE”. The “as_array()” will return an array of the results, no having to do “while($row = mysql_fetch_array())”.

Now that we have a model method, I’m sure we would want to put it use. Open up “ko3.php” in “/application/classes/controller” and lets add this into the class:

    public function action_posts()
     {
        $posts                            = new Model_Post();
        $ko3                              = array();
        $this->template->title            = 'Kohana 3.0 Model Test';
        $this->template->meta_keywords    = 'PHP, Kohana, KO3, Framework, Model';
        $this->template->meta_description = 'A test of of the KO3 framework Model';
        $this->template->styles           = array();
        $this->template->scripts          = array();

        // Get the last 10 posts
        $ko3['posts']                     = $posts->getLastTenPosts();
        $this->template->content          = View::factory('pages/posts', $ko3);

     }

Basically we’ve called our model’s “getLastTenPosts()” method and assigned it to an array which we pass to our view. Talking about views, open up a new file and put the following into it:

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

Save to as “posts.php” under “application/views/pages/”. This view loops through the array we pass to it from the the controller and displays our posts from the DB. Wait, what? There’s no posts in our DB! Here’s some SQL you can run to populate your table:

insert  into `posts`(`id`,`title`,`post`) values (1,'Test Post','This is some sample text.');
insert  into `posts`(`id`,`title`,`post`) values (2,'Another post','Some more text');

Now if you point your browser to “http://yourserver/mykohana3/ko3/posts” you should see the two entries on the screen.

Now lets add something to put data into our DB. Open the the post model (”application/classes/model/post.php”) and add this to the class:

    public function addPost($title, $post)
     {
       $sql = sprintf('INSERT INTO `posts`'."\n".
                      'SET         `title` = %s,'."\n".
                      '            `post`  = %s',
                       $this->_db->escape($title),
                       $this->_db->escape($post));

       $this->_db->query(Database::INSERT, $sql, FALSE);
    }

The above is a pretty simple insert, but you may notice we are using “$this->_db>escape()”. This will wrap your strings in quotes and escape it content for you. Save it and now go back to the “posts.php” from “application/views/pages” and add the following to the bottom:

<form method="POST" action="">
  <table>
    <tr>
     <td>
       Title
     </td>
     <td>
       <input type="text" name="title" style="border: 1px solid #000000;"/>
     </td>
    </tr>
    <tr>
     <td>
      Post
     </td>
     <td>
      <textarea cols="20" rows="5" name="post"></textarea>
      <input type="submit" name="submit" value="Submit"/>
     </td>
  </table>
</form>

Save that and open the ko3 controller back up (”application/classes/controller/ko3.php”) and lets add a new method to it.

    private function _addPost($title, $post_content)
     {
       // Load model
       $post = new Model_Post();

       // Check required fields
       if(empty($title))
        {
           return(array('error' => 'Please enter a title.'));
        }
       elseif(empty($post_content))
        {
           return(array('error' => 'Please enter a post.'));
        }

       // Add to DB
       $post->addPost($title, $post_content);
       return TRUE;
     }

The above code is pretty much a middle man between the “action_posts” and the model that saves the post it self. Lets go back to the “action_posts” method and make it look like this:

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

        // Setup view stuff
        $ko3                              = array();
        $this->template->title            = 'Kohana 3.0 Model Test';
        $this->template->meta_keywords    = 'PHP, Kohana, KO3, Framework, Model';
        $this->template->meta_description = 'A test of of the KO3 framework Model';
        $this->template->styles           = array();
        $this->template->scripts          = array();
        $ko3['msg']                       = "";

        // Handle POST
        if($_POST)
         {
            $ret = $this->_addPost((isset($_POST['title']) ? $_POST['title'] : ""),
                                  (isset($_POST['post']) ? $_POST['post']  : ""));

            if(isset($ret['error']))
             {
                $ko3['msg'] = $ret['error'];
             }
            else
             {
                $ko3['msg'] = 'Saved.';
             }
         }

        // Get the last 10 posts
        $ko3['posts']                     = $posts->getLastTenPosts();

        // Display it.
        $this->template->content          = View::factory('pages/posts', $ko3);
     }

Save this and reload your browser. Now you should see a pretty ugly form at bottom. Enter some stuff in and click the “submit” button. You post should appear at the top along with the word “Saved”, this is if you entered stuff in both fields, if not you should see an error.

Before I end this tutorial, I want to go back to our little model for saving our posts. There are several ways to do queries in KO3, but want to quickly show you how you can use the query builder to do the same thing.

    public function addPost($title, $post)
     {
        DB::insert('posts', array('title','post'))
          ->values(array($title, $post))
          ->execute();
     }

That’s pretty simple! It does the same thing as the previous one, with less “hassle” There are advantages using the query builder method, like being able to convert between different DB types (MySQL to Oracle to what ever).

While I might not have gone over doing updates with your model, I thought I would give you a homework assignment to see if you can come up with you own update model for this. Until next time when we go over “H” in “HMVC”, happy coding.

Sources used: Unofficial Kohana 3 Wiki, Kohana PHP 2.x Docs, KO3 API Guide

Get the file for this tutorial here

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
  <head>
    <meta http-equiv="Content-type" content="text/html; charset=UTF-8" />
    <meta http-equiv="Content-Language" content="en-us" />
    <title><?php echo $title;?></title>
    <meta name="keywords" content="<?php echo $meta_keywords;?>" />
    <meta name="description" content="<?php echo $meta_description;?>" />
    <meta name="copyright" content="<?php echo $meta_copywrite;?>" />
    <?php foreach($styles as $file => $type) { echo HTML::style($file, array('media' => $type)), "\n"; }?>
    <?php foreach($scripts as $file) { echo HTML::script($file), "\n"; }?>
  </head>
  <body>
    <div id="container">
     <?php echo $header;?>
     <?php echo $content;?>
     <?php echo $footer;?>
    </div>
  </body>
</html>

Save the above as “default.php” in your “/application/views/templates/” folder.

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
 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();
      }
 }

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”, one to load CSS style sheets and one to 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:

class Controller_Ko3 extends Controller

to:

lass Controller_Ko3 extends Controller_DefaultTemplate

We also need to change up our “index” action (action_index() method) to look like the following:

    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);
     }

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:

  <h1>This is my first view</h1>
  <?php echo $content;?>
  <?php echo $ko3_inner; ?>
  <br/><?php echo $x;?>

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:

    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', NULL, TRUE);

        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);
     }

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”:

h1
 {
    color: #FF0000;
 }

Next “/assets/js/jqtest.js”:

$("document").ready(function()
                     {
                        alert('Hello Kohana!');
                     });

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

Get the file for this tutorial here

Kohana::init(array('base_url' => '/kohana/'));

to

Kohana::init(array('base_url'   => '/mykohana3/',
                   'index_file' => ''));

Now that we are updated to the latest and greatest, lets get right in to developing a view. Create a new folder within the “application” folder named “views” and inside the “views” folder, create another folder named “pages”. Now open up a new document in your editor and put the following in it:

<html>
 <head>
  <title>Hello!</title>
 </head>
 <body>
  <h1>This is my first view</h1>
 </body>
</html>

Now save that in your “application/views/pages” as “ko3.php”. As you can tell, it’s a pretty simple HTML page with some PHP mixed in. Lets open the “ko3″ controller (”application/classes/controller/ko3.php”). Replace the “action_index” class with the following:

    public function action_index()
     {
        $this->request->response = View::factory('pages/ko3');
     }

Save it, and load up “http://yourserver/myfirstkohana3/” in your browser. You should see “This is my first view”. The code above is pretty simple, we use the “Facotry” method of the view class to load the file “application/views/pages/ko3.php”, renders it and outputs it. Not very exciting, so let go back to the view (”application/views/pages/ko3.php”) and add:

  <?php echo $content;?>

After the “h1″ tags. Your view should look like this:

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

If we were to refresh the browser, we would seen an exception error about an undefined variable. So let’s go ahead and fix that, by relating data to the view variable in our controller. So, change up “Action_Index” controller to look like this:

    public function action_index()
     {
        $view                       = View::factory('pages/ko3');
        $view->content              = 'We have data!';
        $this->request->response = $view->render();
     }

Now if we refresh the browser, we should see “This is my first view” and under that “We have data!”. Lets explain the the code line by line.

$view = View::factory('pages/ko3');

This load our view file (”application/views/pages/ko3.php”) into the view controller.

$view->content = 'We have data!';

This assigns a variable for use by the view called “content” and we also assign data to that, in this case it’s “We have data!”

$this->request->response = $view->render();

This renders the view and outputs it.

Simple enough, but there is another way of doing the above. We could have also done the following:

    public function action_index()
     {
        $data['content']         = 'We have data!';
        $view                    = View::factory('pages/ko3', $data);
        $this->request->response = $view->render();
     }

Basically the above use an array with element keys as the template variable names to assign the data. We are not done yet! There’s 2 more ways we can do the above.

    public function action_index()
     {
        $view                    = View::factory('pages/ko3')
                                       ->set('content', 'We have data!');

        $this->request->response = $view->render();
     }

The above used the set method of the view class, which you can use method chaining to set all your template variables. And now for forth way:

    public function action_index()
     {
        $content                 = 'We have data!';
        $view                    = View::factory('pages/ko3')
                                       ->bind('content', $content);
        $this->request->response = $view->render();
     }

Now the above is using the bind method of the view class. Once again, this you can do method chaining here. This is a little bit different from the set method, since it will create a reference to a variable. So $content might equal ‘We have data!’ when we bound the variable to the template variable, but could change later on, since we are referencing the variable $content in our controller, instead of assigning data to the template variable.

If we were to do the following:

    public function action_index()
     {
        $content                 = 'We have data!';
        $view                    = View::factory('pages/ko3')
                                       ->bind('content', $content);
        $content                 = 'Our data changed';
        $this->request->response = $view->render();
     }

Instead of “We have data!” showing on our screen, we would have “Our data changed”.

Now lets do a view with in a view! Create a new folder in your “application/views/” named “blocks”. Lets create another view file named “ko3_inner.php” and put this in it:

  <h3>This is an inner view</h3>

Save that in your “application/views/blocks/” directory. Now lets edit the “ko3″ view (”application/views/pages/ko3.php”) and add the following:

  <?php echo View::factory('blocks/ko3_inner')->render(); ?>

You view should like this:

<html>
 <head>
  <title>Hello!</title>
 </head>
 <body>
  <h1>This is my first view</h1>
  <?php echo $content;?>
  <?php echo View::factory('blocks/ko3_inner')->render(); ?>
 </body>
</html>

So if we run it we should see what we had before, then “This is an inner view”. This would be useful for static content, but we won’t be able to use variables directly to that view. So let fix this. Lets go back to our controller (”application/classes/controllers/ko3.php”) and edit the “Action_Index” method to look like this:

    public function action_index()
     {
        $ko3_inner['content']    = 'We have more data';
        $ko3['content']          = 'We have data';
        $ko3['ko3_inner']        = View::factory('blocks/ko3_inner', $ko3_inner)
                                       ->render();
        $view                    = View::factory('pages/ko3', $ko3);
        $this->request->response = $view->render();
     }

This will render the view to a array that then is rendered by the main view. If you noticed I did the inner stuff first and went back to using array template variable setting style. Next we will need to edit the main view (”application/views/pages/ko3.php”). The line we put in before, we will change it to:

  <?php echo $ko3_inner; ?>

The view should look like this:

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

And the last change we need to make is to the inner view (”application/views/blocks/ko3_inner.php”). Make it look like this:

  <h3>This is an inner view</h3>
  <?php echo $content;?>

If you refresh the browser after saving, you should now see the following:

This is my first view

We have data

This is an inner view

We have more data

Pretty cool, now you can make your views more modular and reusable. Now lets get into making variables globally available to your views. Back to your controller (”applications/classes/controllers/ko3.php”) and edit the “Action_Index” method so the following is at the top of the method:

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

So now the method should look like this:

    public function action_index()
     {
        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();
        $view                    = View::factory('pages/ko3', $ko3);
        $this->request->response = $view->render();
     }

Now if you were to edit your views and add in:

  <br/><?php echo $x;?>

You should now see “This is a global variable” two times on the page. As you can see this could be very handy. Basically, we are using the static method of “set” from the view class, so it ends up being available to all view object instances. You can also use the static method of “bind” to reference variables. This could be handy for dry things “DRY” and could be used in other place, like a contruct.

Untill next time, when I go over “templates” (advanced views and controller stuff), happy coding!
Sources used: Unofficial Kohana 3 Wiki

Get the file for this tutorial here

Lets check to make sure we have everything needed before going on.

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

Lets go!
Download:
Download the latest Kohana 3.0 PHP (At the time of this writing: 3.0.1.2) and unpack it somewhere.

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” 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:\wamp\www\”. Next make a new folder in there named “mykohana3″. Copy the files from the “kohana” directory to the “mykohana3″. Make sure your *AMP installation is up and running then point your browser to “http://yourserver/mykohana3/”. You should have a screen stating that everything is “OK”.

If everything is “OK”, then remove or rename the “install.php” file in the “mykohana3″ directory. Next open up the “example.htaccess” file and change the following line:

RewriteBase /kohana/

to:

RewriteBase /mykohana3/


Save it as “.htaccess”.

Now open the “bootstrap.php” file located in the “application” folder and cange the following line:

Kohana::init(array('base_url' => '/kohana/'));

to:

Kohana::init(array('base_url'  => '/mykohana3/',
                   'index_file'=> ''));

Save this file then refresh your browser. You should get something that reads “hello, world!” on your screen.

You might already notice that configuration for KO3 is a little bit more involved, editing two files instead of one, which isn’t a big deal at all.

Now to make our first controller! Open a new document and put the following into it:

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

class Controller_Ko3 extends Controller
 {
    public function action_index()
     {
        $this->request->response = 'My First Kohana 3.0 Controller';
     }
 } // End

Save this as “ko3.php” in the “application/classes/controller” folder. You might have noticed another difference between Kohana 2.3.x and 3.0 is the directory structure, not really all that much of difference. Now that you have it saved, point your browser to “http://yourhost/mykohana3/ko3″. You should she “My First Kohana 3.0 Controller” on your screen now.

Now for an explanation of the code.

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

This line basically tells PHP not load this file directly. It can only be included from the framework.

class Controller_Ko3 extends Controller

This creates an controller which is a class that is extended from the Controller class that is part of the framework.

public function action_index()

This created a public method called “action_index”. The “action_index” method is a default action that is loaded by the framework. It’s like your index.php file so to say.

$this->request->response = 'My First Kohana 3.0 Controller';

This will output “My First Kohana 3.0 Controller” to the screen. This basically works like “echo”.

Pretty easy eh? Now if you wanted to add addition action to your controller you would add another public method that has a prefix of “action_” and the you would access via going to “http://yourserver/mykohana3/controller/action”

Let go ahead and add a new method to our “ko3″ controller by adding the following after the “action_index” method:

    public function action_another()
     {
        $this->request->response = 'Another action';
     }

Save the file and loaded up “http://yourserver/mykohana3/ko3/another” in your browser. If all goes well you should see “Another action” in your browser.

That was fun an all, but lets make it a little bit more dynamic!

Copy this code and put it after the “action_another” method:

    public function action_dynamic($say)
     {
        $this->request->response = 'You said: '.$say;
     }

Save this and load “http://yourserver/mykohana3/ko3/dynamic/Monkey” and you should see “You said: Monkey”

Untill next time, when I will go over the first part of views, happy coding!
Sources used: Unofficial Kohana 3 Wiki

It’s easy. First, go to DealTaker.com and then click the “Stores/Coupons” button in the top navigation bar.

Then select the store that you want to get alerts from. For this example, we’ll use Kohl’s.

Once there, you’ll see a list of coupons for the store. The last coupon allows you to sign up to be alerted when new coupons are posted. If you are already a member of DealTaker (and logged in!) all you’ll have to do is click the “Sign me up!” button and they will be delivered to the email address that you originally signed up to DealTaker with.

If you are not a member of DealTaker, just enter your email address into the box and new coupons will be delivered straight to your inbox!

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!

Get the file for this tutorial here.

API or Application Programming Interface is a ubiquitous term used in the tech world everyday.  With the popularity of online social networking sites and the need to add features and content easily into your own site, executives are starting to understand the benefits of using and or providing a public API to third party organizations.  The term has become so popular that most executives now use API in their repertoire of business terms.  They should, considering users want these features and most organizations such as Salesforce.com, YouTube, eBay, Twitter, FaceBook, MySpace and LinkedIn provide an API for the public.  So, what exactly is an API?

APIs allow you to integrate third party content or features into your web site or web application using a set of common programming tools.  Basically, an API puts you in control of the data and how you want to present it.  It provides flexible, two-way communication and allows you to expand or enhance existing functionality.  APIs give you more control and greater options for integration than widgets or RSS feeds, but obviously require you to write more code in order to integrate it into your own applications.

One popular application called TweetDeck uses the Twitter API to enhance and expand Twitter’s features.  TweetDeck is an Adobe Air application that runs on your Mac or PC desktop.  TweetDeck provides many benefits.  For one, it provides a continuous stream of tweets without having to constantly hit the refresh button.  It helps you organize tweets by columns giving you a so-called tweet dashboard.  It also allows you to easily isolate users you follow by clicking on their icon and viewing their profile.  You can then view stats about that user.

Although the current features and benefits of TweetDeck are abundant, it only exists because of Twitter’s API and its ability to provide functionality Twitter has yet to offer.  This is of course good for Twitter, considering that 80% of their tweets or traffic comes through their API usage.

I’ve used the eBay and the YouTube API with great success in the past and look forward to providing one for DealTaker in the very near future.

The bottom line is this, APIs help both parties by allowing the reuse of features and content extending the existing business model while using less upfront investment.