Seeing this, I tried implementing Zend’s Acl component into a default CI installation. Now, this is a very dirty work, I’ve just thrown stuffs here and there. But you’ll at least get an idea on how to use it. The major code goes into a CI library, which initializes the Acl object, roles, resources and rules for them.

Lets begin with the directory structure,

I created a new directory called Custom inside the application directory. And here’s how the folder structure looks inside of Custom,

Custom
-Zend
–Acl
–Acl.php
–Exception.php (You’ll need this file too)

If you download the Zend framework, those are the only files you’ll need. Remember, you’ll need to have a folder called Zend, since this is how Zend refers to them in all of its includes. I apppend the Custom directory into PHP’s include path, since putting the Zend directory directly into the include path throws errors. That’s the reason I have the Custom folder in the first place. You’ll see all the include path stuff ahead, so don’t start worrying about them now.

Lets go to the library part. Now, lemme tell you beforehand that I’ve made no effort to organize code. My objective was to make the Acl component work in a convenient way. So pardon the bad coding practice if any .

In the libraries folder within your application folder, created a new library file named Zacl.php (I know I’m not creative). This is it’s contents.

<?php
if (!defined('BASEPATH')) exit('No direct script access allowed');

class Zacl
{
    function __construct()
    {
        session_start();
        //Append Zend's folder in PHP's include path
        set_include_path(get_include_path() . PATH_SEPARATOR . BASEPATH . "application/Custom");

        //Load the Acl class
        require_once 'Zend/Acl.php';
        require_once 'Zend/Acl/Role.php';
        require_once 'Zend/Acl/Resource.php';

        //Create a new Acl object
        $this->acl = new Zend_Acl();

        /**
         * Add roles and resources. Check Zend's documentation for excellent
         * information on all these.
         * http://framework.zend.com/manual/en/zend.acl.html
         */
        $this->acl->addRole(new Zend_Acl_Role('guest'));
        $this->acl->addRole(new Zend_Acl_Role('users'),array('guest'));

        /**
         * Add some resources
         */
        $this->acl->add(new Zend_Acl_Resource('users_login'));
        $this->acl->add(new Zend_Acl_Resource('users_profile'));

        /**
         * Set rules for Acl
         */
        $this->acl->deny(); //Deny everything, so as to follow a whitelist approach.
        $this->acl->allow('guest','users_login');
        $this->acl->allow('users','users_profile');
    }

    function check_acl($resource)
    {
        if (!$this->acl->has($resource))
        {
            return 1;
        }

        if (isset($_SESSION['user_id']))
        {
            $role = 'users';
        }
        else
        {
            $role = 'guest';
        }

        return $this->acl->isAllowed($role,$resource);
    }

}

Now, I have a constructor, which sets up everything. First of all, don’t be scared by the session_start() stuff, I just included it for a simple login/logout mechanism you’ll see later, to check if everythings fine. Even though I’ve commented the source code, I’ll just give a gist of what I’m doing.

1. Loading all required classes for Zend Acl.
2. Adding Roles.
3. Adding Resources (I elaborate on this below)
4. Set access rules

If you see, the ‘users’ role is actually a child of ‘guest’ role, thus inheriting properties from it. You’ll need to check Zend’s manual to know about the syntax and stuff, since its explained quite well.

Now, both role and resource names are arbitrary. You can set them as whatever you want. I’ve used a small convention for resource part. I’ve named resources as “controller_action”. This is because, I can easily get controller and action name from the URI, and can easily query Acl from any controller.

In the next part, I simply set the access rules (quite self explanatory). I have a function called check_acl(), which takes a parameter named $resource. This is passed by the controller to the function, using the convention I told you about above. Zend throws an exception if a given resource couldn’t be found. Thus, if a resource is not in the Acl, I return 1, saying that its allowed to be accessed.

If the user has a session variable user_id, it means he’s logged in, thus I set his role to ‘users’. Else, his role is ‘guest’.

Now, to the controller path. I created a controller called Users, having this,

<?php

class Users extends Controller
{
    function __construct()
    {
        parent::__construct();
        $this->load->library('zacl');

        $resource = $this->uri->segment(1) . '_' . $this->uri->segment(2);
        if (!$this->zacl->check_acl($resource))
        {
            $this->load->helper('url');
            redirect('/users/login');
        }
    }

    function login()
    {
        echo "The login page";
    }

    function profile()
    {
        echo "The restricted profile page<br />";
        echo "Your user id: " . $_SESSION['user_id'];
    }

    function setsess()
    {
        $_SESSION['user_id'] = 1;
    }

    function remsess()
    {
        unset($_SESSION['user_id']);
    }
}

In the constructor, I load the Acl library, and pass the controller_action to check_acl() function. If the output is 1, user is allowed, else he isn’t. If he isn’t, I redirect him to login page.

