So I’ve created this small shipping calculator. It’s set to use KG in weight and prices inclusive of vat taken from the Royal Mail’s 2011 Prices.

Follows are the config ini file, the class and a basic usage.

[EUR]
prices[0.01] =1.79
prices[0.12] =1.94
prices[0.14] =2.15
prices[0.16] =2.32
prices[0.18] =2.54
prices[0.2] =2.63
prices[0.22] =2.75
prices[0.24] =2.87
prices[0.26] =2.99
prices[0.28] =3.08
prices[0.3] =3.14
prices[0.32] =3.8
prices[0.42] =4.46
prices[0.52] =5.12
prices[0.62] =5.78
prices[0.72] =6.44
prices[0.82] =7.1
prices[0.92] =7.76
prices[1] =7.76

above.start = 1.1
above.increment = 0.1
above.valuePerIncrement = 0.55

[ITL]
prices[0.01] =2.49
prices[0.12] =2.79
prices[0.14] =3.12
prices[0.16] =3.48
prices[0.18] =3.84
prices[0.2] =4.2
prices[0.22] =4.56
prices[0.24] =4.76
prices[0.26] =4.88
prices[0.28] =5
prices[0.3] =5.12
prices[0.32] =6.45
prices[0.42] =7.78
prices[0.52] =9.11
prices[0.62] =10.44
prices[0.72] =11.78
prices[0.82] =13.11
prices[0.92] =14.44
prices[1] =14.44

above.start = 1.1
above.increment = 0.1
above.valuePerIncrement = 0.66

[UK]
prices[0.1] =1.9
prices[0.25] =2.36
prices[0.5] =2.98
prices[0.75] =3.66
prices[1] =4.46
prices[1.25] =5.88
prices[1.5] =6.8
prices[1.75] =7.71
prices[2] =8.62
prices[4] =10.74

above.start = 6
above.increment = 2
above.valuePerIncrement = 3.66

<?php
class BinaryKitten_Shipping {
    private $_cfg;
    private $_curCfg;
    public function __construct($postalZone=null) {
        $this->_curCfg = $this->_cfg = new Zend_Config_Ini(APPLICATION_PATH .'/configs/postal.ini');
        if (isset($postalZone)) {
            $this->setPostalZone($postalZone);
        }
    }
    public function setPostalZone($postalZone)
    {
        if (self::validatePostalZone($postalZone)) {
            $this->_curCfg = $this->_cfg->get($postalZone, $this->_cfg);
        }

    }
    public static function validatePostalZone($postalZone)
    {
        return in_array(strtoupper($postalZone), array('UK','EUR','ITL'));
    }
    public function getPriceForWeight($weight)
    {
        $priceOut = -1;
        foreach($this->_curCfg->prices as $weightBoundary=>$price) {
            if ($weightBoundary < $weight) continue;
            if ($weightBoundary >= $weight) {
                $priceOut = $price;
                break;
            }
        }
        if ($priceOut == -1) {
            for($weightBoundary = (float)$this->_curCfg->above->start;$weightBoundary < $weight;$weightBoundary += $this->_curCfg->above->increment) {
                $price+=$this->_curCfg->above->valuePerIncrement;
            }

            $priceOut = $price;
            //try to calculate the difference
        }
        return (float)$priceOut;
    }
}

$prices = new BinaryKitten_Shipping();
$prices->setPostalZone('EUR');
$price = $prices->getPriceForWeight(5);

This works well, but I wanted to make sure that the plugn was not accessible unless the user logged in. I already used Zend_Auth and this doesn’t exactly play well with the basic SessionAuthenticator. So I set out to create a basic simple plugin for TinyMCE that would allow it to work with the Zend_Auth System.

- Creating the plugin -
first off we have to create our plugin and plugin folder within the tinymce plugin’s plugin folder. If you think that’s a lot of use of plugin, you can understand where my brain decided to up and leave.

1st locate your tinymce folder, in there you should find plugins and then go into the filemanager folder. Of course this assumes you have purchased and installed the filemanager plugin. Your path should be something like the following:
<path_to_tiny_mce>/plugins/filemanager/ – this is what we shall refer to our “Base Path” from now on.

now we are at a comfortable location to proceed, we can go ahead and create our folder and file
<Base Path>/plugins/ZendAuthenticator
in here place a file name ZendAuthenticator.php containing this code:

<?php
/**
 * Use Zend_Auth to validate the logged in user.
 *
 * @author BinaryKitten
 */
class BinaryKitten_ZendAuthenticator extends Moxiecode_ManagerPlugin {

