Zend FR

<?php
/**
 * Tight_Di - Contains all dependencies references
 *  
 * @category Tight
 * @package Tight_Di
 * @author Benjamin Dulau
 */
class Tight_Di  {
    
    /**
     * Array of instances     
     * @var array
     */
    protected $_instances = array();
    
    /**
     * Array of registered dependencies     
     * @var array
     */
    protected $_components = array();

    
    /**
     * Constructor - calls load method for each file
     * 
     * @param array $componentFiles
     * @return void
     */
    public function __construct(array $componentFiles = array())
    {
        foreach($componentFiles as $file) {
            $this->load($file);
        }
    }

    /**
     * Loads file and builds components definitions
     * 
     * @param string $componentFile
     * @return bool success
     * @throws Tight_Di_Exception if unable to load file as XML
     */
    public function load($componentFile)
    {        
        if (false === file_exists($componentFile) || false === is_file($componentFile)) {
            Throw new Tight_Di_Exception(Tight_Di_Exception::NO_SUCH_FILE . ': ' . $componentFile);
            return false;                
        } 
        
        $xml = null;
        if (false === ($xml = simplexml_load_file($componentFile))) {
            Throw new Tight_Di_Exception(Tight_Di_Exception::FILE_LOAD_FAILED . ': ' . $componentFile);
            return false;            
        };    

        foreach ($xml->component as $XMLElement) {
            $component = array();
        
            // id
            $id = (string)$XMLElement->attributes()->id;
            $component['class'] = (string)$XMLElement->attributes()->class;        

            // dependencies
            $component['dependencies'] = array();
            foreach($XMLElement->property as $property) { 
                $name = (string)$property->attributes()->name;
                $refComponent = (string)$property->attributes()->ref;
                                
                $component['dependencies'][$name] = $refComponent;                                             
            }
            
            $this->addComponent($id, $component);
        }
        
        return true;
    }

    /**
     * Adds a dependency reference to container     
     *
     * @param  array $dependency config array for provided dependency     
     * @return Tight_Di
     */
    public function addComponent($key, array $component) {                
        $this->_components[$key] = $component;
        return $this;        
    }
    
    /**
     * Returns component definition
     * 
     * @param string $key
     * @return array
     */
    public function getComponent($key) {        
        return $this->_components[$key];        
    }
    
    /**
     * Returns all components definitions array
     * 
     * @return array
     */
    public function getComponents()
    {
        return $this->_components;
    }
    
    /**
     * Retrieves component instance.
     * Creates instance if none exists yet
     * 
     * @param $key
     * @return mixed
     */
    public function getInstance($key)
    {
        $component = $this->getComponent($key);
        if (false === array_key_exists($key, $this->_instances)) {
            $this->_instances[$key] = new $component['class']();            
        }
        
        return $this->_instances[$key];
    }
    
    /**
     * Injects recursively dependencies starting by $key
     *  
     * @param $key
     * @param $target
     * @return void
     */
    public function inject($key, $target)
    {        
        $component = $this->getComponent($key); 
        foreach($component['dependencies'] as $property => $ref) {            
            $var = '_' . $property;
            $setter = 'set' . ucfirst($property);
            
            $instance = $this->getInstance($ref);        
            $target->$setter($instance);
            
            // recursive injection for dependency dependencies
            $this->inject($ref, $instance);
        }
    }
    
    /**
     * Sets directly an instance into instances.
     * Used by Zend_Application on resource plugin return.     
     *
     * @param string $key
     * @param mixed $instance
     * @return Tight_Di
     */
    public function __set($key, $instance)
    {
        /*$component = array();                               
        $component['class'] = get_class($instance);        
        
        // dependencies
        $component['dependencies'] = array();                        
        $this->addComponent($key, $component);*/

        $this->_instances[$key] = $instance;
        
        return $this;    
    }

    /**
     * Gets the given instance
     * Used by Zend_Application on getInvokArg()
     *
     * @param string $key
     * @return mixed instance
     */
    public function __get($key)
    {        
        return $this->getInstance($key);
    }
    
    /**
     * Tests if an object exists into instances
     * Used by Zend_Application
     *
     * @param string $key
     * @return bool
     */
    public function __isset($key)
    {        
        return array_key_exists($key, $this->_instances);
    }
}

/** Tight_Di */
require_once 'Tight/Di.php';

