ORM Framework doc

Présentation

ORM Framework est un framework MVC orienté Webservices.
Il est modulaire à l'extrème, c'est à dire qu'il lui faut un minimum de dépendences pour pouvoir fonctionner.
Différents conceptes sont abordés dans cette doc.

Le principe de `core` et de `custom` est simple et efficace.

Le core

Le core contient le code du framework.
Il est déconseillé d'y toucher.

Le custome

Le custom est l'endroit où vous allez inserer votre code et où l'orm vas générer son code.
Vous pouvez créer vos propres services, vos propres configurations, vos propres vues, models, entitées et controlleurs.

Pour créer un service, rendez vous dans le répertoire custom/services,


<?php
    class MonService implements IService {
        public function __construct() {
            //TODO: Votre code ici
        }

        public function __invoke() {
            //TODO: Votre code ici
        }

        public function votre_methode_ici($mon_parametre1, $mon_parametre2 /*, $plus_de_parametres ...*/) {
            //TODO: Votre code ici
        }

        //TODO: Plus de méthodes ...
    }
                    
                

Pour utiliser mon service, il suffis de se placé dans la méthode qu'on veux dans un model ou une simple classe et ecrire le code suivant


<?php
    // ...
    $servicemanager = ServiceManager::instence();
    $monservice = $servicemanager('MonService', 'parametre');
    $monservice('votre_methode_ici', ['mon_parametre1', 'mon_parametre2' /*, 'plus_de_parametres' ...*/]);
    // ...
                    
                

Les annotations sont puissantes et simple d'utilisation.
À partir du moment ou on utilise une annotation dans une méthode, le module met ne nombre de paramètres de la méthode à 0 par défault.

Voici un exemple d'utilisation


<?php
    // ...
    Annotation::annote(
            $this,
            __METHOD__ /* obligatoire */,
            Annotation::$__HTTP_METHOD__ /* type d'annotation */,
            Annotation::$__COMMANDLINE__ /* valeur correspondant au type d'annotation */
    );
    Annotation::action($this, __METHOD__, $params /* paramètres de la methode courrante */,
            function($infos, $args, $annotation, $params) {
                // Votre code ici
            } /* , false */);
    // ...
                    
                
  • Une strate est l'ensemble de `Model`, `Controller`, `Entity`, et `Conf` correspondant à un nom en particulier.
    par exemple pour une strate nommée `HelloWorld`, on auras :
  • Un controller `C_HelloWorld`
  • Un model `M_HelloWorld`
  • Une entitée `E_HelloWorld`
  • Une conf `D_HelloWorld.cnf`
    ( À terme cette configuration sera comprise dans les annotations pour optimiser le nombre de fichiers )
Lorse que vous vous rendez dans un terminal et que vous tapez la commande :
php ormframework.php new strate `nom_de_la_strate`
Cette commande vous génèrera une strate qui portera le nom que vous avez passé en paramètre.
Vous n'aurez alors plus qu'à remplire le model à la main avec les méthodes que vous voulez y mettre.
Petit exemple de code générer :
  • Model

  • 
        <?php
            class M_ma_strate_generee extends Model {
                // Mettre mon code ici
            }
                            
  • Controller

  • 
        <?php
           class C_ma_strate_generee extends Controller {
               /* Ne pas toucher à ce code sauf si vous voulez changer le comportement du constructeur,
                  tout est déja dans la classe Controller */
           }
                            
  • Entity

  • 
        <?php
           class E_ma_strate_generee extends Entity {
                // Mettre mon code ici
           }
                            
  • Conf

  • 
        {
            "ma_premiere_methode": "nbr_de_parametres_minimum sous forme d'integer"
        }
                            
Pour supprimer une strate, il faut taper la ligne suivante dans le terminal :
php ormframework.php rm strate `nom_de_la_strate`
Pour supprimer plusieurs strates, il faut taper la ligne suivante dans le terminal :
php ormframework.php rm strates `nom_de_la_strate1` `nom_de_la_strate2` `nom_de_la_strate3`
On peux supprimer autant de strates qu'on veux en une commande.

Ce framework est modulaire.

Il est séparé en plusieurs modules qui sont chargés si activés.
Cette spécificité fait que les modules non utilisés ne sont pas chargés ce qui as pour conséquences de rendre son execution plus ou moins rapide selon le nombre de modules activés.

