Tag Archives

5 Articles
Développement Android sous Netbean

Développement Android sous Netbean

by Throrïn 3 Comments

Pour mes tutos de la rentrée, je vais commencer simplement avec le passage à un nouvel IDE : Netbean. Comme Eclipse, Netbean est un IDE codé en Java, permettant de développer sous différents langages (PHP, C/C++, Java, …), et pouvant être enrichi grâce à des extensions (intégration Subversion, …).

Aujourd’hui nous allons voir comment développer sous Android avec Netbean. Comme certains le savent, Google fournit une extension Android que pour Eclipse et, malheureusement, elle a tendance à planter sous Eclipse Helios (dernière version).

Heureusement pour nous, un plugin non officiel, mais fonctionnel, a été fait pour Netbean et, je dois bien l’avouer, il semble être assez bien réussit.

Je ne l’ai pas testé dans sa globalité mais il me semble correct. Après à vous de voir. Mais, avant de commencer, vous devrez télécharger Netbean. Je vous conseille de prendre la version contenant les différents langages ainsi que les serveurs glassfish et Apache tomcat.

Dans l’ensemble Netbean fonctionne comme Eclipse, autocompletion, ajout de library java/PHP, … mais, et c’est là son point fort, il s’avère être beaucoup plus léger et rapide. Ensuite, n’oubliez pas de vous procurer le SDK Android, d’installer les différentes versions disponibles, et de créer une machine virtuelle Android.

Bien, maintenant que tout cela est en place, nous allons nous attarder à l’installation du plugin. Pour se faire, nous allons enregistrer un nouveau dépôt dans Netbean. Pour se faire, il suffit d’aller dans Outils -> Plugins. Si vous n’avez que plugins et Options, profitez-en pour activer les plugins PHP et Java SE (figure 1).

Ensuite, allez dans le dernier onglet () et choisissez d’ajouter un dépôt. Là, entrez l’adresse suivante, puis validez (figure 2) :
http://kenai.com/projects/nbandroid/downloads/download/updatecenter/updates.xml

Maintenant, il ne vous reste plus qu’à installer le plugin. Pour se faire, allez dans l’onglet Plug-ins disponibles et sélectionnez Android puis installez (figure 3).

Bien, il ne nous reste plus qu’à ajouter les différentes ressources Java d’Android dans Netbean et le tour est joué. Pour se faire, nous allons aller dans Outils -> Java Platforms -> ajouter une plateforme. Puis sélectionnez Google Android Handheld Platform (figure 4).

Pour finir, pointez le SDK et sélectionnez la version à ajouter. Personnellement, j’enregistre chaque version d’Android (figure 5).

Voilà. Maintenant il ne vous reste plus qu’à créer un projet Android. Vous pourrez constater que l’arborescence diffère d’Eclipse (figure 6). Pour lancer votre application, il vous suffit juste d’appuyer sur la touche F6 et une machine virtuelle Android se lance (figure 7).

Maintenant vous pouvez développer convenablement sous Netbean. Je n’ai malheureusement pas eu le temps de tester le debuggeur. Si vous avez un problème, n’hésitez pas à demander.

Introduction au Framework Zend – Partie 4

Chose promise, chose due, malgré une semaine de retard, je vous offre la suite du tutoriel Zend sur la création d’un blog. Aujourd’hui, il va s’agir de la partie authentification de l’administrateur.

Je vais donc commencer par vous montrer la création d’un nouveau module (module admin). Ensuite je vais vous montrer la création d’un formulaire avec Zend (il faut bien vous identifier quelque part non ?) et pour finir, nous allons entrer dans les détails de l’authentification par base de données.

Tout d’abord, reprenez le projet concernant cette suite de sujets et créez le module admin basée sur la structure montrée lors du précédent sujet (organisation des dossiers). Pour qu’un module autre que default marche, il faut lui créer un bootstrap de module permettant de charger ses models, ses formulaires et surtout ses contrôleurs.

