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 “myfirstkohana3″. Copy the files from the “kohana” directory to the “myfirstkohana3″. Make sure your *AMP installation is up and running then point your browser to “http://yourserver/myfirstkohana3/”. You should have a screen stating that everything is “OK”.

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

RewriteBase /kohana/

to:

RewriteBase /myfirstkohana3/


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

1.) Get the location’s latitude and longitude (IE. 33.017262, -96.98494).

2.) Make sure you have 3 numbers before decimal point.  So we would left pad with a ‘0′ and we would end up  with 033 and 096.

3.) Add the + and – to our result, so +033 and -096 would be our result

4.) Take the first 3 numbers after the decimal point and add it to the end of result, so we end up with +033017-096984.

4.)Take the first 3 to 6 numbers after the decimal point and add it to the end of result, so we end up with +033017-096984 if we used 3 or if we used 6 we would end up with +033017255-096984955

5.) Post a tweet with the hash tag of #geotwit, the result and the rest of what your tweet.

Here’s an example of a full tweet: #geotwit +033017-096984 http://twitpic.com/6eh1a Spotted this car Friday in Lewisville, TX.

Personally, I got a Palm tengsen  and a ipod 30G classic from Ameritrade for free, another ipod mini from Citibank. Anyways, I need a brokerage account and checking account.  I will be very happy to take those gift .

There are free chocholate, free icecream, free donuts .. etc , it is fun to find out .

I love this.

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!
Click here to download the files.

Now it seems like there are so many instant messaging services surrounding us that it becomes almost impossible to utilize multiple services without running a multi-im application like Pidgin or Trillian. I have tried both and there were small things about each I didn’t like. Then I discovered Meebo.

Meebo is 100% web based so I can open it up in any browser that is available. There’s no need to install a pesky application that slows down how quickly your computer boots. While there is no full application to download they have now introduced the Meebo Notifier. This very application doesn’t take up hardly any memory and allows you to remain signed in to Meebo without having to leave the browser open and when you recieve an IM you can go ahead and open up the browser to reply.

While this may be my client, if you can even call it a client, of choice it may not be for everyone. What IM client do you use? Do you connect to multiple services or do you stick with one of the big providers?

Let me know in the comments.