Voici les modules disponibles par défault :

  • interfaces
  • Les classes simples / setup : Voir la documentation
  • Mvc : où sont les strates
  • html_parser
  • emerode
  • dbcontext : Permet le code first ( En développement )
  • translating : module de traduction.
  • errors_pages : contient les classes qui gerent les pages d'erreurs selon le code de retour HTTP.
  • config : gère les configurations
  • services : contient les différents services du framework.
  • build_templates : Voué à disparêtre, ce module est destiné à la génération de l'installeur.
  • annotation : Voir la doumentationc
  • www / front : contient tout le front si il y en a un et la documentation

BIENTOT EN SERVICE

Pour le data-first c'est très simple.
Insérez vous infos de connection au serveur SQL dans le fichier mysql_datas.json qui est innaccessible de l'exterieur,
Puis vous n'avez qu'une commande à rentré dans le terminal :
php ormframework.php start orm `nom_de_la_base_de_donnes`
et tout le code permetant d'afficher une ou une liste d'entitées en json, ajouter une entité, supprimer une entité, et supprimer une entitée sera générer automatiquement.
Ensuite libre à vous de modifier les classe modifier pour les adapter à vos besoins.

Un exemple de strate générée est afficher dans la partie précédente sur Les strates

Les commandes sont un outil utilisé dans tous les framework.
En l'absence d'interface graphique, c'est le seule moyen de faire plusieurs actions en même temps sans toucher au code.
Elles vont nous être très utiles pour lancer l'ORM, ajouter ou supprimer une connection à la DB, activer ou desactiver un module, générer un installer ou autres.

Pour créer une nouvelle commande, il suffit de créer une classe qui hérite de la classe Commande dans le réprtoire Core/.Commandes
Qui se nome par le nom de la commande en remplaçant les espaces par les `_` et on supprime le `Commande` dans le nom de la classe.
Par exemple :

    <?php

        /**
        * Exemple de la commande `help` appelé par les lignes :
        *  - php ormgramework.php
        *  - php ormgramework.php -h
        *  - php ormgramework.php --help
        **/

        class HelpCommande extends Commande
        {
            private $options,
                    $nb_chars_max;
            /**
             * HelpCommand constructor.
             */
            function __construct() {
                $this->options = [
                    ["-h", "merged"],
                    ["--help", "merged"],
                    ["enable module", "merged", 1],
                    ["disable module", "merged", 1],
                    ["new strate", "merged", 1],
                    ["rm strate", "merged", 1],
                    ["rm strates", "merged", 1],
                    ["start orm", "merged", 1],
                    ["update db", "unmerged", 1],
                    ["install db", "unmerged", 1],
                ];
                $this->nb_chars_max = 69;
            }

            function exec()
            {
                echo
        "=====================================================================
        ========================== ORM Framework ============================
        =============================== Help ================================
        =====================================================================
        ";
        for($i=0, $max = count($this->options); $i<$max; $i++) {
            $str = "== ormframework.php ";

            $option = $this->options[$i];

            $commande = $option[0];
            $merge_state = $option[1];
            $merge_state = ($merge_state == "unmerged") ? "[unmerged]" : "";
            $nb_params = (isset($option[2])) ? $option[2] : 0;

            $params = [];
            for($j = 0,$max2 = $nb_params; $j<$max2; $j++) {
                $params[$j] = "< name >";
            }

            $params = implode(" ", $params);

            $str .= $commande." ".$params." ".$merge_state;
            $strlen = strlen($str);

            $reste_nb_chars = $this->nb_chars_max - $strlen-2;

            for($j = 0, $max2 = $reste_nb_chars; $j<$max2; $j++) {
                $str .= " ";
            }

            $str .= "==
        ";
            echo $str;
        }
        echo "=====================================================================
        ============================= Légende ===============================
        =====================================================================
        == strate => Model + View + Controller + Entity                    ==
        =====================================================================
        ";
            }
        }
                

Voici l'affichage dans un terminal lorse qu'on lance la commande.


Le Framework prévoie le fait que le webservice puisse être installé sur une ou plusieurs machines.
Elle met donc à disposition un système de génération d'installeur qui est caché.
Les commandes sont les suivantes :

  • Pour générer un installeur avec vhost puis redémarage d'apache :
  • php ormframework.php genere installer
  • Pour générer un installeur de base qui ne fait que générer le webservice :
  • php ormframework.php genere installer test

Voici le lien vers le zip avec les 2 installeur de l'application de démo meteo : Cliquez ICI