$container = new Tight_Di(array(
    APPLICATION_PATH . '/config/cpt-resources.xml',
    APPLICATION_PATH . '/config/cpt-controllers.xml',
    APPLICATION_PATH . '/config/cpt-services.xml',
    APPLICATION_PATH . '/config/cpt-daos.xml'    
));

/** Zend_Application */
require_once 'Zend/Application.php';

// Creates application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV, 
    APPLICATION_PATH . '/config/application.ini'
);

$application->getBootstrap()->setContainer($container);
$application->bootstrap()
            ->run();

// cpt-resources.xml
// les classes ici n'ont pas vraiment d'importance
<?xml version="1.0" encoding="UTF-8"?>
<components>
    <component id="db" class="Zend_Db" />        
    <component id="exception" class="Zend_Exception" />
    <component id="modules" class="" />
    <component id="exception" class="Zend_Exception" />
    <component id="Navigation" class="Zend_Navigation" />
    <component id="Routeur" class="Zend_Router" />
    <component id="frontcontroller" class="Zend_Controller_Front" />
    <component id="layout" class="Zend_Layout" />
    <component id="view" class="Tight_View" />
    <component id="locale" class="Zend_Locale" />
    <component id="translate" class="Zend_Translate" />    
    <component id="session" class="Zend_Session" />
    <component id="config" class="Zend_Config" />
    <component id="modeltemplate" class="Tight_Model_Template" />
    <component id="mailer" class="Tight_Mail" />
    <component id="acl" class="Tight_Acl" />
</components>

// cpt-controllers.xml
<?xml version="1.0" encoding="UTF-8"?>
<components>
    <!-- Default module -->
    <component id="indexController" class="Default_IndexController">
        <property name="tr" ref="translate" />
    </component>
    <component id="errorController" class="Default_ErrorController">
        <property name="tr" ref="translate" />
    </component>    
    <!-- Sign module -->
    <component id="signIndexController" class="Sign_IndexController">
        <property name="tr" ref="translate" />
        <property name="userService" ref="userService" />
        <property name="mailService" ref="mailService" />
    </component>
</components>

// cpt-services.xml
<?xml version="1.0" encoding="UTF-8"?>
<components>
    <component id="userService" class="Service_User">
        <property name="userDAO" ref="userDAO" />
        <property name="acl" ref="acl" />
    </component>
    <component id="mailService" class="Service_Mail">
        <property name="mailer" ref="mailer" />
    </component>
</components>

// cpt-daos.xml (avec mapper)
<?xml version="1.0" encoding="UTF-8"?>
<components>
    <component id="userDAO" class="Model_Dao_User">
        <property name="mapper" ref="mapper" />
    </component>
    <component id="mapper" class="Model_Db_Mapper">
        <property name="db" ref="db" />
        <property name="template" ref="modeltemplate" />
    </component>
</components>

<?php
/**
 * Provide IOC
 *
 * @uses       Zend_Controller_Action_Helper_Abstract
 * @category   Tight
 * @package    Tight_Controller
 * @author       Benjamin Dulau
 */
class Tight_Controller_Action_Helper_Di extends Zend_Controller_Action_Helper_Abstract 
{          
    /**
     * @var bool
     */
    protected $_enabled = true;
    
    /**
     * If not disabled by the action controller:
     * Browses registered components from Tight_Di
     * and injects instances from controller to all dependencies     
     */
    public function init()
    {                
        if (false === $this->_enabled) {
            return;
        }
        
        $bootstrap = $this->_actionController->getInvokeArg('bootstrap');
        $container = $bootstrap->getContainer();        
        $components = $container->getComponents();                
        
        $module = $this->_actionController->getRequest()->getModuleName();        
        $currentControllerClass = ucfirst($module) . '_' . ucfirst($this->_actionController->getRequest()->getControllerName()) . ucfirst($this->_actionController->getRequest()->getControllerKey());
        
        foreach($components as $k => $v) {            
            if ($v['class'] == $currentControllerClass) {
                $container->inject($k, $this->_actionController);
                break;
            }                    
        }    
    }        
    
    /**
     * Enable IOC
     * To be called from action controllers
     */
    public function enable()
    {        
        $this->_enabled = true;
    }
    
    /**
     * Disable IOC
     * To be called from action controllers
     */
    public function disable()
    {        
        $this->_disable = true;
    }
}

<?php
/**
 *  Example
 */