Comme vous pouvez le voir, toutes les classes du module admin commencent par le Namespace Admin_, ceci est normal et permet à Zend de trouver facilement vos classes. Si vous oubliez cette information, Zend vous retournera une erreur comme quoi il ne trouve pas vos classes. Faites donc attention.
Dans le Bootstrap aussi vous devez renseigner le Namespace utilisé. Si il diffère de celui renseigné au début du nom de vos classes, vous aurez le droit à la même erreur.

/application/modules/admin/Bootstrap.php :

class Admin_Bootstrap extends Zend_Application_Module_Bootstrap
{  
    protected function _initAutoload()
    {
        $moduleLoader = new Zend_Application_Module_Autoloader(array(
            'namespace' => 'Admin_',
            'basePath'  => APPLICATION_PATH . '/modules/admin'));
        $moduleLoader->addResourceType('Models', 'models', 'Models');
        $moduleLoader->addResourceType('Forms', 'forms', 'Forms');
        return $moduleLoader;
    }
}

Afin de tester si notre module marche bien, nous allons ajouter l’IndexController et la vue associée à l’indexAction : /application/modules/admin/controllers/IndexController.php

class Admin_IndexController extends Zend_Controller_Action 
{
    public function indexAction() {
        $this->view->title="Authentification utilisateur";
    }
}

/application/modules/admin/views/scripts/index/index.phtml

<h3>Authentification</h3>

Normalement, si vous tapez http://localhost/tutosite.com/admin, vous devriez tomber sur La page suivante :

Je vous dis félicitation, vous venez de créer votre premier module pour le site. Maintenant, nous allons nous attaquer à quelque-chose de plus dur. La création du formulaire d’authentification.

Il faut savoir que dans la classe Zend_form, un élément comprend la légende et l’élément input. On peut aussi rajouter certains filtres et des validateurs pour automatiser des traitements rébarbatifs en PHP (combien ont fait des tests sur des $_POST).

Pour l’authentification, je prends les deux champs traditionnels : Login et Password. Le login ne sera pas une adresse E-Mail mais un pseudo. Je vous le dis pour le choix des validateurs. Si vous choisissez un e-mail, vous pouvez rajouter un validateur d’adresse e-mail qui accepte vos infos si et seulement si votre email a une structure valide (a@a.a). Vous pouvez aller plus loin en vérifiant que le nom de domaine existe bien (hotmail.com validé alors qu’azdfes.azdf est refusé).

Je vais donc vous montrer la classe formulaire que j’utilise sans trop rentrer dans les détails. La documentation explique beaucoup mieux que moi. Je vous expliquerais juste l’utilité des filtres et des validateurs que j’utilise.

/application/modules/admin/forms/Identification.php

class Admin_Forms_Identification extends Zend_Form 
{ 
    public function init()
    {
        $this ->setMethod('post')
              ->setName('identification'); 

        $login = new Zend_Form_Element_Text('login');
        $login ->setLabel('Identifiant')
               ->setRequired(TRUE)
               ->addFilters(array('StringTrim', 'StripTags'))
               ->addValidators(array( array('validator' => 'StringLength', 'options' => array(0, 20))))
               ->getDecorator('label')->setOption('tag', null);

        $passwd = new Zend_Form_Element_Password('password');
        $passwd ->setLabel('Mot de Passe')
                ->setRequired(TRUE)
                ->addFilters(array('StringTrim', 'StripTags'))
                ->addValidators(array( array('validator' => 'StringLength', 'options' => array(0, 20))))
                ->getDecorator('label')->setOption('tag', null);

        $submit = new Zend_Form_Element_Submit('submit');
        $submit ->setLabel('Connexion')
                ->setIgnore(true);

        $this->addElement($login);
        $this->addElement($passwd);
        $this->addElement($submit);

        $this->setDecorators(array(
            array('ViewScript', array('viewScript' => 'identification.phtml'))
        ));
    }
}

