If you don’t know basic OOP (Object-Oriented Programming) principles, now would be a good time to go do some reading on them. We’re going to make heavy use of inheritance, as well as overriding. Just keep in mind that PHP is not a strongly typed language.

Let’s get started. For authentication, we’re going to build the form the old fashioned way so that you can get a good example for ‘how it was done’ versus ‘how smoothly it can be done’ with Zend Framework. Let’s create the login form. In /app/views/scripts/index/, create login.phtml — do note the .phtml extension on it. To keep us moving right along, here’s the code for it.

<? if(!empty($this->message)): ?>
    <?=$this->message?>
<? endif; ?>
<form name="login" action="index/login" method="post">
Login: <input type="text" name="login" /><br />
Password: <input type="password" name="password" /><br />
<input type="submit" name="submit" value="submit" />
</form>

Now we’ll head back to your controller. If you look at the work you did in the form, you’ll see that the index controller’s login action will be responsible for both displaying and processing this form.

First, to get the form to display, you’ll need to add just a blank login action to your IndexController. For security purposes, I’ve cleared out the ‘list of users’ that was in yesterday’s indexAction() (we don’t really want to give an attacker a list of users to try, do we?) and replaced it with a call to $this->_forward() to direct users that come to the index page to the login. Later on, when we’re checking for authenticated users, we’ll replace this with a conditional.

class IndexController extends Zend_Controller_Action {
  function indexAction() {
     $this->forward('login');
  }
  function loginAction() {
 
  }
}

Now, if you visit /index/login in your browser, you should get the login form. Let’s add some logic to make it do something. We’re going to use Zend_Auth’s database methods for this.

function loginAction() {
  $params = $this->_getAllParams();
 
  if(!empty($params['submit']) && $params['submit'] == 'submit') {
        $auth = Zend_Auth::getInstance();
 
        $adapt = new Zend_Auth_Adapter_DbTable(Zend_Registry::get('db'));
        $adapt->setTableName('users');
        $adapt->setIdentityColumn('id');
        $adapt->setCredentialColumn('password');
        $adapt->setCredential(sha1($param['password']));
        $adapt->setIdentity(htmlspecialchars($param['login']));
 
        $result = $auth->authenticate($adapt);
        $this->initView();
        if($result->isValid()) {
	          $storage = new Zend_Auth_Storage_Session();
                  $storage->write($adapt->getResultRowObject(array('id')));
	          $auth->setStorage($storage);
 	          $this->view->message = 'Login Successful!';
        } else {
	          $this->view->message = 'Invalid login. Please try again.';
        }
    } 
}

There’s a few very important things we want to note here.

1. Zend_Auth is written in a Singleton Pattern.
2. We make use of the database handle that we stored in the registry in the front controller.
3. We’re encoding the password in the code before we send it to the database. In the database, the password is already encoded in sha1 format.
4. We’re setting the identity for later retrieval.
5. We pass a message back to the user via the view script.

You know what? I know I promised that we’d get into some fancier stuff using Zend_Form and Zend_Mail, but I think that’s enough new concepts for one day. We’ll extend the tutorial into next week and spend tomorrow working with Zend_Form and Zend_Mail.

Happy coding!

The general procedure when setting up Zend_Db is to create a bunch of objects that extend Zend_Db_Table_Abstract. When defining an object, you can define what table it connects to, what the primary key is, and any foreign keys that relate to it. Upon instantiating the object in your code, you can use it to build queries against it’s related table, which returns a collection of row sets for direct use in your applications. Today’s tutorial assumes that you’re very comfortable with looping and other control structures in PHP.

Configuration File

You should have a MySQL database accessible to your webserver. Knowing how to use MySQL is outside of the scope of this tutorial but the basic gist of what you need to do is — create a database, create a user and password for that database, and insert the SQL to create the tables.

ZFApp (Day 3) SQL

When you’ve collected that information, let’s write a configuration file. This file will go in app/config/db.ini.

[dev]
database.params.host=localhost
database.adapter=pdo_mysql
database.params.username=foobaruser
database.params.password=foobar
database.params.dbname=zfapp