class Common_Controller_Action extends Tight_Controller_Action
{
    /**     
     * @var Zend_Translate
     */
    protected $_tr;
        
    
    public function setTr(Zend_Translate $tr)
    {
        $this->_tr = $tr;
        return $this;
    }
}

<?php
/**
 * Example
 */
class Sign_IndexController extends Common_Controller_Action
{    
    /**     
     * @var Service_User
     */
    private $_userService;
    
    /**     
     * @var Service_Mail
     */
    private $_mailService;
                

    public function setUserService(Service_User $userService)
    {
        $this->_userService = $userService;
        return $this;
    }
    
    public function setMailService(Service_Mail $mailService)
    {
        $this->_mailService = $mailService;
        return $this;
    }
    
    
    public function indexAction()
    {
        // test à la con
        $user = $this->_userService->getUserById(1);
    }
}

<?php 
interface Service_Generic_IUser 
{ 
    public function authenticate($login, $password);
       
    public function createUser(Model_User $user);    
        
    public function saveUser(Model_User $user);
        
    public function getUserById ($id);    
}

?php
class Service_User extends Tight_Service_Service implements Service_Generic_IUser
{  
    /**     
     * @var Model_Dao_User
     */
    private $_userDAO;
    
    /**     
     * @var Tight_Acl
     */
    private $_acl;
       
    public function setUserDAO(Model_Dao_User $userDAO)
    {
        $this->_userDAO = $userDAO;
        return $this;
    }
    
    public function setAcl(Tight_Acl $acl)
    {
        $this->_acl = $acl;
        return $this;
    }
    
    public function __construct ()
    {}
       
    /**
     * Authenticate an user
     * 
     * @param string  $login
     * @param string  $password
     * @return bool success
     */
    public function authenticate($login, $password)
    {        
        return $this->_userDAO->authenticate($login, $password);        
    }

    /**
     * Create new user     
     * 
     * @param Model_User $user
     * @return bool
     */
    public function createUser(Model_User $user)
    {
        $user->setCreated(Zend_Date::getTimestamp());
        return $this->_userDAO->create($user);
    }
    
    /**
     * Save user
     * @param Model_User $user
     * @return boolean
     */
    public function saveUser(Model_User $user)
    {
        return $this->_userDAO->save($user);       
    }

    /**
     * Find and populate User with id $id
     * 
     * @param  string $id 
     * @return Model_User
     */
    public function getUserById ($id)
    {
        return $this->_userDAO->find($id);    
    }

    // etc. etc.
}

<?php 
interface Model_Dao_Generic_IUser 
{ 
    public function create(Model_User $user);
    
    public function save(Model_User $user);
    
    public function authenticate($login, $password);
    
    public function find($id);
    
    public function findByLogin($login);    
}

<?php 
class Model_Dao_User extends Tight_Model_Dao implements Model_Dao_Generic_IUser
{ 
    public function create(Model_User $user)
    {
        try {
            $this->getMapper()->create($user);
            return true;
        }
        catch (Exception $e) {            
            throw new Exception($e->getMessage());
            return false;
        }        
    }
    
    public function save(Model_User $user)
    {
        try {
            $this->getMapper()->save($user);
            return true;
        }
        catch (Exception $e) {            
            throw new Exception($e->getMessage());
            return false;
        }
    }
    
    
    public function authenticate($login, $password)
    {                
        $authAdapter = new Zend_Auth_Adapter_DbTable(Zend_Db_Table::getDefaultAdapter());
        $authAdapter->setTableName('user')
                    ->setIdentityColumn('login')
                    ->setCredentialColumn('password');
        // Définit les valeurs avec lesquels authentifier l'utilisateur (ici venant d'un formulaire)
        $authAdapter->setIdentity($login)
                    ->setCredential($password)
                    ->setCredentialTreatment('MD5(?)');

        $auth = Zend_Auth::getInstance();
        $result = $auth->authenticate($authAdapter);
        
        if ($result->isValid()) {                        
            $data = $authAdapter->getResultRowObject(null, 'password');                        
            $user = $this->getMapper()->buildEntity($data, 'Model_User');

            $auth->getStorage()->write($user);

            return true;
        }
        else {
            
            return false;
        }
    }
    
    /**     
     * @return Model_User
     */
    public function find($id)
    {
        try {            
            return $this->getMapper()->find('Model_User', $id);                        
        }
        catch (Exception $e) {            
            throw new Exception($e->getMessage());
            return false;
        }
    }
    