Tout d’abord, les filtres que j’utilise servent à limiter la casse et les injections de code (même si Zend ne permet pas ce genre de choses. Striptags permet d’enlever de notre variable toutes les balises de code afin d’éviter les injections JavaScript par exemple. Le filtre StringTrim quand à lui permet de supprimer les espaces en trop en début et en fin de notre variable afin de ne pas tricher sur le nombre de caractères requis. Ensuite le validateur StringLength quand à lui permet de définir le nombre min/max de caractères requis pour valider le formulaire.

Pour les décorateurs, j’ai décidé de passer par une vue externe afin de définir ma propre présentation. Cela permet une meilleure flexibilité de présentation e nos formulaires. Je trouve que les décorateurs sont trop complexes et limités mais en même temps, je suis nul avec. Pour pouvoir faire ce que je veux, j’ai donc désactivé les balises mises par défaut autour de notre élément.

Comme je vous l’ai expliqué, j’utilise un script de vue pour mettre en forme mon formulaire. Je vous le fournis bien entendu pour que vous puissiez voir comment cela marche.

/application/modules/admin/views/scripts/identification.phtml

<form action="<?php echo $this->escape($this->element->getAction()); ?>"         
      method="<?php echo $this->escape($this->element->getMethod()); ?>"         
      class="formident">         

    <p>Vous devez vous identifier pour accéder au backoffice.</p>        
    <div>        
        <span class="labelform"><?php echo $this->element->login->renderLabel(); ?></span>       
        <span><?php echo $this->element->login->renderViewHelper(); ?></span>        
    </div>       
    <div>        
        <span class="labelform"><?php echo $this->element->password->renderLabel(); ?></span>        
        <span><?php echo $this->element->password->renderViewHelper(); ?></span>         
    </div>       
    <?php echo $this->element->submit->renderViewHelper(); ?>                
</form>

Pour pouvoir afficher notre vue, nous ajoutons juste ces lignes pour le moment dans notre contrôleur :

$form = new Admin_Forms_Identification();
$this->view->form = $form;
$this->view->message = null;

Et dans notre vue, juste ces ligne :

<?php 
    if(!empty($this->message))
    {
?>
<div class="warning"><?php echo $this->message; ?></div>
<?php  
    }
    $this->form->setAction($this->url());
    echo $this->form;
    echo md5(azerty);

Voici le rendu final de notre vue :

En ajoutant le code css suivant à notre style, nous pouvons obtenir le résultat suivant :

/**
 * Formulaire authentification
 */
.formident{
    text-align: center;
}
.formident div{
    margin-top: 3px;
    margin-bottom: 3px;
    position: relative;
    width: 300px;
    margin-left: 330px;
} 
.formident div .labelform{
    width: 100px;
    display:block;
    float: left;
    text-align: left;
}

Alors ? Ce n’est pas sympa ce que l’on peut faire ? Nous pouvons aussi rajouter des images et des effets visuels sympas, mais ce n’est pas le but de cet article.

Bien, maintenant nous pouvons enfin attaquer le vif du sujet : L’authentification.

Comme je vous l’ai expliqué, nous allons authentifier notre utilisateur par une base de données. Je vais donc vous fournir le script de la base avec la table utilisateur. Je vais me baser dessus pour tous les autres articles du tutoriel.

CREATE DATABASE `tutosite` DEFAULT CHARACTER SET latin1 COLLATE latin1_swedish_ci;
USE `tutosite`;
CREATE TABLE IF NOT EXISTS `utilisateurs` (
    `idutilisateur` int(11) NOT NULL AUTO_INCREMENT,
    `login` varchar(50) NOT NULL,
    `passwd` varchar(100) NOT NULL,
PRIMARY KEY (`idutilisateur`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

Bien évidemment, nous devons toucher les fichiers de configuration Zend pour pouvoir nous connecter à la base de donnée :

; Base de donnée
resources.db.adapter = PDO_MYSQL
resources.db.params.charset = UTF8
resources.db.params.host = localhost
resources.db.params.username = root
resources.db.params.password = passwd
resources.db.params.dbname = tutosite
resources.db.isDefaultTableAdapter = true

Voilà, maintenant que la connexion à la base de données fonctionne, voici les étapes à rajouter dans l’indexController->indexAction() pour s’identifier. J’ai commenté chaque ligne afin que vous ayez directement les explications :

if($this->_request->isPost())
{
    //on récupère le login
    $username = $this->_request->getPost('login');
    //on récupère le password  
    $password = $this->_request->getPost('password'); 

    if (empty($username)) 
    {
        $this->view->message = 'Veuillez saisir un identifiant';
    } 
    else
    {
        //on récupère la connexion à la base de donnée
        $dbAdapter = Zend_Db_Table::getDefaultAdapter();
        //récupération de l'adaptateur dbAdapter 
        $authAdapter = new Zend_Auth_Adapter_DbTable($dbAdapter);
        //on indique le nom de la table 
        $authAdapter->setTableName('utilisateurs'); 
        //on indique la colonne du login 
        $authAdapter->setIdentityColumn('login');
        //on indique la colonne du mot de passe 
        $authAdapter->setCredentialColumn('passwd');
        //on dit que les mots de passes sont hashés en MD5
        $authAdapter->setCredentialTreatment('MD5(?)'); 

        //ajout des données du formulaire pour l'authentification
        $authAdapter->setIdentity($username);
        $authAdapter->setCredential($password);

        //lancement de l'authentification
        $auth = Zend_Auth::getInstance()->setStorage(new Zend_Auth_Storage_Session('admin'));
        $result = $auth->authenticate($authAdapter);

        if ($result->isValid()) 
        {
            //succès: on stoque dans un objet sessions toutes les infos de la ligne
            //de la table sauf le mot de passe pour des raisons de sécurité.
            $data = $authAdapter->getResultRowObject(null, 'password');
            $auth->getStorage()->write($data);
            //on redirige vers notre page admin
            $this->_redirect('/admin/accueil');
        } 
        else 
        {
            //failure: clear database row from session
            $this->view->message = "Echec de l'identification";
        } 
    }
}

Avant de tester ceci, sachez que nous allons être redirigés vers un nouveau contrôleur du module admin. Pour éviter à quelqu’un de non authentifié d’accéder à ce contrôleur, j’initialise la fonction preDispatch() qui permet d’effectuer des réglages avant la fin de l’initialisation du contrôleur.
/application/modules/admin/controllers/AccueilController.php :

class Admin_AccueilController extends Zend_Controller_Action 
{ 
    public function preDispatch()
    {
        $auth = Zend_Auth::getInstance()->setStorage(new Zend_Auth_Storage_Session('admin'));

        if (!$auth->hasIdentity()) {
            $this->_redirect('/admin/index');
        }
    }

    /**
     * The default action - show the home page
     */
    public function indexAction() 
    {
        $this->view->title = "Partie Administration - Accueil";
    }
}

/application/modules/admin/views/scripts/accueil/index.phtml

Partie Admin, vous êtes authentifiés.</code> Maintenant votre authentification est optionnelle. 

Pour vous déconnecter, il suffit de faire un lien vers l’action déconnexion de l’IndexController par exemple et qui serait comme ceci :

public function logoutAction()
{
    Zend_Auth::getInstance()->setStorage(new Zend_Auth_Storage_Session('admin'))->clearIdentity();
    $this->_redirect('/admin/index');
}

Pour éviter de tomber sur le formulaire d’identification, vous pouvez rajouter ceci autour de toutes les lignes de codes d’indexAction() afin d’arriver directement sur l’accueil admin :

$ident = Zend_Auth::getInstance()->setStorage(new Zend_Auth_Storage_Session('admin'))->getIdentity(); 
if($ident){
    $this->_redirect('/admin/accueil');
}else{
    //code authentification
}
Pour les mots de passe créez une page php de base avec juste un echo md5(‘motdepasse’) ; et après insérez votre nouvel utilisateur avec, comme mot de passe, celui qui vient d’être généré.

Voilà. Maintenant vous pouvez vous authentifier et rajouter d’autres utilisateurs à votre base de données. La prochaine fois, nous verrons les classes métiers et table_abstract pour ajouter nos premiers articles.

Introduction au Framework Zend – Partie 3

Comme promis, voici la suite du tutoriel mais, avant de vous faire l’intégration du Layout, j’aimerais corriger un oubli et pas n’importe lequel car, il est de taille.

J’ai oublié de vous parler de l’ErrorController. Ce contrôleur, d’une importance cruciale, sert à capturer toutes les erreurs Apache que génère votre projet. Il n’existe qu’un seul contrôleur d’erreur pour tout le site et il se trouve dans le module default. Je vais donc vous passer le controller officiel.

Certains le personnalisent afin d’avoir des informations supplémentaires et des fonctions de plus (ajout dans un log, …).

/application/modules/default/controllers/ErrorController.php :

class ErrorController extends Zend_Controller_Action
{
    public function errorAction()
    {
        $errors = $this->_getParam('error_handler');

        switch ($errors->type) { 
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
            case Zend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
                // 404 error -- controller or action not found
                $this->view->title = "Erreur 404: Page non trouvée";
                $this->getResponse()->setHttpResponseCode(404);
                $this->view->message = 'Erreur 404 : Page non trouvée';
                break;
            default:
                // application error 
                $this->view->title = "Erreur 500 : Problème d'Application";
                $this->getResponse()->setHttpResponseCode(500);
                $this->view->message = "Erreur 500 : Problème d'Application";
                break;
        } 
        $this->view->exception = $errors->exception;
        $this->view->request   = $errors->request;
    }
}

Et la vue associée /application/modules/default/views/scripts/error/error.phtml :

<h1>Une erreur est apparue</h1> 
<h2><?php echo $this->message; ?></h2> 

<h3>Exception information:</h3> 
<p>
    <b>Message:</b> 
    <?php echo $this->exception->getMessage(); ?> 
</p> 
<h3>Stack trace:</h3> 
<pre>
    <?php echo $this->exception->getTraceAsString(); ?> 
</pre> 
<h3>Request Parameters:</h3> 
<pre>
    <?php var_dump($this->request->getParams()); ?> 
</pre>

Comme ceci, nous aurons plus de facilité pour débugger notre application en cas d’erreur. Bien, maintenant que cet oubli est réparé, nous allons pouvoir commencer à nous occuper du Layout.

Pour cette partie sachez que nous aurons un nouveau dossier. Le dossier application/layouts qui contiendra tous nos fichiers composant la structure du site. J’ai pour habitude de séparer le header, footer et structure globale afin de me faciliter les parties de maintenance du site.

La partie CSS sera stockée dans le dossier /public/styles, la partie JS sera stockée dans /public/scripts et les images du site seront stockées dans /public/images.

Tout d’abord, vous voudrez peut-être voir le rendu final du layout, le voici :

Ensuite je vous passe le CSS : /public/styles/styleprincipal.css

a{
    text-decoration: none;
    color: #FFFFFF;
}
a:visited{}
a:hover{
    color: #724C2A;
}
input{
    border: 1px solid #4083A4;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    color: #0A0A0A;
}
#page{
    width: 950px;
    margin-left: auto;
    margin-right: auto;
    overflow: auto;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    border: 1px solid #4083A4;
    text-align: left;
}
#header{
    background-color: #4083A4;
    color: #FDFDFD;
    text-align: center;
    padding-top: 40px;
    font-size: 25px;
    height: 105px;
}
#liensheader{
    background-color: #4083A4;
    font-size: 15px;
    padding-bottom: 5px;
    color: #FDFDFD;
}
#liensheader span
{
    margin-left: 15px;
}
#contenu
{
    overflow: hidden;
    padding-left: 10px;
    padding-right: 10px;
    padding-top: 5px;
    padding-bottom: 15px;
    font-size: 12px;
    font-family:Arial, Helvetica, sans-serif;
    position: relative;
}
#contenu a{
    text-decoration: none;
    color: #000000;
}
#contenu a:visited{}
#contenu a:hover{
    color: #724C2A;
}
#piedpage{
    padding-top: 5px;
    padding-bottom: 5px;
    text-align: center;
    border-top: 1px solid #4083A4;
}

