Untitled


# **Introduction**


**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*.

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*.

# **Arborescence d'un Plugin**

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 :


* Assets
  - config.php

* Config *

* Console

* Database
  - Migrations
  - Seeders
    - ExampleDatabaseSeeder.php
* Emails

* Entities

* Events

* Http *
  - Adder
  - Controllers *
    - ExampleController.php
  - Middleware
  - ModuleInPage
  - Requests
  - routes.php *

* Jobs

* Listeners

* Notifications

* Providers *
  - ExampleServiceProvider.php *

* Repositories

* Resources *
  - lang
  - views *
    - layouts
      - master.blade.php
    - index.blade.php

* Tests

* composer.json *

* config.json *

* start.php *

Certains dossiers peuvent être supprimé, tous les fichiers et dossiers marqués d'un * doivent forcément être présents.


# **Utilisation d'Artisan**

**Commandes obligatoires**


| Commandes                                                	| Utilisation                                                                                                                                                                                                          	| Utilité                                                   	|
|----------------------------------------------------------	|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------	|-----------------------------------------------------------	|
| php artisan create:plugin-example                        	| Cette commande vous permet de créer un plugin d'exemple avec l'identifiant généré                                                                                                                                    	| Obligatoire                                               	|
| 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                                               	|
| 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                                                	|
| 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                                               	|
| 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                                                	|
| 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                                                	|
| 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                                                	|
| 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                                                	|
| 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                                                	|
| 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)  	|
| 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)  	|
| 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                                                	|
| 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                                                	|
| 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                                                	|
| 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) 	|
| php artisan module:seed {pluginname}                     	| Cette commande vous permet d'exécuter les seed  {pluginname} = Nom du Plugin                                                                                                                                         	| Facultatif                                                	|
| php artisan trixcms:delete-cache-module                  	| Cette commande vous permet de supprimer le cache des modules (assets)                                                                                                                                                	| Facultatif                                                	|
| php artisan trixcms:update-database-cms                  	| Cette commande vous permet de mettre à jour le système de mise à jour de table automatique                                                                                                                           	| Facultatif                                                	|

<br>

**Création d'une commande**

**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**.

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**.

# **Utilisation des systèmes de migration**

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.

**Migration**

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.

Neanmoins, en bref, voici ce que vous devez retenir au minimum :

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**".

Chaque migrations ainsi créées se trouveront dans le dossier _/Database/Migrations/_.
Voici le code d'une migration (état initiale) :

```php
<?php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class MaMigration extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {

    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {

    }
}```

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).

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.
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).

Voici un exemple de migration :

```php
public function up()
    {
        Schema::create('faq_list', function(Blueprint $table) {
            $table->increments('id'); // on crée une colonne id en autoincrement
            $table->string('title')->nullable($value = true); //on crée une colonne 'title' de type string et pouvant être null
            $table->text('description')->nullable($value = true);//on crée une colonne 'title' de type string et pouvant être null
            $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.
        });
    }
```
```php

    public function down()
    {
        Schema::dropIfExists('faq_list');
    }
```

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**".

**Model**

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).

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.

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 :/)

```php
<?php

namespace Modules\MonModule\Entities;

use Illuminate\Database\Eloquent\Model;

class Parent extends Model
{
    protected $table = 'parent'; //nom de la table sur laquelle est reliée le model

    public function create(array $attributes = [])
    {
        return parent::create($attributes);
    }

    public function find($id, $columns = ['*'])
    {
        return parent::find($id, $columns);
    }

    public function get($columns = ['*'])
    {
        return parent::get($columns);
    }

    public function where($column, $operator = null, $value = null, $boolean = 'and')
    {
        return parent::where($column, $operator, $value, $boolean); /
    }
}

```

et par exemple si vous voulez créer une relation ONE-TO-MANY, vous devrez procéder de la sorte :
```php
public function mesEnfants()
    {
        return $this->hasMany('Modules\MonModule\Entities\Enfant', 'parent_id');
    }
```

ce qui équivaudrait au schéma suivant :

![diagramme uml](https://i.imgur.com/N4QhrLw.png)

- Parent possède 0 ou plusieurs enfants
- Un enfant est possedé par un parent

Je vous conseil vivement d'aller lire la documentation d'Eloquent :)


**Système de mise à jour de table automatique**

**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.


**L'utilisation est très simple.**

Dans `Modules/NomDeVotrePlugin/Database/` vous devez créer un dossier `Update/` suivis du fichier `database.json`.

`database.json` doit contenir :