    /**     
     * @return Model_User
     */
    public function findByLogin($login)
    {
        $select = $this->getMapper()->getDb()->select()
                       ->from('user')                       
                       ->where('login = ?', $login);                       
        
        return $user = $this->getMapper()->fetchByCriteria('Model_User', $select, true);
    }
}

<?php 
abstract class Tight_Model_Dao
{
    /**
     * @var Tight_Model_Mapper
     */
    private $_mapper;
    
    /**
     * @param Tight_Model_Mapper $mapper
     * @return Tight_Model_Dao
     */
    public function setMapper(Tight_Model_Mapper $mapper)
    {
        $this->_mapper = $mapper;
        return $this;
    }
    
    /**
     * @return Tight_Model_Mapper
     */
    public function getMapper()
    {
        return $this->_mapper;
    }

}

$this->getMapper()->find('Model_User', $id);

<?php
interface Tight_Model_IMapper {

    /**
     * Fetch Array of entities found with criteria     
     * 
     * @param string $entity The Entity type to populate and return
     * @param mixed $criteria
     * @return ArrayObject|Tight_Model_Entity
     */
    public function fetchByCriteria($entity, $criteria, $fetchOne = false);
    
    /**
     * Fetch all entities     
     * 
     * @param string $entity The Entity type to populate and return
     * @return ArrayObject|Tight_Model_Entity
     */
    public function fetchAll($entity);
    
    /**     
     * Find an entity by id
     * 
     * @param string $entity The Entity type to populate and return
     * @param array|string $primary primary keys array
     * @return Tight_Model_Entity
     */
    public function find($entity, $primary);
    
    /**
     * Create (insert) entity into persistence
     * 
     * @param  Tight_Model_Entity $entity
     * @return void
     */
    public function create(Tight_Model_Entity $entity);
    
    /**
     * Save (update) entity into persistence
     * 
     * @param Tight_Model_Entity $entity
     * @return void
     */
    public function save(Tight_Model_Entity $entity);
    
    /**
     * Delete entity from persistence
     * 
     * @param Tight_Model_Entity $entity
     * @return void
     */
    public function delete(Tight_Model_Entity $entity);
    
    /**
     * Build an entity from an object
     * 
     * @param stdClass $row
     * @param string $entity The Entity type to populate and return
     * @return Tight_Model_Entity
     */
    public function buildEntity($row, $entity);
}

<?php
/**
 * Tight_Model_Db_Mapper
 * Db Table Mapper
 * 
 * @category   Tight
 * @package    Tight_Model
 * @subpackage Db
 * @author     Benjamin Dulau
 */
abstract class Tight_Model_Db_Mapper extends Tight_Model_Mapper implements Tight_Model_IMapper
{        
    /**     
     * @var Zend_Db_Adapter_Abstract
     */
    protected $_db;
    
    
    /**     
     * @var Tight_Model_Template
     */
    protected $_template;
    
    /**
     * Constructor
     *      
     */
    public function __construct()
    {

    }
    
    /**     
     * @param Tight_Model_Template $template
     * @return Tight_Model_Db_Mapper
     */
    public function setTemplate(Tight_Model_Template $template)
    {
        $this->_template = $template;
        return $this;
    }
    
    /**          
     * @return Tight_Model_Template
     */
    public function getTemplate()
    {
        return $this->_template;
    }
    
    /**
     * Set Db adapter to use
     * 
     * @param Zend_Db_Adapter_Abstract $db
     * @return Tight_Model_Db_Table_Mapper Provides a fluent interface
     * @throws Tight_Model_Db_Mapper_Exception 
     */
    public function setDb($db)
    {
        if (!$db instanceof Zend_Db_Adapter_Abstract) {
            throw new Tight_Model_Db_Mapper_Exception(Tight_Model_Db_Mapper_Exception::INVALID_TABLE_GATEWAY);
        }        
        $this->_db = $db;
        $this->_db->setFetchMode(Zend_Db::FETCH_OBJ);
        
        return $this;
    }