Pour finir voici le Layout composé des fichiers : /application/layouts/layout.phtml

<?php echo '<?xml version="1.0" encoding="UTF-8"?>'; ?>
<html xmlns="http://www.w3.org/1999/xhtml">
    <body>
        <div id="page">
            <?php echo $this->partial('header.phtml'); ?>
            <div id="contenu">
                <?php 
                    //cette fonction permet de récupérer la vue de l'action appelée
                    echo $this->layout()->content; 
                ?>
            </div>
            <div id="piedpage">
                Ignoti posticas pervadendoque vero pervadendoque.
            </div>
        </div>
    </body>
</html>

/application/layouts/meta.phtml

<meta http-equiv="Content-Type" content="text/html; charset=utf-8" /></code> 

/application/layouts/styles.phtml

<link rel="stylesheet" type="text/css" href="<?php echo $this->BaseUrl(); ?>/styles/styleprincipal.css" />

/application/layouts/header.phtml

<div id="header">Tutoriel ZF</div>
<div id="liensheader">
    <a href="#"><span>Accueil</span></a>
    <a href="#"><span>Identifiez-vous</span></a>
</div>
Le fichier /application/layouts/scripts.phtml est vide car il n’y a pas encore de fichiers Javascripts. Quand à la fonction $this->BaseUrl(); elle retourne le répertoire de base du site. Ici il retournera /tutosite.com. Cela permet à Zend de savoir qu’il faut chercher ces fichiers dans le répertoire public et non dans les actions (sauf si vous avez créer des routes pour sa).

