Donc, après une petite nuit de sommeille et la maintenance quotidienne de mon taf, je peux rependre la suite de l'article sur ma vision d'une utilisation rapide d'un MVC :

4. un contrôleur text() :

Le but actuel de ce controler n'est autre que d'afficher un texte, mais comme tous controler, il a des fonctions communes avec les autres controler, il doit inclure une connexion Bdd, il doit avoir accès aux login des membres postant les messages (blog et forum), ... donc c'est une extension de la class controller()

class text extends controller {
 function __contruct($container){
   parent::__construct($container);
 }
 function affichTex($idtext){
   $r = $this->model->select('text', 'text', "id=$idtext");
   return (!isset($r[0][0])) ? false : $r[0][0];
 }
}

L'idéal pour nous est d'avoir une class text() la plus légère possible, et ici, c'est dur de faire plus lourd !! ;) Mais comment est-ce possible ? grâce à la classe mère controller() simplement !!

class controller {
 protected $model;
 protected $container;

 function __construct($container){
   $this->container = $container ;
// nous verrons par la suite pourquoi je tiens à conserver un accès au container
   $this->model = new model(MYSQL_BdCont);
 }
}

Ainsi, on uniformise les controler, chacuns étant une extention de la class controler(), utilise $this->model pour accèder au model ....

Nous de vons désormé contruire notre class model ... qui possède déja quelques fonctions, vous l'aurez remarquè !!

5. notre Model :

Nous savons qu'il prend en paramètre à la construction la variable globale contenant le nom de la base de donnée spécifiquement utilisée par l'élément (le container utilise 'Bdd_Auth', le controller utilise 'Bdd_Cont', ...)

Nous avons utilisé jusqu'à présent une seule fonction : select qui nous retourne un tableau array()

class model {
 protected connect = false;
 protected $sql;
 protected $Bdd;

 function __construct($bdd){
   $this->Bdd = $bdd;
   $this->dbConnect();
 }
 function dbConnect(){
   if(!$this->connect)$this->connect = @mysql_connect(MYSQL_HOST,MYSQL_USER,MYSQL_PASS);
   $this->Bdd = @mysql_select_db($this->Bdd,$this->connect);
 }
 /* nous allons donc faire notre fonction select() ... mais pour etre le plus ouvret possible, nous allons simplement dans select préparer la requete */
 function select($field, $table, $where='', $limit='', $order=''){//on pourrais en mettre d'autre ;)
   $str = "SELECT $field FROM `$table`";
   if (!empty($where)) $str .= " WHERE $where";
   if (!empty($limit)) $str .= " LIMIT $limit";
   if (!empty($order)) $str .= " ORDER BY $order";

/* notre requète étant désormée, mise en forme, il nous suffit de l'envyer à la base de donnée */
   $this->sql = $this->query($str);
   return $this->ArrayResponse();
 }
// commençons par la fonction query()
 function query($str){
   /* nous pouvons placer ici toutes les surveillance que nous souhaitons sur les requetes, elles arrivent toutes à un seul et unique endroit !! ici ...
      nous pouvons décider de stocker toutes les requetes dans un fichier log, ou faire un traitement particulier sur les requete select ou insert
      Mais je vais plutot m'en tenir au plus simple et vous laisser immaginer les protections à mettre en place ... */
   return @mysql_query($str);
 }

// notre fonction ArrayResponse() maintenant !
 function ArrayResponse(){
   if(!mysql_num_rows($this->sql)>=1)
     return array();
   $array = array();
   while($row = mysql_fetch_array($this->sql)){
     $array[count($array)] = $row ;
   }
   return $array;
 }
}

et voila ... Notre MVC est fait ! ... il ne nous reste plus qu'à créer des contrôleurs, les intégrer dans nos pages, et tout roule ...

Je vais maintenant approfondir la fonction container::viewer() en charge de présenter le rendu visuel à l'internaute

class container {
 /* ... */
 function viewer(){
   if(!this->design)return true; 

   /* rappelons que le controler incrémente container::containt et que nous devons placer :
    * un bandeau haut (contenant un formulaire d'identification),
    * un menu,
    * une zone de "contenu",
    * un bandeau vertical (pub),
    * et un bandeau bas (second menu).
   */

   $view = $this->head();
   $view .= $this->header();
   $view .= $this->menu();
   $view .= $this->Contenu();
   $view .= $this->bandeauRight();
   $view .= $this->footer();

   $this->containt = $view;
   return true ;
 }
 function head(){
   /* cette fonction va 
    * chercher dans notre container::model() les <meta> necessaires à l'affichage de la page demandée
    * générer les balise <style>, <script> et <link> on peux tout a fait imaginer que nos containers incrémentes des variables de sessions style :
    $_SESSION['script'] .= "var objJs = new Obj();"
    Ensuite, on la récupère ici, et la place dans une balise <script = text/javascript>
    * ... Bref, on retourne toute la balise <head> et bien évidemement de <!doctype>*/
 }
 function header(){
   // ici, on doit retourné notre bandeau et le formulaire d'identification / ou le login du membre
 }
 function menu(){
   // on retourne notre menu (avec si accès le lien vers l'admin)
 }
 function Contenu(){
   // on retourne la cellule contenant $this->containt (actuellement, c'est uniquement ce qui a été retourné par le controler ...
 }
 function BandeauRight(){
   // ici, nous n'avons pas besoin que ce soit référencé par les moteurs de recherches, donc nous allons retourner simplement notre script JS / ou notre JSon, pour gérer notre espace de pub
   // je ferais un tutos à ce propos dans le prochain mois .. il est en cours décriture ... ;)
 }
 function footer(){
   // si vous avez tout suivi jusqu'ici, il n'est pas necéssaire que j'aille plus loin ... vous avez compris ...
   return $footer.'</body></html>';
   // mais il ne faut pas oublier de fermer notre script xHTML ...
 }

/* ... */
}

Vous l'aurez compris, notre container est en réalité le View ... l'interface direct à laquelle l'internaute accède, qui appel le Controler en suivant les directives du Model Sachant que les controler sont tributaires, eux aussi du Model ...

Dans un prochain article, je pousserais plus loin certains détails, actuellements mis de coté comme l'intérêt d'inclure le container dans le controler en quelques mots : la Bdd gérant les login étant celle appelée par le Container, ceux ci ne sont pas accessible du model ni du controler pour ce faire, nous ajoutons à notre container la fonction getLogin()

class container{
 /* ... */
 function getLogin($id){
   $return = ''
   $r = $this->model->select('login', 'membres', "id=$id");
   if(!empty($r[0][0]))
     $return = $r[0][0];
   return $return;
 }
 /* ... */
}

Donc à l'appel de container::getLogin($id), nous récupérons le login, ou '' ... cette fonction devant etre accessible de tous les contrôlleurs, nous l'appellons depuis la class parent des contrôlleurs controller()

class Controller {
 /* ... */
 function __construct($container){
   $this->container = $container ;
   /* ... */
 }
 function getLogin($id){
   return $this->container->getLogin($id);
 }
 /* ... */
}

Comme vous le constatez, les possibilités ne peuvent être limitées avec une tels construction de script ....

Voilà, il ne me reste plus qu'à vous souhaitez de bien vous amuser !! et de vous priez de me laisser vos impression cette publication ... BonCode ;)

Nours312 ...