SHARE
TWEET

Untitled

a guest Jun 25th, 2019 69 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. # **Introduction**
  3.  
  4.  
  5. **TrixCMS** possède un système de Module (ou plus communément appelé "Système de Plugin"), il vous permet de développer des extensions afin d'améliorer votre CMS, de le rendre à la fois plus complet et plus performant, tout dépendra du code du *plugin en question*.
  6.  
  7. Si vous souhaitez utiliser notre système pour des **créations publiques** ou **privée**, suivez cette documentation, pour toutes questions, veuillez vous adressez à *l'Équipe Technique*.
  8.  
  9. # **Arborescence d'un Plugin**
  10.  
  11. Tout comme les thèmes, les plugins possèdent une structure de base qui peut éventuellement être modifiée suivant vos besoins. Voici, de base la structure de tous les plugins :
  12.  
  13.  
  14. * Assets
  15.   - config.php
  16.  
  17. * Config *
  18.  
  19. * Console
  20.  
  21. * Database
  22.   - Migrations
  23.   - Seeders
  24.     - ExampleDatabaseSeeder.php
  25. * Emails
  26.  
  27. * Entities
  28.  
  29. * Events
  30.  
  31. * Http *
  32.   - Adder
  33.   - Controllers *
  34.     - ExampleController.php
  35.   - Middleware
  36.   - ModuleInPage
  37.   - Requests
  38.   - routes.php *
  39.  
  40. * Jobs
  41.  
  42. * Listeners
  43.  
  44. * Notifications
  45.  
  46. * Providers *
  47.   - ExampleServiceProvider.php *
  48.  
  49. * Repositories
  50.  
  51. * Resources *
  52.   - lang
  53.   - views *
  54.     - layouts
  55.       - master.blade.php
  56.     - index.blade.php
  57.  
  58. * Tests
  59.  
  60. * composer.json *
  61.  
  62. * config.json *
  63.  
  64. * start.php *
  65.  
  66. Certains dossiers peuvent être supprimé, tous les fichiers et dossiers marqués d'un * doivent forcément être présents.
  67.  
  68.  
  69. # **Utilisation d'Artisan**
  70.  
  71. **Commandes obligatoires**
  72.  
  73.  
  74. | Commandes                                                 | Utilisation                                                                                                                                                                                                           | Utilité                                                      |
  75. |---------------------------------------------------------- |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |-----------------------------------------------------------    |
  76. | php artisan create:plugin-example                         | Cette commande vous permet de créer un plugin d'exemple avec l'identifiant généré                                                                                                                                     | Obligatoire                                                   |
  77. | php artisan trixcms:edit-name-plugin {oldname} {newname}  | Cette commande vous permet de modifier le nom de votre plugin via les arguments :  {oldname} = Nom actuel du plugin   {newname} = Nouveau nom                                                                         | Obligatoire                                                   |
  78. | php artisan module:make-command {name} {pluginname)       | Cette commande vous permet de créer une commande exemple :  "php artisan create:plugin-example"   {name} = Nom du fichier de la commande   {pluginname} = Nom du plugin sur le quel vous souhaitez généré le fichier  | Facultatif                                                    |
  79. | php artisan module:make-controller {name} {pluginname}    | Cette commande vous permet de généré un controller pour votre plugin   {name} = Nom du controller   {pluginname} = Nom du Plugin en question                                                                           | Obligatoire                                                   |
  80. | php artisan module:make-event {name} {pluginname}         | Cette commande vous permet de généré un event (évenement) pour votre plugin   {name} = Nom de l'event   {pluginname} = Nom du Plugin en question                                                                      | Facultatif                                                    |
  81. | php artisan module:make-job {name} {pluginname}           | Cette commande vous permet de généré un job (tâche) pour votre plugin   {name} = Nom de la tâche (job)   {pluginname} = Nom du Plugin en question                                                                        | Facultatif                                                    |
  82. | php artisan module:make-listener {name} {pluginname}      | Cette commande vous permet de généré un écouteur (Listener) pour votre plugin   {name} = Nom de l'écouteur (listener)    {pluginname} = Nom du Plugin en question                                                        | Facultatif                                                    |
  83. | php artisan module:make-mail {name} {pluginname}          | Cette commande vous permet de généré un mail pour votre plugin   {name} = Nom du mail    {pluginname} = Nom du Plugin en question                                                                                      | Facultatif                                                    |
  84. | php artisan module:make-middleware {name} {pluginname}    | Cette commande vous permet de généré un middleware pour votre plugin   {name} = Nom du middleware     {pluginname} = Nom du Plugin en question                                                                         | Facultatif                                                    |
  85. | php artisan module:make-migration {name} {pluginname}     | Cette commande vous permet de généré une migration pour votre plugin   {name} = Nom de la migration    {pluginname} = Nom du Plugin en question                                                                        | Dépend du Plugin  (Si utilise une bdd alors obligatoire)     |
  86. | php artisan module:make-model {name} {pluginname}         | Cette commande vous permet de généré un model (pour votre plugin)   {name} = Nom du model    {pluginname} = Nom du Plugin en question                                                                                  | Dépend du Plugin  (Si utilise une bdd alors obligatoire)     |
  87. | php artisan module:make-provider {name} {pluginname}      | Cette commande vous permet de généré un provider pour votre plugin   {name} = Nom du provider    {pluginname} = Nom du Plugin en question                                                                              | Facultatif                                                    |
  88. | php artisan module:make-request {name} {pluginname}       | Cette commande vous permet de généré une request pour votre plugin   {name} = Nom de la request    {pluginname} = Nom du Plugin en question                                                                            | Facultatif                                                    |
  89. | php artisan module:make-seed {name} {pluginname}          | Cette commande vous permet de généré un seed pour votre plugin   {name} = Nom du seed    {pluginname} = Nom du Plugin en question                                                                                      | Facultatif                                                    |
  90. | php artisan module:migrate {pluginname} --force           | Cette commande vous permet d'exécuter toutes les migrations (elle vous permet de créer les tables jadis générées avec la commande php artisan module:make-migration)                                                     | Dépend du Plugin   (Si utilise une bdd alors obligatoire)    |
  91. | php artisan module:seed {pluginname}                      | Cette commande vous permet d'exécuter les seed  {pluginname} = Nom du Plugin                                                                                                                                             | Facultatif                                                    |
  92. | php artisan trixcms:delete-cache-module                   | Cette commande vous permet de supprimer le cache des modules (assets)                                                                                                                                                 | Facultatif                                                    |
  93. | php artisan trixcms:update-database-cms                   | Cette commande vous permet de mettre à jour le système de mise à jour de table automatique                                                                                                                             | Facultatif                                                    |
  94.  
  95. <br>
  96.  
  97. **Création d'une commande**
  98.  
  99. **Laravel 5 et TrixCMS** vous permettent de créer des commandes pour vos plugins, *l'utilité* ? Elle est simple, **derrière votre commande** ce trouve tout un *code*, et plutôt que *d'exécuter* ce code plusieurs fois dans le CMS (ce qui peut causer d'énorme ***latence et probablement des bugs***) en créant une commande, l'utilisation de celle-ci devient **bénéfique pour vous et pour le CMS**.
  100.  
  101. Si votre plugin permet de mettre en cache des assets, alors en créant une commande de suppression du cache, l'utilisateur n'aura plus qu'à exécuter la commande depuis un **terminal** ou en cliquant sur un **bouton**.
  102.  
  103. # **Utilisation des systèmes de migration**
  104.  
  105. Il faut savoir que la particularité de laravel et donc de **TrixCMS** et que vous ne devez pas manipuler la base de donnée directement. Vos plugins devront respecter la logique d'interaction prévue de base. Elle se compose d'un système de migration, de model et d'un supplément apportée par **TrixCMS** : un système pour mettre à jour automatiquement vos tables.
  106.  
  107. **Migration**
  108.  
  109. Le système de migration disponible dans les modules est le même que celui de **laravel**. Si vous voulez voir plus en détail se qu'il en retourne, vous pouvez aller lire là [documentation officielle de laravel](https://laravel.com/docs/5.4/migrations) qui est beaucoup plus complète.
  110.  
  111. Neanmoins, en bref, voici ce que vous devez retenir au minimum :
  112.  
  113. Chaque migration peut être créée via la commande (obligatoire): _**module:make-migration**_ dont vous pouvez voir en détail son utilisation dans la section "**Commandes obligatoires**".
  114.  
  115. Chaque migrations ainsi créées se trouveront dans le dossier _/Database/Migrations/_.
  116. Voici le code d'une migration (état initiale) :
  117.  
  118. ```php
  119. <?php
  120.  
  121. use Illuminate\Support\Facades\Schema;
  122. use Illuminate\Database\Schema\Blueprint;
  123. use Illuminate\Database\Migrations\Migration;
  124.  
  125. class MaMigration extends Migration
  126. {
  127.     /**
  128.      * Run the migrations.
  129.      *
  130.      * @return void
  131.      */
  132.     public function up()
  133.     {
  134.        
  135.     }
  136.  
  137.     /**
  138.      * Reverse the migrations.
  139.      *
  140.      * @return void
  141.      */
  142.     public function down()
  143.     {
  144.        
  145.     }
  146. }```
  147.  
  148. Comme vous pouvez le constater, deux fonctions sont présentes **up()** et **down()** respectivement utilisées pour la création des tables (mettre à jour etc...) et le rollback (pouvoir revenir en arrière).
  149.  
  150. Maintenant, imaginons que vous voulez créer une table _MaTable_. Pour pouvoir manipuler une table (création etc..), vous devez passer par le système de *Shema* fournit par laravel.
  151. En ce qui concerne l'utilisation du système de Schéma, je vous redirige vers [la documentation officielle de laravel](https://laravel.com/docs/5.4/migrations#tables).
  152.  
  153. Voici un exemple de migration :
  154.  
  155. ```php
  156. public function up()
  157.     {
  158.         Schema::create('faq_list', function(Blueprint $table) {
  159.             $table->increments('id'); // on crée une colonne id en autoincrement
  160.             $table->string('title')->nullable($value = true); //on crée une colonne 'title' de type string et pouvant être null
  161.             $table->text('description')->nullable($value = true);//on crée une colonne 'title' de type string et pouvant être null
  162.             $table->timestamps(); //ajoute deux colonnes de types dates updated_at et created_at respectivement mise à jours lors d'une modification dans les données d'une ligne et lors de l'ajout d'une nouvelle ligne.
  163.         });
  164.     }
  165. ```
  166. ```php
  167.  
  168.     public function down()
  169.     {
  170.         Schema::dropIfExists('faq_list');
  171.     }
  172. ```
  173.  
  174. Pour finir, pour executer ou faire un rollback d'une migration referez-vous aux commandes **module:migrate** et **module:rollback** expliquées dans la section "**Commandes obligatoires**".
  175.  
  176. **Model**
  177.  
  178. De la même façon, laravel met à disposition un outil nommé *Eloquent* permettant d'intéragir avec votre base de données en terme de données. Plus besoin de taper votre SQL à la main, ici tout est fait pour vous rendre la tâche beaucoup plus simple et pratique. C'est un outil vraiment très complet vous permettant d'avoir des logiques relativement complexes comme les relations. Je vous redirige vers [la documentation officielle de laravel](https://laravel.com/docs/5.4/eloquent).
  179.  
  180. Pour les models, vous pouvez les créer manuellement ou passer par la commande **module:make-model** expliquée plus haut. Tous les models se trouvent dans le dossier _Entities_ de votre plugin.
  181.  
  182. Voici globalement ce à quoi ressembleront une grande majoritée des models (à savoir : l'ensemble des fonctions présentés ci-dessous ne sont maheuresement pas créées automatiquement :/)
  183.  
  184. ```php
  185. <?php
  186.  
  187. namespace Modules\MonModule\Entities;
  188.  
  189. use Illuminate\Database\Eloquent\Model;
  190.  
  191. class Parent extends Model
  192. {
  193.     protected $table = 'parent'; //nom de la table sur laquelle est reliée le model
  194.  
  195.     public function create(array $attributes = [])
  196.     {
  197.         return parent::create($attributes);
  198.     }
  199.  
  200.     public function find($id, $columns = ['*'])
  201.     {
  202.         return parent::find($id, $columns);
  203.     }
  204.  
  205.     public function get($columns = ['*'])
  206.     {
  207.         return parent::get($columns);
  208.     }
  209.  
  210.     public function where($column, $operator = null, $value = null, $boolean = 'and')
  211.     {
  212.         return parent::where($column, $operator, $value, $boolean); /
  213.     }
  214. }
  215.  
  216. ```
  217.  
  218. et par exemple si vous voulez créer une relation ONE-TO-MANY, vous devrez procéder de la sorte :
  219. ```php
  220. public function mesEnfants()
  221.     {
  222.         return $this->hasMany('Modules\MonModule\Entities\Enfant', 'parent_id');
  223.     }
  224. ```
  225.  
  226. ce qui équivaudrait au schéma suivant :
  227.  
  228. ![diagramme uml](https://i.imgur.com/N4QhrLw.png)
  229.  
  230. - Parent possède 0 ou plusieurs enfants
  231. - Un enfant est possedé par un parent
  232.  
  233. Je vous conseil vivement d'aller lire la documentation d'Eloquent :)
  234.  
  235.  
  236. **Système de mise à jour de table automatique**
  237.  
  238. **TrixCMS** vous permet de bénéficier d'un système d'auto-update des tables choisit via un fichier JSON, vous vous demandez probablement à quoi ce système peut-il vous servir ? Eh bien c'est très simple, au lieu de supprimer les tables en question et de les re-créer (ce qui peut énormément agasser les utilisateurs de TrixCMS car en faisant cela, toutes les données des tables seront supprimées à cause d'une mise à jour d'un plugin), le système de mise à jour de table automatique vous permet en plus d'éviter la suppression des données mais aussi de baisser la latence des mises à jours de x5 et d'ajouter les colonnes que vous souhaitez.
  239.  
  240.  
  241. **L'utilisation est très simple.**
  242.  
  243. Dans `Modules/NomDeVotrePlugin/Database/` vous devez créer un dossier `Update/` suivis du fichier `database.json`.
  244.  
  245. `database.json` doit contenir :
  246.  
  247. ```json
  248.  
  249. {
  250.   "update": { /* permet d'avertir le CMS que c'est une mise à jour et non pas autre chose */
  251.     "vote__configuration": { /* ici vous devez mettre votre/vos table(s) à mettre à jour */
  252.       "keyAPI": { /* Ici vous mettez le nom de la colonne que vous voulez créer */
  253.         "type": "text", /* "type" représente si la colonne est de type text, string, int... */
  254.         "tall": null, /* la taille de la colonne exemple : 255 (type string) */
  255.         "after": "objectif" /* Ce paramètre permet de dire au système de placer cette colonne après une autre colonne */
  256.       }
  257.     }
  258.   }
  259. }
  260.  
  261. ```
  262.  
  263. Ce code est exécuté de base lors de la mise à jour ou l'installation du plugin par l'utilisateur, mais si vous souhaitez l'exécuter de force alors dans votre `DevTools` ou dans un `terminal` faites la commande `php artisan trixcms:update-database-cms`.
  264.  
  265. # **Les bases**
  266.  
  267. **Controllers**
  268.  
  269. Le système de Controller est plutôt simple à comprendre. Néanmoins, il y a quand même des notions plus ou moins complexe pour celles-ci je vous laisse les découvrir
  270.  
  271.  
  272. **DeveloppementTools**
  273.  
  274. **Routing**
  275.  
  276. Pour faire simple le routing c'est un peu comme un système d'aiguillage qui va vous permettre de rediriger des urls vers des fonctions présent dans des controllers. C'est un système très important et obligatoire que vous ne devez pas prendre à la légère. En effet, via les **routes**, le cms va par exemple récupérer le nom des pages pour l'afficher dans la balise `<title></title>` ou encore indispensable pour l'affichage des vues. De plus on peut voir les routes comme un système de "protection".
  277.  
  278. Encore une fois, **TrixCMS** utilise le système de routing présent dans laravel, je vous conseil vivement de regarder la [documentation officielle](https://laravel.com/docs/5.4/routing).
  279.  
  280. Toutes les routes sont définies dans le fichier _Http/routes.php_.
  281.  
  282. Voici un exemple de structure de routes groupées:
  283. ```php
  284. Route::group(['middleware' => 'web', 'prefix' => 'monmodule', 'namespace' => 'Modules\MonModule\Http\Controllers'], function()
  285. {
  286.     Route::get('/', 'MonControlleur@index')->name('MaRoute');
  287. });
  288. ```
  289. Globalement, on va préférer créer plusieurs groupes suivant sur quoi va agir les routes. Par exemple on va découper en deux groupes les routes accéssible depuis le site en lui même (vos utilisateurs) et ceux ratachées au panel admin.
  290.  
  291. Comme expliqué dans la documentation de laravel, vous n'avez bien évidemment pas seulement la possibilité de créer des routes pour la méthode GET, mais également POST, PUT, PATCH etc...
  292.  
  293. Vous pourrez observer que pour chaque route tout d'abord nous devons spécifier une url, le controller et la fonction qui va être appellé (NomController@NomFonction) mais également un nom. En effet, la spécification d'un nom de route est obligatoire. Nom appliqué via l'appel de la fonction **name()** ou via le paramètre **as** (présent dans l'exemple ci-dessous). Il permet notamment d'afficher un titre dans une page (balise title) mais également pour le système d'affichage des vues. Chaque nom de route doit être **unique !** assurez-vous donc de son unicité.
  294.  
  295. De plus, on peut également customiser les routes par exemple via l'ajout de middlewares.
  296.  
  297. Exemple (d'une route appellé via requete ajax/fetch retournant du json):
  298. ```php
  299. Route::get('/', ['uses' => 'MonControlleur@mafonction', 'as' => 'NOM_DE_MA_ROUTE', 'middleware' => ['InstallExt', 'ApiCall']]);
  300. ```
  301.  
  302. Le paramètre **as** correspond a l'identifiant de la route. Vous pourrez ainsi par exemple utiliser {{ route('NOM_DE_MA_ROUTE') }} dans vos vues :).
  303.  
  304. Vous pourrez retrouver la liste des middlewares dans la section **Middleware** situé plus bas dans la documentation.
  305.  
  306. Enfin, si vous souhaitez créer des routes avec des paramètres dynamiques je vous redirige vers la famosa [documentation officielle](https://laravel.com/docs/5.4/routing#route-parameters).
  307.  
  308.  
  309. Mais briévement pour celles et ceux qui auraient la flemme de la lire :
  310. - les paramètres sont présents dans vos routes sous la forme {nom_du_paramètre} (vous ne devez pas utiliser de -).
  311. - si vous souhaitez créer des paramètres optionnelles il faut rajouter un **?** {param_optionel?}
  312. - pour chaque paramètre que vous allez ajouter dans l'url, il faudra ajouter un paramètre dans la fonction associée à la route (l'ordre des paramètres de fonction est le même que l'ordre des paramètres dans l'url, le nom n'importe peu).
  313.  
  314. Petite notion importante, vous pouvez définir des expréssions régulières pour vos paramètres  (et ça c'est cool).
  315.  
  316. Exemple tirée de la [documentation officielle](https://laravel.com/docs/5.4/routing#route-parameters) :
  317.  
  318. ```php
  319. Route::get('user/{name}', function ($name) {
  320.     //
  321. })->where('name', '[A-Za-z]+');
  322. ```
  323.  
  324.  
  325. **Assets**
  326.  
  327. **Vues**
  328.  
  329. En ce qui concerne les vues, laravel propose d'utiliser un système de template nommé **blade** ([lien de la documentation](https://laravel.com/docs/5.4/blade)). Ce système apporte différentes choses comme une syntaxe alternative. Vous n'êtes pas obligé d'utiliser cette syntaxe même si elle est recommandée.
  330.  
  331. Chaque vue doit se trouver dans le dossier Ressources/views de votre plugin et se nommer de la forme ***.blade.php**.
  332.  
  333. Pour pouvoir charger une vue pour une route donnée, vous devez dans la fonction associé à cette dernière utiliser le **DeveloppementTools** présenté plus haut.
  334.  
  335. **Attention : c'est un système qui est très sensible à ce que vous allez entrer (sensible à la case etc...) !**
  336.  
  337. Voici un exemple d'affichage d'une vue ou le contexte serait :
  338. - Nom du module : MonModule
  339. - Nom de la vue index.blade.php (Ressources/views/index.blade.php)
  340. - Nom de la route : MaRoute
  341. - Identifiant de la vue pour cette route : monmodule_mavue
  342.  
  343. ```php
  344. DeveloppementTools::moduleSetViews('MaRoute', 'monmodule_mavue', 'MonModule::index', 'MonModule');
  345. return DeveloppementTools::loadView();
  346. ```
  347.  
  348. Explication des paramètres de la fonction **moduleSetViews()** :
  349.  
  350. 1. Nom de la route associée à cette fonction
  351. 2. Identifiant généralement nomdumodule_nomdelavue
  352. 3. Chemin pour aller charger la vue sous la forme de NomDuModule::chemin. A noter que dans le chemin vous ne devez pas spécifier les extensions des vues, en l'occurence ici _.blade.php_. Si vous avez structuré vos vues dans des sous-dossiers, vous ne devez spécifier le chemin par des . au lieu des / exemples si vous avez /Ressources/views/admin/index.blade.php, vous le retranscrirez par MonModule::admin.index
  353. 4. Nom du module
  354.  
  355.  
  356. # **Système avancé**
  357.  
  358. **ServiceProvider**
  359.  
  360. **Middleware**
  361.  
  362. **Http - Adder**
  363.  
  364. Le système d'**adder** est un système innovant à **TrixCMS** qui permet entre-autre aux développeurs de plugins d'afficher quelques statistiques directement sur la page d'acceuil du panel admin ! Voici un exemple de statistique :
  365. ![exemple adder](https://i.imgur.com/zPETm1v.png).
  366.  
  367. Pour ajouter des statistiques à vos plugins, vous devrez créer un fichier **BlockIndex.php** dans le dossier _Http/Adder_ de votre plugin.
  368.  
  369. Voici la structure de base que devra respecter votre fichier :
  370. ```php
  371. <?php
  372.  
  373. namespace Modules\MonModule\Http\Adder;
  374.  
  375. class BlockIndex {
  376.  
  377.     public function set()
  378.     {
  379.        
  380.         return [];
  381.     }
  382.  
  383. }
  384. ```
  385.  
  386. A noter que la fonction **set()** doit obligatoirement retourner un tableau.
  387.  
  388. Une statistique est structurée de cette façon :
  389. ```php
  390. [
  391.     "icon" => "", //icon du block (font awesome sans le fa- par exemple pour fa-list indiquez juste list)
  392.     "title" => "", //nom du block
  393.     "color" => "", //couleur reprenant les noms des classes bootstrap : warning, success et danger
  394.     "contains" => "" //valeur à afficher
  395. ]
  396. ```
  397.  
  398. **Http - ModuleInPage**
  399.  
  400. Avant de vous expliquez ce qu'est que le **ModuleInPage**, sachez que ce système est difficile à appréhender or lorsque vous comprendrez la partie théorique, la pratique deviendra extrémement simple.
  401.  
  402. Tout d'abord sachez qu'il y a 3 principes de base dont 2 facultatifs selon l'utilisation.
  403.  
  404. Le **ModuleInPage** (M.I.P) contient 3 fonctionnalités qui sont les suivantes :
  405.  
  406. * M.I.P Function
  407. * Sharer
  408. * SharerProvider
  409.  
  410. ###### M.I.P Function
  411.  
  412. Le *M.I.P Function* est une fonction à implémenter **obligatoirement** dans le ServiceProvider (fonction : boot()) qui gère votre Plugin, exemple : `Modules/FAQ/Providers/FAQServiceProvider.php`, le code à implémenté est :
  413.  
  414. ```php
  415.  
  416. DeveloppementTools::setModuleInPage('Vote', [
  417.    "profil" => ModuleInPage::$PROFIL
  418. ]);
  419.  
  420.  
  421. ```
  422.  
  423. Dans ce code plusieurs points sont à prendre en considération,
  424.  
  425. * Le nom du plugin
  426. * Le tableau contenant les intégrations
  427.  
  428. ce qui donne :
  429.  
  430. ```php
  431.  
  432. DeveloppementTools::setModuleInPage("MonPlugin", [
  433.   "MaVue" => "users.profil.home" // "MaVue" est la vue que vous comptez intégrer, et users.profil.home est la vue dans la quel vous comptez intégrer "MaVue", (ATTENTION : Vous ne pouvez intégrer votre vue que dans certaines vues déjà existantes.)
  434. ]);
  435.  
  436.  
  437. ```
  438.  
  439. Voici la liste des vues dans lesquels vous pouvez intégrer votre vue :
  440.  
  441. * users.profil.home (page de profil)
  442. * users.login.home (page de connexion)
  443. * users.register.home (page d'inscription)
  444. * home.home (page d'accueil)
  445. * news.home (blog)
  446. * Maintenance.Layout.home (Page LAYOUT de la Maintenance)
  447.  
  448.  
  449. ###### Sharer
  450.  
  451. Le *Sharer* est un système vous permettant de partager vos variables dans les intégrations, certainement après l'utilisation de la *M.I.P Function* vous ne pourrez que mettre du code static (html/css) ou du code php avec des variables globales (comme par exemple $user oou $config), afin de pouvoir implémenter vos variables vous devez sois utiliser le `Sharer System` (celui-ci) ou bien le `SharerProvider System` (que nous verrons après). On va ce concentrer sur le `Sharer`.
  452.  
  453. L'utilisation est très simple, vous devez pour cela créer un fichier `Sharer.php` dans le dossier `Modules/monPlugin/Http/ModuleInPage`.
  454.  
  455. Ensuite rentrez ce code :
  456.  
  457. ```php
  458. <?php
  459.  
  460. namespace Modules\MonPlugin\Http\ModuleInPage;
  461.  
  462. class Sharer {
  463.  
  464.     public $allVar = [];
  465.  
  466.     public function setAllVar()
  467.     {
  468.         return $this->allVar = [];
  469.     }
  470. }
  471.  
  472. ```
  473. <br>
  474.  
  475. Ne stressez pas, je vais vous expliquez comment utiliser ce code... Vous avez à disposition la méthode : `public $allVar`, cette méthode ne vous servira à rien OR ne la supprimez surtout pas. Elle est très importante, elle permet de partager les variable
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!
 
Top