Zend FR

<?php #coding: utf-8
// Step 1: APPLICATION CONSTANTS - Set the constants to use in this application.
// These constants are accessible throughout the application, even in ini
// files. We optionally set APPLICATION_PATH here in case our entry point
// isn't index.php (e.g., if required from our test suite or a script).
require_once 'constant.inc.php';


/**
 * bootstrap ancêtre
 * @todo à partir de ZF 1.10, faire hériter de Zend_Application_Bootstrap_Bootstrap
 * @package exposehome
 * @subpackage kernel
 * @category bootstrap
 * @author ECAROT
 *
 */
abstract class Bootstrap
{
    /**
     * @var Zend_Controller_Front
     */
    protected static $_frontController = null;

    /**
     * @var Zend_Registry
     */
    protected static $_registry = null;

    /**
     * mise en place d'un système de cache
     * @access private
     */
    protected static function _setupCache()
    {
       /* if (! is_dir(GRC_TEMP_DIR)) {
            mkdir(GRC_TEMP_DIR);
        }


        self::$_registry->set('cache', $cache);*/
    }

    /**
     * Set up autoloading
     */
    static protected function _autoload()
    {
        require_once 'Zend/Loader/Autoloader.php';
        $autoloader = Zend_Loader_Autoloader::getInstance();
        $autoloader->setFallbackAutoloader(true);

        //Configure l'autoload pour inclure le module portail_citoyen et le module portail_accueil

        new Zend_Application_Module_Autoloader(
            array(
                'namespace' => 'Portaildta_',
                'basePath'  => dirname(__FILE__) . '/modules/portaildta',
                'resourceTypes' => array(
                    'library' => array(
                        'path'      => 'library/',
                        'namespace' => 'Library'
                    ),
                    'models' => array(
                        'path'      => 'models/',
                        'namespace' => 'Model' /* sans 's' */
                    )
                )
            )
        );
    }


    /**
     * @param string $config_file_path
     * @param string $section
     * @access private
     * @return Zend_Config_Ini
     */
    protected static function _setupConfig($configFilePath, $section)
    {
        // CONFIGURATION - Setup the configuration object
        // The Zend_Config_Ini component will parse the ini file, and resolve all of
        // the values for the given section.  Here we will be using the section name
        // that corresponds to the APP's Environment
        return new Zend_Config_Ini($configFilePath, $section);
    }

    /**
     *
     */
    /*protected static function _setupDatabase()
    {
        $db = Zend_Db::factory(Zend_Registry::get('configuration')->database);
        Zend_Db_Table::setDefaultAdapter($db);

        //$db = Zend_Db::factory($configuration->database);
        //Zend_Db_Table_Abstract::setDefaultAdapter($db);
        //self::$_registry->set('dbAdapter', $db);
    }
    */


    /**
     * mise en place de la "ZFDebug toolbar"
     */
    protected static function _setupDebug()
    {
        // seulement si on est en mode "development"
        if (APPLICATION_ENV != 'development') {
            return;
        }

        // et seulement si on n'est pas sous IE
        // (car message d'erreur javascript si on est sous IE)
        $req = new Zend_Controller_Request_Http();
        $ua = $req->getServer('HTTP_USER_AGENT');
        unset($req);
        // NB : possible d'utiliser $browser = get_browser(null, true); mais nécessite un browscap.ini
        if ((strpos($ua, 'Chrome') === false)
            and (strpos($ua, 'Firefox') === false)
            and (strpos($ua, 'Opera') === false)) {
            return;
        }

        // toutes les conditions sont réunies, mise en place de la toolbar
        $options = array(
            'jquery_path' => '/js/jquery.js',
            'plugins' => array(
                'Variables',
                'Html',
                 /*'Database' => array('adapter' => array('standard' => $db)),*/
                   'File' => array('basePath' => APPLICATION_PATH),
                   'Memory',
                   'Time',
                   'Registry',
                   /*'Cache' => array('backend' => $cache->getBackend()), */
                   'Exception'
            )
        );

        $debugBar = new ZFDebug_Controller_Plugin_Debug($options);
        self::$_frontController->registerPlugin($debugBar);
    }

    /**
     * démarrage du MVC
     * @param $configuration Zend_Config_Ini
     * @access private
     */
    protected static function _setupLayout($configuration)
    {
        //$layout_path['pluginClass'] = 'WinWinweb_Layout_Controller_Plugin_Layout';
        Zend_Layout::startMvc($configuration);
    }

    /**
     * définit le système de log
     * @param string $file
     */
    protected static function _setupLogger($file)
    {
        $logger = new Zend_Log();
        // pour déraciner le log (écrire nulle part):
        //$logger->addWriter(new Zend_Log_Writer_Null());
        //$logger->addWriter(new Zend_Log_Writer_Firebug());
        $logger->addWriter(new Zend_Log_Writer_Stream($file));

        // choix du niveau de debuggage
        $logLevel = intval(Zend_Registry::get('configuration')->logLevel);
        $logger->addFilter(new Zend_Log_Filter_Priority($logLevel));
        /*
        EMERG  0 : Urgence : le système est inutilisable
        ALERT  1 : Alerte: une mesure corrective doit être prise immédiatement
        CRIT   2 : Critique : états critiques
        ERR    3 : Erreur: états d'erreur
        WARN   4 : Avertissement: états d'avertissement
        NOTICE 5 : Notice: normal mais état significatif
        INFO   6 : Information: messages d'informations
        DEBUG  7 : Debug: messages de déboguages
        */
        //$log->setEventItem('Memory used', memory_get_usage());
        self::$_registry->set('logger', $logger);
        unset($logger);
    }