The login() and profile() functions are simply dummy functions, to check if Acl is working properly. If you look at the library, you’ll find that guest cannot access profile, while only a user can. The setsess() and remsess() functions are to set and remove user session to simulate logging in and logging out.

Well, I guess that’s it. I know I went a bit fast, but I really got tired typing this much. Anyways, if you have any sort of doubts, or if my code has some errors, please point out by commenting below! I’ve tested the above code in WAMP.Similar Posts:

• Playing With Zend Framework 1.7
• An Update On My Zend Framework 1.7 Experience

But still, the amount of overhead was quite large if you’re planning on using a standard shared hosting. Luckily, Zend does provide a performance guide on the Zend Framework manual. If you follow it, you’ll surely be able to significantly improve the framework’s performance, but I still doubt if shared hosting would handle it with ease.

I’m currently developing a project with CodeIgniter 1.7.0 (the current version as of now), and it seems to be more than enough for what I need. With CI, the advantage is that you can start straight away, seeing the screencasts available on their websites. You’d understand most of the structural parts there itself, and a well written User Guide always to your rescue.

Its not that one framework is better than the other. Zend is definitely powerful, and I’m still learning new things about it everyday. I’m sure I’ll get an opportunity to use it in a real life project.

The choice of a framework should always be based on your convenience, your requirements, the overhead, and the platform selected for deployment. If I’m simply making a Contact Us form, I wont even be needing a framework (duh!).

I created a simple “test” application in CakePHP. Unfortunately, in my shared hosting, its caching didn’t work. The problem persisted even with default CakePHP setting (all directory structure etc.). The problem seems to be with the shared host, which I no longer use. I don’t really know what the problem was, but now everything’s fine with a good new host. CakePHP still is in RC3 as of now, and RC2 at the time of writing my “test” application.

Writing it took about a two to three days, because I was still learning CakePHP’s ORM and Naming Conventions, which I had to constantly refer to. It’ll become a habit soon, just need more experience. Because of the caching problem, I rewrote the entire application in a day (hey, it was really small) in pure PHP and Smarty especially for its built-in cache support and design/code separation.

It wasn’t that difficulty after all. But if I were to really develop the application, I’d have used a framework, for future scalability. For me, CI looks like a good choice for nice code organization, as well as basic Active Record and Validation support. Its quite feature rich, I must admit.

CakePHP is a real monster, but I’m still waiting it to come out of RC. As far as Zend is concerned, its quite great too, but I’ll need a resourceful server (not a weak shared hosting) for any serious decent traffic website.

Happy coding!Similar Posts:

• Playing With Zend Framework 1.7
• Using Zend Acl With CodeIgniter

Previously, I learnt CakePHP 1.2 RC (I’m desparately waiting for 1.2 Final). CakePHP did have a good documentation, though lacking at some parts (especially the 1.2 version). But still, the usage for so simple that you could, by yourself figure out many things. Code logically fitted into places.

Now, Zend Framework is a completely different monster. Instead of a large framework, its a collection of components, basically. You can use any component on its own, without using the entire library, as long as you also include dependencies. E.g., the Auth component would require Session component for storage, etc…

Zend Framework does have a good manual, covering practically all of its feature. You’d find some sort of code for all the components. But the problem is, in many cases, they are snippets. You may be able to use them if that’s the only component you’re ever going to use. But if you’re taking advantage of Zend Framework’s MVC structure, you might be clueless on where to put those codes, how to call them, when to call them etc.

If you’re just starting out with the Framework, I’d recommend going through the four screencasts. Then, watch the webinars on components of your interest, though they’re basically the same thing you’d see in the manual. But still, you can get some additional useful information in the webinars.

So far, I’ve been able to create the main index and bootstrap properly, along with understanding the significance of each statement I write. The AutoLoad feature of the framework is a real boon. You don’t need to scatter require or require_once statements all over your code. Zend Framework will load the class files automatically for you, if you follow the right convention (which you’ll learn in the manual and screencasts).

I even played with the Auth component, and it works like a charm. You can restrict access to certain controllers or even actions within controllers using Auth alone, but I’d always recommend using Acl for such things if you have more than 2 roles and need to restrict certain actions within controllers. It’ll save you a lot of typing in the end. A good tip to note here is that you can/should save the Acl roles/resources you’ve constructed in a cache (using Zend’s cache) or a file or in a database, so that you don’t need to have an overhead of constructing them everytime.

So far, I’ve been searching the internet for various tutorials on Zend tutorials. Many bloggers have posted tutorials on various sections of the framework, I’m assembling a list of tutorials I liked, and am soon going to post it here.

Well then, meet ya next time!Similar Posts:

• Using Zend Acl With CodeIgniter
• An Update On My Zend Framework 1.7 Experience