    private $auth = null;
    public function  __construct($man)
    {
        $config = $man->getConfig();
        if (isset($config['ZendAuthenticator.LibraryPath']) && !empty($config['ZendAuthenticator.LibraryPath'])) {
            set_include_path(
                implode(
                    PATH_SEPARATOR, array(
                        realpath(
                        $config['ZendAuthenticator.LibraryPath']
                        ),
                        get_include_path(),
                    )
                )
            );
        }
        require "Zend/Auth.php";
        $this->auth = Zend_Auth::getInstance();
    }

    //put your code here
    public function onAuthenticate(&$man)
    {
        return $this->auth->hasIdentity();
    }
}

$man->registerPlugin("ZendAuthenticator", new BinaryKitten_ZendAuthenticator($man));

Voila the plugin is ready.

- Configuring the plugin -
Now open up the config.php found in the “Base Path” mentioned earlier.
locate: $mcFileManagerConfig['authenticator'] and set it’s value to the following
$mcFileManagerConfig['authenticator'] = 'ZendAuthenticator';

- Library Location -

Finally, If your Zend_Framework is not located on the include path (like mine is) then you will need to tell the system where to find the library, to do this add the following to the config.php
$mcFileManagerConfig['ZendAuthenticator.LibraryPath'] = ' ';
Please remember though that this is relative to the “Base Path” and not the Document_Root unless you specify it as such.

– - – - –
The last thing I will leave you with is that this only checks to see if there is a stored session for Zend_Auth. I’ll leave it up to you if you want to get roles and other fancy stuff integrated.

So I present to you active Module Config V2

Many thanks to Paul Bouzakis (@paul_eye) for the pointers in ways to make this more readable and concise

<?php
class BinaryKitten_ModuleConfig extends Zend_Controller_Plugin_Abstract
{
    /**@var string The Init Name aka initModule */
    private $_moduleInitName = '';

    public function routeShutdown(Zend_Controller_Request_Abstract $request)
    {
        $activeModuleName = $request->getModuleName();
        $this->_moduleInitName = $activeModuleName."Init";

        $appBootstrap = $this->_getMainBootstrap();
        $activeModuleBootstrap = $this->_getActiveBootstrap($appBootstrap, $activeModuleName);
        $this->_processApplicationBootstrap($appBootstrap);
        if ($activeModuleBootstrap instanceof Zend_Application_Module_Bootstrap) {
            $this->_processActiveModuleBootstrap($activeModuleBootstrap);
        }
    }

    /*****************************************************************
     * Gets the Main Boostrap Object
     *
     * @return Zend_Application_Bootstrap_Bootstrap Main Bootstrap
     *****************************************************************/
    private function _getMainBootstrap()
    {
        $frontController = Zend_Controller_Front::getInstance();
        $bootstrap =  $frontController->getParam('bootstrap');
        return $bootstrap;
    }

    /*******************************************************************************
     * Gets the Current Active Module's Boostrap Object
     *
     * @param Zend_Application_Bootstrap_Bootstap $appBootstrap The Main Bootstrap
     * @param String $activeModuleName The name to find.
     * @return Zend_Application_Module_Bootstrap Active Module Bootstrap
     ******************************************************************************/
    private function _getActiveBootstrap($appBootstrap, $activeModuleName)
    {
        $moduleList = $appBootstrap->modules;
        if (isset($moduleList[$activeModuleName])) {
            $activeModule = $moduleList[$activeModuleName];
        } else {
            $activeModule = $appBootstrap;
        }
        return $activeModule;
    }

     /*********************************************************
     * Process the methods from within the main bootstrap
     * @param Zend_Application_Bootstrap_BootstrapAbstract $appBootstrap The Application Bootstrap;
     **********************************************************/
    private function _processApplicationBootstrap($appBootstrap)
    {
        $moduleInitNameLength = strlen($this->_moduleInitName);
        $bootstrapMethodNames = get_class_methods($appBootstrap);
        foreach ($bootstrapMethodNames as $key=>$method) {
            $runMethod = false;
            $methodNameLength = strlen($method);
            if ($this->_isModuleNameInitMethod($method)) {
                $resource = call_user_func(array($appBootstrap, $method));
                $resourceName = substr($method, $moduleInitNameLength);
                if (!is_null($resource)) {
                    $this->storeResource($resource, $resourceName, $appBootstrap);
                }
            }
        }
    }