```json

{
  "update": { /* permet d'avertir le CMS que c'est une mise à jour et non pas autre chose */
    "vote__configuration": { /* ici vous devez mettre votre/vos table(s) à mettre à jour */
      "keyAPI": { /* Ici vous mettez le nom de la colonne que vous voulez créer */
        "type": "text", /* "type" représente si la colonne est de type text, string, int... */
        "tall": null, /* la taille de la colonne exemple : 255 (type string) */
        "after": "objectif" /* Ce paramètre permet de dire au système de placer cette colonne après une autre colonne */
      }
    }
  }
}
```

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`.

# **Les bases**

**Controllers**

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 sur la [documentation officielle](https://laravel.com/docs/5.4/controllers).

Un controller est de base sous la forme :

```php
<?php

namespace Modules\Example\Http\Controllers;

use Illuminate\Routing\Controller;

class ExampleController extends Controller
{
    // Documentation : https://docs.trixcms.eu/
    public function index()
    {

    }
}

```


**DeveloppementTools**

**Routing**

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".

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).

Toutes les routes sont définies dans le fichier _Http/routes.php_.

Voici un exemple de structure de routes groupées:
```php
Route::group(['middleware' => 'web', 'prefix' => 'monmodule', 'namespace' => 'Modules\MonModule\Http\Controllers'], function()
{
    Route::get('/', 'MonControlleur@index')->name('MaRoute');
});
```
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.

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...

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é.

De plus, on peut également customiser les routes par exemple via l'ajout de middlewares.

Exemple (d'une route appellé via requete ajax/fetch retournant du json):
```php
Route::get('/', ['uses' => 'MonControlleur@mafonction', 'as' => 'NOM_DE_MA_ROUTE', 'middleware' => ['InstallExt', 'ApiCall']]);
```

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 :).

Vous pourrez retrouver la liste des middlewares dans la section **Middleware** situé plus bas dans la documentation.

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).


Mais briévement pour celles et ceux qui auraient la flemme de la lire :
- les paramètres sont présents dans vos routes sous la forme {nom_du_paramètre} (vous ne devez pas utiliser de -).
- si vous souhaitez créer des paramètres optionnelles il faut rajouter un **?** {param_optionel?}
- 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).

Petite notion importante, vous pouvez définir des expréssions régulières pour vos paramètres  (et ça c'est cool).

Exemple tirée de la [documentation officielle](https://laravel.com/docs/5.4/routing#route-parameters) :

```php
Route::get('user/{name}', function ($name) {
    //
})->where('name', '[A-Za-z]+');
```


**Assets**

**Vues**

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.

Chaque vue doit se trouver dans le dossier Ressources/views de votre plugin et se nommer de la forme ***.blade.php**.

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.

**Attention : c'est un système qui est très sensible à ce que vous allez entrer (sensible à la case etc...) !**

Voici un exemple d'affichage d'une vue ou le contexte serait :
- Nom du module : MonModule
- Nom de la vue index.blade.php (Ressources/views/index.blade.php)
- Nom de la route : MaRoute
- Identifiant de la vue pour cette route : monmodule_mavue

```php
DeveloppementTools::moduleSetViews('MaRoute', 'monmodule_mavue', 'MonModule::index', 'MonModule');
return DeveloppementTools::loadView();
```

Explication des paramètres de la fonction **moduleSetViews()** :

1. Nom de la route associée à cette fonction
2. Identifiant généralement nomdumodule_nomdelavue
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
4. Nom du module


# **Système avancé**

**ServiceProvider**

**Middleware**

**Http - Adder**

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 :
![exemple adder](https://i.imgur.com/zPETm1v.png).

Pour ajouter des statistiques à vos plugins, vous devrez créer un fichier **BlockIndex.php** dans le dossier _Http/Adder_ de votre plugin.

Voici la structure de base que devra respecter votre fichier :
```php
<?php

namespace Modules\MonModule\Http\Adder;

class BlockIndex {

    public function set()
    {

        return [];
    }

}
```

A noter que la fonction **set()** doit obligatoirement retourner un tableau.

Une statistique est structurée de cette façon :
```php
[
    "icon" => "", //icon du block (font awesome sans le fa- par exemple pour fa-list indiquez juste list)
    "title" => "", //nom du block
    "color" => "", //couleur reprenant les noms des classes bootstrap : warning, success et danger
    "contains" => "" //valeur à afficher
]
```

**Http - ModuleInPage**

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.

Tout d'abord sachez qu'il y a 3 principes de base dont 2 facultatifs selon l'utilisation.

Le **ModuleInPage** (M.I.P) contient 3 fonctionnalités qui sont les suivantes :

* M.I.P Function
* Sharer
* SharerProvider

###### M.I.P Function

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 :

```php

