First of all, you already have a system

WordPress, though traditionally a blogging platform, can be used as a full-blown CMS if you want. Apart from making online publishing easy, it also has access level controls built-in.

WordPress allows you to add functionality that it already does not have. And while you attempt to do that, your plugin has access to all the functions and capabilities of WordPress.

Now, let me explain how you can get great ideas for WordPress…

It may be common in PHP, but not in WordPress

Many WordPress users are not so technically savvy that they can play with PHP files and configure them. We hackers like to do it, but it’s too inconvenient for them. So, all of the WordPress’ plugins have an options panel that helps in easy configuration.

Do you remember writing or even seeing PHP pages that expire after a certain date, or a certain number of hours from the starting date? Well, it’s easy to write that. Just get the current time and find out if the page is supposed to be “expired.”

A beginning PHP programmer can easily make such a script. But such simple scripts are also available for download just in-case you don’t know PHP. They also come with simple instructions on modifying the script to specify the “exact time” of the expiration.

Now, that’s a very simple concept. A beginner would not be so delighted after writing such a script.

However, what if you wanted to do the same in WordPress. Let’s say you could set certain posts/pages to expire magically after a certain period of time?

But WordPress is different. Your script has to work seamlessly with WordPress, making sure that you allow your users to use your script without fiddling with any PHP files. You also need a clean interface where user can easily set and remove expiration.

Now, this simple task has become quite challenging. The challenge comes due to your concentration on making the script (now a WordPress plugin) as seamless as possible to use.

What could you do? Maybe you could have an expiration setting shown on each post or page’s edit page. Or maybe have a separate options panel where users can select pages/posts that they want to have expired. There are numerous design decisions you can make. It all depends on you and your taste.

Suddenly, the simple task of creating a simple PHP script has turned into a complex task of making it accessable to a certain subset of users. It’s challenging, and might keep you busy for a while. Your programming experience will also increase in the process.

So, just browse all those script directories and choose the ones you’d like to adapt to WordPress. And there you have a virtually infinite set of ideas for WordPress plugins.

Where do I begin?

Now that you’re charged up, I should also point you to some resources that will teach you how to create WordPress plugins.

I’d recommend starting with Writing a Plugin – WordPress Codex. Once you read that, you’ll also find a couple of links at the bottom referring to various tutorials.

Go ahead and make ‘em

Instead of creating just “test scripts,” you’d be creating stuff that people would want to use. So, what are you waiting for?

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:

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