    /**
     * mise en place de l'environnement nécessaire à l'exécution
     * @access private
     */
    protected static function _setupRegistry()
    {
        self::$_registry = Zend_Registry::getInstance();
    }

    /**
     * mise en place des routes
     * @access private
     */
    protected static function _setupRoute()
    {
        /* @var $router Zend_Controller_Router_Rewrite */
        $router = self::$_frontController->getRouter();
    }
}

<?php #coding: utf-8
require_once APPLICATION_PATH . '/Bootstrap.php';

/**
 *
 * @package portailDTA
 * @subpackage kernel
 * @category bootstrap
 * @author ECAROT
 *
 */
class bootstrapPortaildta extends Bootstrap
{
    static public function run()
    {
        //self::setupEnvironment();

        self::_prepare();

        try {

            // mettre cette ligne pour que ErrorController fasse son job
            // si cette ligne est commentée, c'est le catch ci-dessous qui sera fait
            self::$_frontController->throwExceptions(false);

            // Dispatch the request using the front controller.
            // The front controller is a singleton, and should be setup by now. We
            // will grab an instance and call dispatch() on it, which dispatches the
            // current request.
            self::$_frontController->dispatch();

        } catch(Exception $exception) {

            echo $exception->getMessage();
            
            echo "<html><body><center>"
                   . "Une exeption a été soulevé par le bootstrap de l'application.";
            if (defined('APPLICATION_ENV')
                && APPLICATION_ENV != 'production'
            ) {
                echo "<br /><br />" . $exception->getMessage() . "<br />"
                   . "<div align='left'>Trace pile d'execution:"
                   . "<pre>" . $exception->getTraceAsString() . "</pre></div>";
            }
            echo '</center></body></html>';
            exit(1);
        }

    }

    /**
     * minimum syndical pour lancer des tests unitaires sur des objets de l'application
     */
    static public function runForUnitTests()
    {
        self::_prepare();
    }

    /**
     *
     */
    protected static function _prepare()
    {
        parent::_autoload();

        //Config du registry
        parent::_setupRegistry();

        //Config du fichier de config :)
        /* @var $config Zend_Config_Ini */
        $iniConfig = parent::_setupConfig(APPLICATION_PATH . '/config/config.ini', APPLICATION_ENV);
        parent::$_registry->set('configuration', $iniConfig);

        //Mise en place du controller principal
        self::_setupFrontController(
            array(
                //'default'     => APPLICATION_PATH . '/modules/portailexposehome/controllers',
                'portaildta' => APPLICATION_PATH . '/modules/portaildta/controllers'
            )
        );


        //Mise en place des routes
        parent::_setupRoute();

        //Mise en place du layout
        /* @var $config Zend_Config_Ini */
        $config = new Zend_Config_Ini(APPLICATION_PATH . '/config/config.ini', 'layoutPortailDta');
        parent::_setupLayout($config);
        unset($config);

        parent::_setupDebug();
    }

    /**
     *
     * @param unknown_type $controllersPath
     */
    protected static function _setupFrontController($controllersPath)
    {
        // FRONT CONTROLLER - Get the front controller.
        // The Zend_Front_Controller class implements the Singleton pattern, which is a
        // design pattern used to ensure there is only one instance of
        // Zend_Front_Controller created on each request.

        self::$_frontController = Zend_Controller_Front::getInstance();
        //self::$_frontController->setRequest(new Zend_Controller_Request_Http());
        self::$_frontController->throwExceptions(true);
        //self::$_frontController->returnResponse(true);

        // CONTROLLER DIRECTORY SETUP - Point the front controller to your action
        // controller directory.
        self::$_frontController->setControllerDirectory($controllersPath);

        self::$_frontController->setDefaultModule('portaildta');
        self::$_frontController->setDefaultControllerName('index');
        self::$_frontController->setDefaultAction('test');

        //self::$_frontController->setParam('registry', self::$_registry);
        self::$_frontController->setParam('context', 'portaildta');

        // APPLICATION ENVIRONMENT - Set the current environment.
        self::$_frontController->setParam('env', APPLICATION_ENV);

    }
}

<?php
/**
 * loader de l'appli dta
 *
 *
 * @package dta
 * @subpackage kernel
 */
define('APPLICATION_PATH', realpath(dirname(__FILE__) . '/../../application/'));

set_include_path(
    realpath(APPLICATION_PATH . '/../library')
    . PATH_SEPARATOR .
    realpath(APPLICATION_PATH . '/models')
    . PATH_SEPARATOR .
    get_include_path()
);

// Define application environment
// voir le virtual host, pour mettre par exemple :
// SetEnv APPLICATION_ENV development
// s'il n'y en a pas, alors la ligne ci-dessous sera prise en compte
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV', (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV') : 'production'));


require_once APPLICATION_PATH . '/Bootstrapdta.php';

bootstrapPortaildta::run();

<?php
class Model_Personne extends Zend_Db_Table {
    protected $_name = 'PERSONNE';
    
    private function getPersonnesAll() {
        return $this->fetchAll()->toArray();
    }

    private function getPersonneNom($name = '') {
        return $this->fetchAll()->toArray(array('nom_personne = ?'=> $name));
    }
}

<?php
class IndexController extends Zend_Controller_Action
{
    public function init() {
        $this->view->headTitle('Socialisme Citoyen');
    }
     
    public function testAction()
    {
        /*$loader = Zend_Loader_Autoloader::getInstance();
        die( print_r( $loader->getAutoloaders() ));*/
        $model = new Model_Personne();
        $this->view->test = "ESSAI 1";
    }
}