Après tout ceci, il ne nous reste plus qu’à rajouter les lignes suivantes dans le fichier /application/configurations/app.ini à la fin de la partie [production].

; ADD THE FOLLOWING LINES
resources.layout.layout = "layout"
resources.layout.layoutPath = APPLICATION_PATH "/layouts"

Maintenant, si vous allez sur le site http://localhost/tutosite.com, vous devriez tomber sur le même rendu que moi. Après, libre à vous d’en créer de nouveaux et pourquoi pas, de les faire partager ici. Si votre thème est vraiment bien fait, je pourrais l’intégrer pour la suite du tutoriel.

La semaine prochaine, nous allons commencer le module admin avec l’authentification à travers la base de données. Bon week-end à tous.

Introduction au Framework Zend – Partie 2

Aujourd’hui j’ai décidé de tout remanier mon introduction à Zend. Au lieu d’expliquer pas à pas le fonctionnement, je préfère vous faire réaliser de a à z un site simple ayant 2 modules, un module de blog et un module de commentaires. Nous verrons ensuite pour la création d’un flux RSS et pourquoi pas, le partage de vos articles sur twitter.

Tout d’abord, le programme d’aujourd’hui sera la mise en place de notre projet.

Nous allons donc prendre la structure modulaire expliquée dans l’introduction partie 1. Sachez que je fournis ce tutoriel pour une utilisation en local via WAMP, Zend Server, LAMP ou autres alternatives. Nous utiliserons la version 1.10.2 du framework.