Save that file, and then let’s go tell the front controller how to access the zfapp database.

Front Controller

The first thing we need to do is go back and visit our friend the Front Controller. It needs some setup if we’re to use Zend_Db. Let’s open up index.php and add a few lines. We’ll be using Zend_Config_Ini to load up the configuration file. Note the ‘dev’ – that tells us to load up the area after the [dev] in the above .ini file. I use this to tell the difference between my dev and live configuration, since that keyword is set by a SetEnv statement in the Apache configuration file.

$dbconf = new Zend_Config_Ini(BASEDIR.'/app/config/db.ini','dev');

Now that we’ve got a handle to the configuration file, we’ll use Zend_Db’s factory method to create a DB Connection.

$db = Zend_Db::factory($dbconf->database);

That’s it. That’s all we need to do. $db is now a database handle. Two lines of code! Zing! The only other things that we’ll find helpful here is setting this DB handle as the default handle for tables. I also register the DB handle with the registry so that I have an easy way to get it back later if I want to do something deep and complicated with the db.

Zend_Db_Table_Abstract::setDefaultAdapter($db);
Zend_Registry::set('db',$db);

Using the DB

Tomorrow, we’ll really get into using the database for something, but for today let’s just finish the prep work and make a basic use of our new toy.

First, we need a model to access. Make sure you’ve got the models on your include path in your front controller:

set_include_path(ini_get('include_path').PATH_SEPARATOR.BASEDIR.'app/models');

Now, we’ll create our first model. A model is a basic file that just tells the database driver where a table is, and provides some defaults. In /app/models/users.php, we’ll want to extend a Zend_Db_Table_Abstract as follows:

class Users extends Zend_Db_Table_Abstract {
   protected $_name = 'users';
   protected $_primary = 'id
}

… and that’s it. Since you included the models directory in your include path, all you need to do is instantiate a Users module anywhere in your application, and you can access the users table via the db handle you created in your front controller and assigned as default. Pretty neat, huh?

Ok, let’s select some rows out.

Head over to the /app/controllers/IndexController.php that you made yesterday. In the indexAction() function, place this code:

public function indexAction() {
  $this->initView(); // Initialize the view object for this module
  $user = new Users(); // Users Table Object. 
  $rowset = $user->select(); // Created a default 'select all' query
  $list_of_users = array();
  foreach($rowset as $row) {
    $list_of_users[] = $row->id;
  }
  $this->view->userlist = join($list_of_users,', '); // Concatenate the list of users and make it available to the view. 
}

And we’ll head over to the view script you created yesterday … /app/views/scripts/index/index.phtml … and add in a line to echo that userlist. Don’t forget to add the carat-questionmarks here, of course.

 echo $this->userlist;

… and as Emeril says, Bang! You’re reading from your database.

Tomorrow we’ll do some ‘heavy’ lifting — we’ll set up Zend_Auth to authenticate users from the database, a Zend_Form to allow users to sign up, and a Zend_Mail to send users their passwords when they’ve forgotten it.

Today we’ll be covering the front controller and some basic modules and actions. You still won’t need a database at this point, but you will need to have Apache configured correctly. You’ll also want to have the Zend Framework Reference Guide within easy reach.

Before we get started, make sure that your Apache configuration (we’re assuming you’re doing this on a stanadlone server, your local machine using MAMP or WAMP, or a virtual host, and not on shared hosting) is set up so that your document root is your /html folder, and AllowOverrides is set to All for the directory. If you don’t know how to do this, refer to your Web Server’s documentation or ask someone.

The first thing we’re going to do is set up your front controller. Every time someone accesses your application, they access the front controller, and the front controller is responsible for loading up everything else that the user needs to see or the application needs to process. The front controller is one of the few PHP files that lives in your /html directory. Let’s create it, and call it index.php.

The first few things that your front controller needs to know are where the front controller itself is, what the path to the Zend libraries are, and where your controllers are so that it can dispatch the request to them.

