Inside DealTaker » howto

Kohana PHP 3.0 (KO3) Tutorial Part 3

ellisgl — Wed, 30 Dec 2009 15:08:30 +0000

Welcome to the third part in this series on how to develop with Kohana PHP V3 (KO3). If you havenâ€™t read the first and/or second parts yet, I would click here and read them before going on. In this tutorial we will be going over how to create a template.

In the last tutorial, we went over views and in this one we are going to extend the Controller classes which will allow us to create a template. A template, you might ask, is nothing more than a view that is more or less your base (X)HTML code. This will allow to keep things “DRY” in the view world. Before we get to putting code into a file, lets create a new directory under “/application/views/” named “templates”. Now open up your favorite IDE and make a new file and put the following into it:



  
    
    
    <?php echo $title;?>
    
    
    
     $type) { echo HTML::style($file, array('media' => $type)), "\n"; }?>

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:

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:

  This is my first view

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 PHP Tuturial – Part III

ellisgl — Fri, 19 Jun 2009 13:26:09 +0000

It’s been a couple weeks now, so lets get back on track with this series of tutorials. This tutorial will get into models and how to play with data.

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:


As you can tell the above really doesn’t do much, so let’s give it some functionality:
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 .= '
    '.$row['title'].'
    '.$row['post'].'';
         }

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




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:

  
    
     
       Title
     
     
       Post
     
    
    
     
      
     
     
      
      
     
  

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.