Le site sera créé via un alias et le framework Zend sera présent dans le dossier library de notre site. Après, à vous de transformer selon vos préférences mais sachez qu’il n’y a pas trop de modifications à apporter.

Chez moi, le site aura pour allias « tutosite.com » qui pointe directement vers le dossier public, donc faites bien attention à comment c’est déclaré dans le .htaccess et dans votre config apache. Ensuite, pour les fichiers, je donne leur chemin à partir de la racine du projet donc faites attention.

L’introduction étant terminée, nous allons donc nous attarder sur les différents fichiers de config.

Tout d’abord, votre fichier /public/.htaccess :
php_value include_path "./../library/"

php_flag zlib.output_compression On

SetEnv APPLICATION_ENV development
# The rules below basically say that if the file exists in the tree, just
# serve it; otherwise, go to index.php. This is more future-proof for your
# site, because if you start adding more and more content types, you don't
# need to alter the .htaccess to accomodate them.
# This is an important concept for the Front Controller Pattern which the
# ZF MVC makes use of.
RewriteEngine On

RewriteCond %{REQUEST_FILENAME} -s [OR]
RewriteCond %{REQUEST_FILENAME} -l [OR]
RewriteCond %{REQUEST_FILENAME} -d
RewriteRule ^.*$ - [NC,L]
RewriteRule ^.*$ /tutosite.com/index.php [NC,L]