    /*********************************************************
     * Process the methods from within the main bootstrap
     * @param Zend_Application_Module_Bootstrap $activeModuleBootstrap The "Active"  Modules's Bootstrap;
     **********************************************************/
    private function _processActiveModuleBootstrap($activeModuleBootstrap)
    {
        $moduleInitNameLength = strlen($this->_moduleInitName);
        $methodNames = get_class_methods($activeModuleBootstrap);
        foreach ($methodNames as $key=>$method) {
            $runMethod = false;
            if ($this->_isActiveInitMethod($method)) {
                $resourceName = substr($method, 10);
                $runMethod = true;
            } elseif ($this->_isModuleNameInitMethod($method)) {
                $resourceName = substr($method, $moduleInitNameLength);
                $runMethod = true;
            }
            if ($runMethod) {
                $resource = call_user_func(array($activeModuleBootstrap, $method));
                if (!is_null($resource)) {
                    $this->storeResource($resource, $resourceName, $activeModuleBootstrap);
                }
            }
        }
    }

    /*******************************************************
     * Check to see if the method is in style of ModulenameInitXXX
     * @param string $method The method name to check
     ********************************************************/
    private function _isModuleNameInitMethod($method)
    {
        $methodNameLength = strlen($method);
        $moduleInitNameLength = strlen($this->_moduleInitName);
        $methodNameLonger = ($moduleInitNameLength < $methodNameLength);
        $methodNameBeginMatch = $this->_moduleInitName == substr($method, 0, $moduleInitNameLength);
        return $methodNameLonger && $methodNameBeginMatch;
    }

    /*******************************************************
     * Check to see if the method is in style of activeInitXXX
     * @param string $method The method name to check
     ********************************************************/
    private function _isActiveInitMethod($method)
    {
        $methodNameLength = strlen($method);
        $methodNameLonger = ($methodNameLength > 10);
        $methodNameBeginMatch = 'activeInit' === substr($method, 0, 10);
        return $methodNameLonger && $methodNameBeginMatch;
    }

    /***********************************
     * Store the resource returned by the function so that it can be "bootstrapped"
     * @param misc $resource The Resource to be stored
     * @param string $name the name of the resource
     * @param Zend_Application_Bootstrap_BootstrapAbstract $bootstrap The Bootstrap against which to store the resource
     ********************/
    private function storeResource($resource, $name, $bootstrap)
    {
        // Store the resource.. not sure how to do this yet.. if you do let me know! 
    }
}

The Solution

The solution is to extend Zend_form and use the extended version as the basis for all the forms in the application. Here is my Form class.

<?php
class BinaryKitten_Form extends Zend_Form
{
    private $_stylesheets = array(
        'main'=>array('href'=>'/css/form.css', 'media'=>'screen')
    );

    public function addStylesheet($href,$media='screen')
    {
        $this->_stylesheets[basename($href)] = array(
            "href"=>$href,
            "media"=>$media
        );
    }

    public function removeStylesheet($href)
    {
        unset($this->_stylesheets[basename($href)]);
    }

    public function clearStylesheets()
    {
        $this->_stylesheets = array();
    }

    public function render(Zend_View_Interface $view = null)
    {
        if (null !== $view) {
            $this->setView($view);
        }
        else {
            $view = $this->getView();
        }

        foreach ($this->_stylesheets as $stylesheet) {
            $view->headLink()->appendStylesheet($stylesheet['href'], $stylesheet['media']);
        }

        $content = '';
        foreach ($this->getDecorators() as $decorator) {
            $decorator->setElement($this);
            $content = $decorator->render($content);
        }
        return $content;
    }
}

Of course you would extend it as usual to create a new form….

<?php
class BinaryKitten_Form_LoginForm extends BinaryKitten_Form
{
    public function __construct($option = null)
    {
        parent::__construct($option);
        $decorators = array(
            array('ViewHelper'),
            array('Label', array(
                'requiredSuffix'=>" *"
            )),
            array('HtmlTag', array('tag'=>'div'))
        );

        $username = new Zend_Form_Element_Text('username');
        $username
            ->setLabel('Username')
            ->setRequired(true)
            ->addValidator('NotEmpty', true)
            ->addFilter("StringTrim")
            ->addErrorMessage('Please Enter your Username')
            ->setDecorators($decorators);

        $password = new Zend_Form_Element_Password('password');
        $password
            ->setLabel('Password')
            ->setRequired(true)
            ->addValidator('NotEmpty', true)
            ->addFilter("StringTrim")
            ->addErrorMessage('Please Enter your Password')
            ->setDecorators($decorators);

        $loginButton = new Zend_Form_Element_Submit('login');
        $loginButton
            ->setValue('login');

        $this
            ->addElements(
                array(
                    $username,
                    $password,
                    $loginButton
                )
            )
            ->setMethod('post')
            ->setName('loginForm')
            ->addDecorator(
                array('mytag' => 'HtmlTag'), array('tag' => 'div')
            )
            ->removeDecorator('HtmlTag');

        $this->addStylesheet('/css/loginform.css','screen');
    }
}