    /**     
     * @return Zend_Db_Adapter_Abstract
     * @throws Tight_Model_Db_Mapper_Exception
     */
    public function getDb()
    {
        if (null === $this->_db) {
            throw new Tight_Model_Db_Mapper_Exception(Tight_Model_Db_Mapper_Exception::TABLE_GATEWAY_NOT_FOUND);
        }
        
        return $this->_db;
    }    

    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#fetchByCriteria($entity, $criteria)
     */
    public function fetchByCriteria($entity, $select, $fetchOne = false)
    {                
        try {
            if (true === $fetchOne) {
                $row = $this->getDb()->fetchRow($select);
                if (is_null($row) || empty($row)) {
                    return null;
                }
                $entries = $this->buildEntity($row, $entity);                
            }
            else {
                $rows = $this->getDb()->fetchAll($select);
                $entries = new ArrayObject();                
                foreach ($rows as $row) {
                    $entries[] = $this->buildEntity($row, $entity);
                }
            }            
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
        }
        
        return $entries;
    }
    
    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#fetchAll($entity)
     */
    public function fetchAll($entity)
    {
        try { 
            $rows = $this->getDb()->fetchAll($select);
            $entries = new ArrayObject();
            foreach ($rows as $row) {
                $entries[] = $this->buildEntity($row, $entity);
            }
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
        }
        
        return $entries;
    }
    
    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#find($entity, $primary)
     */
    public function find($entity, $primary)
    {                        
        $map = $this->getTemplate()->getEntityMapping($entity);        
        try {                                 
            $table = new Zend_Db_Table($map['table']);
            $table->setOptions(array('primary' => $map['id']));                        
            
            $row = $table->find($primary)->current();                       
            if (is_null($row) || empty($row)) {
                return null;
            }                        
            
            $entry = $this->buildEntity($row, $entity);      
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
        }
        
        return $entry;
    }

    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#create($entity)
     */
    public function create(Tight_Model_Entity $entity)
    {        
        // entité = parent du proxy
        $entityStr = get_class($entity);
        
        $map = $this->getTemplate()->getEntityMapping($entityStr);
        
        try {                                 
            $table = new Zend_Db_Table($map['table']);
            $table->setOptions(array('primary' => $map['id']));
            
            $row = $table->createRow();
            foreach ($map['fieldMap'] as $property => $field) {
                $row->$field = $entity->$property;
            }            
            $id = $row->save();
            
            $entity->setId($id);
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
        }
    }
    
    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#save($entity)
     */
    public function save(Tight_Model_Entity $entity)
    {        
        // entité = parent du proxy
        $entityStr = get_class($entity);
        
        $map = $this->getTemplate()->getEntityMapping($entityStr);
        
        try {                                 
            $table = new Zend_Db_Table($map['table']);
            $table->setOptions(array('primary' => $map['id']));
            
            $row = $table->find($entity->getId())->current();
            foreach ($map['fieldMap'] as $property => $field) {
                $row->$field = $entity->$property;
            }            
            $row->save();
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
        }
    } 
    
    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#delete($entity)
     */
       public function delete(Tight_Model_Entity $entity) {
           // entité = parent du proxy
        $entityStr = get_class($entity);
        
        $map = $this->getTemplate()->getEntityMapping($entityStr);
        
        try {                                 
            $table = new Zend_Db_Table($map['table']);            
            $primary = $map['id'];
            $table->setOptions(array('primary' => $primary));
            $row = $table->find($entity->getId())->current();
            $row->delete();
            return true;    
        }
        catch(Exception $e) {
            throw new Exception ($e->getMessage());
            return false;
        }
       }

    /**     
     * @see library/Tight/Model/Tight_Model_IMapper#buildEntity($row, $entity)
     */    
    public function buildEntity($row, $entity)
    {
        $map = $this->getTemplate()->getEntityMapping($entity);
    
        try { 
            $entry = new $entity();
            
            $id = null;            
            if (is_array($map['id'])) {                
                foreach($map['id'] as $k => $v) {
                    if (isset($row->$v)) {
                        if (!is_array($id)) {
                            $id = array();
                        }                                               
                        array_push($id, $row->$v);
                    }
                }                    
            }
            else {                
                $idField = $map['id'];
                if (isset($row->$idField)) {
                    $id = $row->$idField;
                }
            }
            
            $entry->id = $id;
            
            foreach ($map['fieldMap'] as $k => $v) {
                if (isset($row->$v)) {
                    $entry->$k = $row->$v;
                }                                      
            }
        }
        catch(Exception $e) {
            throw new Exception ($e->getCode() . ' : ' .$e->getMessage());
        } 

        return $entry;
    }
}

$ret = $service->action();
if ($ret === false) {
$service->getMessages();
}