Ensuite, voici le fichier /public/index.php :
// Define path to application directory
defined('APPLICATION_PATH')
|| define('APPLICATION_PATH',
realpath(dirname(__FILE__) . '/../application'));

// Define application environment
defined('APPLICATION_ENV')
|| define('APPLICATION_ENV',
(getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
: 'production'));

// Typically, you will also want to add your library/ directory
// to the include_path, particularly if it contains your ZF install
set_include_path(implode(PATH_SEPARATOR, array(
dirname(dirname(__FILE__)) . '/library',
get_include_path(),
)));

require_once 'Zend/Loader/Autoloader.php';
$autoloader = Zend_Loader_Autoloader::getInstance();
$autoloader->setDefaultAutoloader(create_function('$class',
"include str_replace('_', '/', \$class) . '.php';"
));

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

// Create application, bootstrap, and run
$application = new Zend_Application(
APPLICATION_ENV,
APPLICATION_PATH . '/configurations/app.ini'
);
$application->bootstrap()
->run();

Nous allons faire le fichier /application/bootstrap.php avec les configurations de bases pour une application modulaire :
class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
{
public static function autoload($class)
{
include str_replace('_', '/', $class) . '.php';
return $class;
}

/**
* Fonction de chargement
*/
protected function _initAutoload()
{
//on configure le module par défaut avec son namespace, son chemin et les ressources associées
$moduleLoader = new Zend_Application_Module_Autoloader(array(
'namespace' => 'Default_',
'basePath' => APPLICATION_PATH . '/modules/default'));
$moduleLoader->addResourceType('Models', 'models', 'Models');
$moduleLoader->addResourceType('Forms', 'forms', 'Forms');
Zend_Session::start();
return $moduleLoader;
}

/**
* Fonction servant à initialiser la vue
*/
protected function _initView()
{
// Initialize view
$view = new Zend_View();
$view->doctype('XHTML1_STRICT');
$view->headMeta()->appendHttpEquiv('Content-Type',
'text/html; charset=utf-8');
$view->addHelperPath('App/View/Helper/', 'App_View_Helper');
Zend_View_Helper_PaginationControl::setDefaultViewPartial('pagination.phtml');
// Add it to the ViewRenderer
$viewRenderer = Zend_Controller_Action_HelperBroker::getStaticHelper('ViewRenderer');
$viewRenderer->setView($view);
//ZendX_JQuery_View_Helper_JQuery::enableNoConflictMode();
// Return it, so that it can be stored by the bootstrap
return $view;
}

protected function _initModifiedFrontController()
{
$this->bootstrap('FrontController');
$front = $this->getResource('FrontController');
$response = new Zend_Controller_Response_Http;
$response->setHeader('Content-Type','text/html; charset=UTF-8', true);
$front->setResponse($response);
}
}