And then as usual in you controller:

$form = new BinaryKitten_Form_LoginForm();
$this->view->form = $form;

and of course, echo it out in the view
[sourcecoe lang="php"]
echo $this->form;
[/sourcecode]

And that’s it, Simple.
Hopefully this will help someone out there

The Problem

The Concept I wanted to achieve was to have unique Configuration based upon the module that was active. The Issue with this is that the Bootstrap files and the _init functions for ALL modules are called with no bias as to which module is active. Thus if you created a 3 modules wanted to make menu alterations in one, those alterations will be applied to all. I also wanted to have a a system where if i added extra modules i could just add extra functions to the bootstrap file and it would work in a similar way.

With this in mind, I set about trying to figure out the solution.

New Version

Though this version still works and you should read through the code to see how to implement the plugin, there is a new version available at:
http://binarykitten.me.uk/dev/zend-framework/296-active-module-config-v2.html
Please refer to this as the latest version.. Thanks

—– Original Post —–

Solution 1 – Failure

With the Idea that no-body is perfect, including myself. My 1st attempt ended in failure. This attempt was to modify/extend the Bootstrap class to add extra functions to the resources list.. In the end I couldn’t determine if the Module bootstrap was the active one. ok So Attempt 1 was a failure, onto the next

Solution 2 – Success!

A quick conversation with Matthew Weier O’Phinney (@weierophinney) pointed me in the direction of Controller plugins and the routeShutdown method, as after the route had been finished which module was active would be able to be discerned.
At this point I must apologise to Pieter Kokx ( @kokxie ) who I had a small disagreement with in the #zftalk channel. Pieter had done his best to point me down this route to start with, though being a stubborn mule I am refused to see the quality and precision of his comments.
Thank you both for your help here.

The way that this works is that is scans the active modules bootstrap for functions starting with activeInit or modulenameInit just like the _init functions but these would only be called if the module is active.
I was successfully able to create the plugin and trigger the functions, unfortunately it was triggering/calling them in a static sense.. which meant that standard _init style code wouldn’t work. Luckily with a little digging in the source of the framework i found a storage of the modules and their initiated bootstrap classes. Lucky Me! So finally we call the methods within the right context.

So Here it is the Final Code, Please do comment, I learn from people as I hope that others can learn from me.

I’ve used the “Namespace” of BinaryKitten here. If you want to use a different “Namespace” Replace BinaryKitten with what you want.
The “Namespace” allows for the use of the BinaryKitten folder within the Libray Folder.
Remember the Controller Plugin should go in the right place for your application, if you are using the autoloader you can add the “Namespace” to be autoloaded via your application.ini

autoloadernamespaces[] = "BinaryKitten"

First off we have the Controller Plugin.
This should go into the “Namespace” folder within the Library Folder and should be called ModuleConfig.php

<?php
class BinaryKitten_ModuleConfig extends Zend_Controller_Plugin_Abstract
{
    public function routeShutdown(Zend_Controller_Request_Abstract $request)
    {
        $frontController = Zend_Controller_Front::getInstance();
        $bootstrap =  $frontController->getParam('bootstrap');
        $activeModuleName = $request->getModuleName();
        $moduleList = $bootstrap->modules;

        $moduleInitName = strtolower($activeModuleName)."Init";
        $moduleInitNameLength = strlen($moduleInitName);

        if (isset($moduleList[$activeModuleName])) {
            $activeModule = $moduleList[$activeModuleName];

            $bootstrapMethodNames = get_class_methods($bootstrap);
            foreach ($bootstrapMethodNames as $key=>$method) {
                $runMethod = false;
                $methodNameLength = strlen($method);
                if ($moduleInitNameLength < $methodNameLength &&
                    $moduleInitName == substr($method, 0, $moduleInitNameLength)) {
                    call_user_func(array($bootstrap,$method));
                }
            }
        } else {
            $activeModule = $bootstrap;
        }

        $methodNames = get_class_methods($activeModule);
        foreach ($methodNames as $key=>$method) {
            $runMethod = false;
            $methodNameLength = strlen($method);
            if (10 < $methodNameLength && 'activeInit' === substr($method, 0, 10)) {
                $runMethod = true;
            } elseif ($moduleInitNameLength < $methodNameLength &&
                    $moduleInitName == substr($method, 0, $moduleInitNameLength)) {
                $runMethod = true;
            }
            if ($runMethod) {
                call_user_func(array($activeModule,$method));
            }
        }
    }
}