DeveloppementTools::setModuleInPage('Vote', [
   "profil" => ModuleInPage::$PROFIL
]);
```

Dans ce code plusieurs points sont à prendre en considération,

* Le nom du plugin
* Le tableau contenant les intégrations

ce qui donne :

```php

DeveloppementTools::setModuleInPage("MonPlugin", [
  "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.)
]);


```

Voici la liste des vues dans lesquels vous pouvez intégrer votre vue :

* users.profil.home (page de profil)
* users.login.home (page de connexion)
* users.register.home (page d'inscription)
* home.home (page d'accueil)
* news.home (blog)
* Maintenance.Layout.home (Page LAYOUT de la Maintenance)


###### Sharer


Le *Sharer* est un système vous permettant de partager vos variables **uniquement** dans les intégrations (ce qui fait la différence avec le SharerProvider), 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`.


L'utilisation est très simple, vous devez pour cela créer un fichier `Sharer.php` dans le dossier `Modules/monPlugin/Http/ModuleInPage`.

Ensuite rentrez ce code :

```php
<?php

namespace Modules\MonPlugin\Http\ModuleInPage;

class Sharer {

    public $allVar = [];

    public function setAllVar()
    {
        return $this->allVar = [];
    }
}

```
<br>

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 variables aux vues, afin de déclarer vos variables, vous devez les ajouter dans la fonction `setAllVar()` et plus précisément dans le bout de code suivant : `return $this->allVar = [];`, vous devez vos variables comme suis :

```php

$lol = 1;

return $this->allVar = ["test" => "Hey je suis un test", "lol", => $lol];


```

En gros dans le tableau `[]`, vous devez placer en clé : "Le Nom de votre variable" et en valeur "la valeur qui sera montrée lorsqu'on appel la variable" (afin d'en créer plusieurs vous devez les séparer par une virgule ["test" => "hey", "lol" => 5]) sa reviens à faire cela :

```php

<?= $test ?> // Retournera : Hey je suis un test
<?= $lol ?> // Retournera : 1


```

Votre code devrait finalement ressembler à cela :

```php
<?php

namespace Modules\MonPlugin\Http\ModuleInPage;

class Sharer {

    public $allVar = [];

    public function setAllVar()
    {
        $lol = 1;
        return $this->allVar = ["test" => "Hey je suis un test", "lol", => $lol];
    }
}

```
<br>
Parfait maintenant vous pouvez actualiser, les variables fonctionnent.

###### SharerProvider

Le *SharerProvider* est un système vous permettant de partager vos variables **dans tous le CMS** (ce qui fait la différence avec le Sharer), 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 d'au-dessus) ou bien le `SharerProvider System` (celui-ci). On va ce concentrer sur le `SharerProvider`.

L'utilisation est très simple, vous devez pour cela créer un fichier `SharerProvider.php` dans le dossier `Modules/monPlugin/Http/ModuleInPage`.

**ATTENTION : L'utilisation du SharerProvider n'est pas recommandée, veuillez utiliser ce système uniquement pour des variables qui doivent être globales, comme par exemple le plugin vote qui doit partager le classement vote, les récompenses et le classement pallier**

Ensuite rentrez ce code :

```php
<?php

namespace Modules\MonPlugin\Http\ModuleInPage;

class SharerProvider {

    public $allVar = [];

    public function setAllVar()
    {
        return $this->allVar = [];
    }
}

```
<br>

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 variables aux vues, afin de déclarer vos variables, vous devez les ajouter dans la fonction `setAllVar()` et plus précisément dans le bout de code suivant : `return $this->allVar = [];`, vous devez vos variables comme suis :

```php

$lol = 1;

return $this->allVar = ["test" => "Hey je suis un test", "lol", => $lol];


```

En gros dans le tableau `[]`, vous devez placer en clé : "Le Nom de votre variable" et en valeur "la valeur qui sera montrée lorsqu'on appel la variable" (afin d'en créer plusieurs vous devez les séparer par une virgule ["test" => "hey", "lol" => 5]) sa reviens à faire cela :

```php

<?= $test ?> // Retournera : Hey je suis un test
<?= $lol ?> // Retournera : 1


```

Votre code devrait finalement ressembler à cela :

```php
<?php

namespace Modules\MonPlugin\Http\ModuleInPage;

class SharerProvider {

    public $allVar = [];

    public function setAllVar()
    {
        $lol = 1;
        return $this->allVar = ["test" => "Hey je suis un test", "lol", => $lol];
    }
}

```
<br>
Parfait maintenant vous pouvez actualiser, les variables fonctionnent partout même dans la page d'accueil ou dans le panel administrateur.