Let’s tackle the location first. I generally don’t depend on the file to know where its by using the

dirname(__FILE__);

trick — I tend more towards setting the specific directory structure based on a location variable set in my apache configuration using SetEnv. So the first few lines of my front controller looks like:

if($_SERVER['ENV'] == 'dev') {
    define('BASE','/Users/kkatzke/work/firstapp');
alit} else {
    define('BASE','/var/www/sites/firstapp.katzke.net');
}

From there, you use the base directory constant to add the appropriate paths to your PHP include path. In your case, you’re working in your home directory, so your path would look like ‘/home/myusername/myprojectname/lib/Zend’. BASE would equal ‘/home/myusername/myprojectname/’, so you would add to your index.php:

set_include_path(BASE.'lib/');

Now it’s time to use your first big of Zend Framework magic. Zend Framework uses the Standard PHP Library (SPL) Autoload functionality. All of the Framework libraries are named the same as their path from the base — so the object Zend_Form_Element_Text is in Zend/Form/Element/Text.php. Let’s go ahead and enable Zend Loader, and then I’ll explain what it does.

require_once('Zend/Loader.php');
Zend_Loader::registerAutoload();

Now that Zend Loader has registered an autoload handler, any time you want to use an object within the Zend Framework, you don’t have to be sure you’ve called ‘require_once()’ yet — it’ll “autoload” itself in based on the name. Let’s go ahead and use that to set up the MVC Layout… but we’ll leave it commented out for now. You’ll find out why later.

#Zend_Layout::startMvc();

Note, again, that we didn’t have to include any extra files to access the Zend_Layout option! Pretty cool, huh? Let’s hurry up and get a site working. The last part of the Front Controller is the Dispatch processor. Dispatching is like saying ‘ok, our environment is set up, let’s go’ within Zend — it takes the request, does some magic, and spits out a response. It should be the last thing that happens in your front controller.

Zend_Controller_Front::run(BASE.'app/controllers');

There’s a lot more that could be said about the front controller and dispatch loop/process, but you can go peruse it in the manual — we’re focused mainly on getting a new app up as fast as we can.

Now, note when we called that front controller, we addressed the BASE.’app/controllers’ directory — this is where we’re going to work next. First, make sure your Front Controller (index.php) file looks something like this, and then let’s move on.