Next we need to make sure the Controller Plugin is loaded.
We can do this in one of two ways. Either in the Application Bootstrap via an _init function

public function _initControllerPlugins()
{
    $plugin = Zend_Controller_Front::getInstance()->registerPlugin(
        new BinaryKitten_ModuleConfig()
    );
}

*– Or –*

We can add a line to the application.ini

resources.frontController.plugins.BKModuleConfig = "BinaryKitten_ModuleConfig"

Finally some example init code from the module bootstrap.
Please remember that the activeInit*() Functions need to be public for this to work properly

class Default_Bootstrap extends Zend_Application_Module_Bootstrap {
    public function activeInitMenus() {
        $layout = $this
                    ->bootstrap('layout')
                    ->getResource('layout');

        $view = $layout->getView();
        $config = new Zend_Config_Xml(APPLICATION_PATH.'/configs/navigation_default.xml',"menu");
        $navigation = new Zend_Navigation($config);
        $view->navigation($navigation);
    }
    public function activeInitDoSomethingElse() {
        /* some other code */
    }
    public function defaultInitSomething() {
    	/* more code */
    }
}

We can also add module inits to the application bootstrap like so:

    public function modulenameInitFunction() {
    	/* place code here */
    }

Where modulename is the lowercase version of the Modules name, eg if you have the Admin module, then you would use:

    public function adminInitFunction() {
    	/* place code here */
    }

Hopefully someone will find this code useful.

[ Edit January 5th 2010 ]
Thanks to:
Matthew Weier O’Phinney for pointing out places for update.
Rob Allen (@Akrabat) for the info that the plugin could be loaded via the application.ini
Elizabeth Marie Smith and Matthew Turland for questioning the use of the Reflection.

• Updated the Bootstrap code to properly define the functions as Public
• Removed the reflection as this wasn’t actually required any more.
• Updated Post to make clean up the order of things and to properly designate that the BinaryKitten is the “Namespace”
  “Namespace” is used to reference that we’re not using PHP5.3 Namespaces, but the Namespaces within the Zend Framework.

[ Edit January 11th 2010 ]
Thanks to:
septem for pointing out a typo where i had $boostrap instead of $bootstrap
Gerard Roche for pointing out that by default, the default module doesn’t require a module bootstrap (in my code it has one)

• Updated to fix the typos
• Added in a quick check to see if the module exists in the modules list of bootstraps
• Removed the _ from the function name that it searches for, this should please the people who are adamant over the Zend Coding Standards
• Added in the functionality to have $modulenameInit() functions as well in both active module bootstrap and the application bootstrap

[ Edit February 13th 2010 ]
Ran the code through codesniffer against the Zend Standard supplied.. updated so no errors found. 3 Warnings are left .. they are as follows:
22 | WARNING | Line exceeds 80 characters; contains 83 characters
35 | WARNING | Line exceeds 80 characters; contains 84 characters
38 | WARNING | Line exceeds 80 characters; contains 83 characters
Don’t think it’s worth the change for 3/4 characters

I had just recently looked over Rob Allen’s (@Akrabat http://akrabat.com/) PHP Nw 08 Conference Talk on “First Steps with Zend Framework”. As I had not been really feeling all that great at the conference itself, I was glad to be able to watch teh recorded version on the web. During the 1st segment of the talk, Rob described how zend cache was his first foray into the Zend Framework and this lead me onto how I was thinking about how the best way to implement the caching on my site(s).

So, with this in mind, off I trotted to http://framework.zend.com to grab the Zend Cache component that I wanted to look at. That’s where I hit a snag. It seemed impossible to actually get the components on their own. After about half and hour of scouring the site I still couldn’t find what I wanted, so I Tweeted about my annoyance.. To which I got a couple of replies… the 1st reply came from Richard Chiswell (@rchiswell) who said:

@BinaryKitten You might find the Dependencies list at http://bit.ly/199FYR useful. You could try contacting @CalEvans who wrote a book on ZF

The bit.ly link took me to: http://framework.zend.com/manual/en/requirements.html#requirements.dependencies the listing of the components and their dependencies, Though this was helpful it wasn’t really as helpful as the reply i got from Cal Evans (@CalEvans):

@BinaryKitten http://epic.codeutopia.net/pack/

Short Sweet and Wham.. That is exactly what I needed.

Shortly afterwards Richard blogged about this, which in turn made me feel like I should blog about it as well, and oooh look.. So I have.