Pareil pour le fichier /application/configurations/app.ini :
[production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1
includePaths.library = APPLICATION_PATH "/../library"
bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
bootstrap.class = "Bootstrap"

; Configuration de la gestion des modules
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"
resources.modules[] = ""

[development : production]
phpSettings.display_startup_errors = 1
phpSettings.display_errors = 1

Maintenant nous pouvons nous attaquer au dossier des modules. Nous allons créer notre module default qui lui nous servira à créer notre page d’accueil en fonction des différents autres modules.

La structure des modules est toujours comme sur l’image. Nous allons donc créer notre /application/modules/default/IndexController :

 

 

class IndexController extends Zend_Controller_Action {

public function indexAction() {

}

}
Et la vue associée /application/modules/default/views/scripts/index/index.ptml :

Normalement, à partir d’ici, nous devrions avoir notre projet d’opérationnel. Tapez-y l’adresse de notre projet qui doit être http://localhost/tutosite.com et nous devrions voir s’afficher un magnifique « hello world ».

La prochaine fois nous allons voir la création d’un Layout pour notre site.

Introduction au Framework Zend – Partie 1

Quelques personnes me demandent toujours des bouts de code afin de voir comment fonctionne le framework Zend, comment on fait pour avoir plusieurs controllers, modules, views, … Pourtant, la plupart des tutoriels fournis sur le site officiel et sur certains sites de développeurs sont amplement suffisants.

Je vais donc revenir pas à par sur le fonctionnement et l’organisation du framework. Bien entendu, la partie Bootstrap sera omise, vu qu’un sujet le traite déjà sur mon site. Vous trouverez cet article ici.

Tout d’abord, vous devez savoir que je préfère travailler en module. Chaque module gère un cas d’utilisation de mon site et me permet ainsi une meilleure portabilité et une meilleure gestion de ceux-ci.

Voici donc l’organisation typique de mes projets. (ici vous avez l’organisation d’un de mes sites).

A l’intérieur, il y a 3 dossiers principaux :

Application : ce dossier contient toute la partie développement du site.

Library : ce dossier, qui est l’un des plus importants, va contenir le framework Zend ainsi que des bibliothèques annexes (html2pdf par exemple). – Public : ce dossier va contenir tous les fichiers publics du site (images, fichiers à télécharger, styles CSS, scripts JS, …) ainsi que notre fichier d’amorçage et notre fichier .htaccess.

Revenons aux modules qui se trouvent être la partie qui nous intéresse ici. Le dossier module va contenir les dossiers de chaque modules (news, article, …) et chacun de ces dossiers contient les dossiers suivants :

controllers : contient chacun des controllers du module. – Forms : contient chacun des formulaires du module (choix perso). – Models : contient chacun des models du module (les abstract table). – Views : contient toutes les vues, aides de vues et paginations du module.

Jusque là, c’est assez simple. Sachez tout de même qu’un module nommé default est automatiquement créé, il s’agit du module contenant le controller et l’action d’accueil du site. Chose importante, toutes les classes contenues dans ce module n’ont pas besoin d’avoir Default_ en début de nom (voir ci-dessous) et ce module n’a pas besoin de bootstrap.

Chaque module a besoin d’une règle particulière pour bien fonctionner. En effet, le framework doit savoir à quel module correspond le controller et dans quel dossier il est stocké.

Pour le dossier controllers, rien de plus simple, votre controller doit se présenter de la façon suivante :
class Blog_IndexController extends Zend_Controller_Action {
}

Pour les models et les formulaures par contre, c’est de cette forme ci :
class Blog_Forms_Blog extends Zend_Form {
}

class Blog_Models_Tables_ArticleBlog extends Zend_Db_Table_Abstract{
}

Tout ceci afin de permettre au framework de trouver vos fichiers. Les « _ » sont remplacés en interne par le caractère de séparation de dossier donc si votre formulaire s’appelle Blog_Forms_Blog, il sera compris de cette forme par Zend : blog/forms/Blog.php

Pour le moment je ne vous ai fait que l’introduction au fonctionnement et à la mise en place d’un projet. D’ici quelques jours je parlerai du lien entre le controller et la vue et nous mettrons ensuite en place un Layout afin d’avoir l’apparence globale de nos sites.