if($_SERVER['ENV'] == 'dev') {
    define('BASE','/users/home/myusername/myprojectname/');
alit} else {
    define('BASE','/home/myusername/myprojectname/);
}
 
set_include_path(BASE.'lib/');
 
require_once('Zend/Loader.php');
Zend_Loader::registerAutoload();
 
#Zend_Layout::startMvc();
 
Zend_Controller_Front::run(BASE.'app/controllers');

Modules

You need two basic modules and a few templates to have your first basic, working application. Let’s add an index module and a template.

In BASE./app/controllers, let’s create a file named IndexController.php. Capitals are important here. It should look something like this:

class IndexController extends Zend_Controller_Action {
 
  public function indexAction() {
 
  }
 
}

Again, we’re using the magic of the autoloader. While we’re in the directory, let’s also create an error controller that will tell us what we did wrong. The file will be called ErrorController.php

class ErrorController extends Zend_Controller_Action {
 
  public function errorAction() {
    $errors = $this->_getParam('error_handler');
    $exception = $errors->exception;
 
    echo $exception->getMessage();
    echo "<br /><pre>";
    echo $exception->getTraceAsString();
  }
}

Now, we need to create some view scripts. You’ll need to create some folders. From BASE, you’ll want to create /app/views/scripts/index and /app/views/scripts/error — and then create index.phtml and error.phtml in the corresponding directories. Note: The name of the directory in scripts matches the CONTROLLER name, and the name of the .phtml file matches the ACTION name. So if we were to create an action in index called ‘about’, you would then create an ‘about.phtml’ file in the /app/views/scripts/index directory.

Open up the index.phtml you just created and type ‘hello world’. Then open up the error.phtml file that you created and type ‘Oops, error!’.

Last but not least, we need an .htaccess file in BASE/html/.htaccess to tell Apache where to route things. Here’s the one I use:

Options +FollowSymLinks
IndexIgnore */*
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . index.php

Now, the moment of truth — point your browser at your document root, and you should see “hello world”! If you got a blank screen, check your PHP error log. If you got a zend framework error printed to your screen, you know your error handler works..! Just figure out what went wrong and fix it.

Tomorrow we’re going to work with the database by adding some database boostrap logic to the front controller, and we’ll retrieve and display some rows with Zend_Db_Table.

First, some requirements. You should be comfortable on the command line or with your Subversion client. I’m writing from the point of view of someone who codes on a Linux or Mac machine using vim. You will need to have PHP 5 installed on your server — this will not work unless you do. Second, I would recommend getting a VPS from a host like Futurehosting — for $20/mo, you get root access to your own machine, you can host as many sites or servers and have as many domain names as you want, and you get 350gb a month in transfer — I don’t think I’ve used 1gb of transfer ever, and I do a ton of work with the server. I also Also, we’re going to assume you have access to a Subversion server. That’s just good practice, folks. Subversion hosts are very cheap — I usually use CVSDude.

Today we’re going to cover the folder structure, getting things into subversion, and locating the different files. Tuesday, we’ll cover the bootstrap and getting your index module and error module to show up. Wednesday, we’ll cover Zend_Db_Table_Abstract, Thursday we’ll cover Zend_Form, and Friday we’ll put it all together to get a user registration and login working.

Disclaimer: I’m by no means a whiz kid with Zend Framework. ZF is unique among frameworks in that it gives you a toolset but does not enforce any conventions. The conventions I’m giving here are *my* conventions and may have nothing to do with the way you want to code.

Let’s dive right in.

Set up a directory to import into SVN. Your directory structure at import will look something like:

/home/myusername/projectfolder
                    /branches
                    /tags
                    /trunk
                           /app
                           /html
                           /lib

Now, let’s import that into a Subversion repository that you’ve already created somewhere else. Type:

[kkatzke@server]$ cd ~/projectfolder
[kkatzke@server]$ svn import ./ \
> http://www.cvsdude.org/svn/myusername/myproject \
> -m "Initial Import"

(Those backslashes are included to indicate that the next line is also part of the command. I’m using them here because otherwise the text rides off into the sidebar.

Now delete the folders in your home directory that you created –
rm -rf /home/myusername/projectfolder.

Let’s head over to where you want to actually have your application live, or at least where you want to do your development work. This will usually be /var/www– or wherever your webroot is. (You could actually place any of these files anywhere on the system, or on another system — but we’re trying to keep this simple here.) You’ll run this checkout command: svn co http://cvsdude.org/svn/myusername/myproject/trunk . — and note that last period, it’s important. The results will look something like this:

A /app
A /html
A /lib

Now you’ve got a working copy of your three directories that will make up the application. The first thing we need to do here is to get a copy of the Zend Framework to work with. SVN makes it easy to do this. From the directory you checked out to (you should type ‘ls’ and see “app html lib”) Just run svn propedit lib, which should pop you into a blank text editor file. Type
Zend http://framework.zend.com/svn/framework/branch/release-1.5/library/Zend
and save and close the file. When you’re back at the command prompt, just type
svn update
and it will automatically pull in the Zend Framework into APP-ROOT/lib/Zend/ for you … although note that it specifically pulls in the lib/Zend folder, it does not pull in the incubator. That’s well outside of the scope of this beginner tutorial.

Last of all for today, you’ll need to add the rest of the directory structure for the application so that we can start with some code tomorrow. Here’s the way things should end up looking:

webroot/
        /app
              /config
              /controllers
              /forms
              /models
              /views
                      /scripts
                      /helpers
        /html
              /css
              /img
              /js
        /lib
              /Zend

When you’re done with all that, run svn add on all of the directories (use svn status to catch any you missed) and then run svn commit to save your changes to the repository. Congratulations! Tomorrow we’ll actually do something with all that work you did today.