• Config: Lire un fichier de configuration
• User: Objet associé à un utilisateur
• Page: Objet associé à une page
• Translate: Récupère ou ajoute des traductions
• Crypt: Fonctions de cryptage
• Session: Modifier les données de session
• Mail: Envoyer un mail
• Parser: Lire un fichier de template
• Html: Ajouter du CSS, JS, ou des variables à la page

Cette classe permet de lire et modifier les fichiers de configuration, au format JSON entouré par les balises de protection PHP.

class Config {
 
    // $path: chemin vers le fichier, s'il est vide ça sera la configuration du CMS
    // $create: spécifie le comportement si le fichier n'est pas trouvé:
    //     true: une configuration vide est créé
    //     false: une exception est émise
    // Note: peut lancer une exception
    public function __construct($path = null, $create = false);
 
    // Retourne la valeur correspondante au chemin donné
    // $path: chemin de la valeur à récupérer, séparé par des points
    // $default: valeur à retourner si le chemin n'est pas trouvé
    public function get($path = null, $default = null);
 
    // Retourne true si le chemin existe, false sinon
    // $path: chemin de la valeur à tester
    public function exists($path);
 
    // Insère ou modifie la valeur correspondante au chemin $path
    // $path: chemin de la valeur à insérer/modifier
    // $value: valeur à insérer/modifier
    public function set($path, $value);
 
    // Supprime la valeur associé au chemin
    // $path: chemin de la valeur à supprimer
    public function delete($path = null);
 
    // Sauvegarder la configuration dans le fichier
    // $beautify: ajouter des retours à la ligne et des tabulations
    public function save($beautify = true);
 
    // Recharge la configuration depuis le fichier
    public function refresh();
 
}

// Ouvre la configuration du CMS
$config = new Config;
// Récupère la version
$version = $config->get('cms.version');

// Ouvre un fichier de configuration, et le créé si le fichier n'existe pas
$config = new Config($path . 'data.cfg.php', true);
// Met à jour une valeur
$config->set('user.settings', true);
// Sauvegarde dans le fichier
$config->save();

Cette classe permet de charger et récupérer les données d'un utilisateur, ou d'utiliser les méthodes associés à l'espace membre (inscription, connexion, ..).

class User {
 
    // Le constructeur n'est pas utilisé
    public function __construct();
 
    // Initialise un utilisateur dans l'objet
    // Si aucun argument n'est passé, c'est l'utilisateur courant qui est chargé
    // Exemple: $user->setup();
    // Exemple: $user->setup('Notch', 'username');
    // Exemple: $user->setup(3, 'id');
    // Retourne true si l'utilisateur existe, false sinon
    public function setup($username = null, $method = 'username');
 
    // Retourne une valeur associée à l'utilisateur
    // Exemple: $user->get('username');
    public function get($index);
 
    // Retourne true si l'utilisateur chargé existe, false sinon
    public function auth();
 
    // Retourne true si l'utilisateur peut voir la page $page
    // $page: Objet page initialisé avec une page
    public function canView(Page $page);
 
    // Retourne true si l'utilisateur peut modifier la page $page
    // $page: Objet page initialisé avec une page
    public function canEdit(Page $page);
 
    // Créé un utilisateur (inscription)
    // Note: peut lancer une exception
    public function create($username, $email, $password, $confirmpassword);
 
    // Tente une connexion pour l'utilisateur courant
    // Si la connexion est réussie, des cookies/sessions seront envoyés
    // Note: peut lancer une exception
    public function login($username, $password, $remember = false);
 
    // Déconnecte l'utilisateur courant
    // $regen: si true, la session est régénérée
    public function logout($regen = true);
 
    // Si $search est vide: renvoie tous les utilisateurs
    // Sinon: cherche dans les colonnes username et email la valeur $search
    public function getUsers($search = null);
 
    // Supprime un utilisateur
    public function delete($id);
 
}

// Charge l'utilisateur courant
$user = new User;
$user->setup();
 
// Affiche l'image de l'utilisateur, ou l'image par défaut s'il n'est pas connecté
echo '<img src="' . HTTP_ROOT . e($user->get('picture')) . '" alt=""/>';

// Charge l'utilisateur "MTC"
$user = new User;
$userExists = $user->setup('MTC', 'username');
 
if ($userExists) {
    $username = $user->get('username');
} else {
    $username = '{@VISITOR}';
}

Cette classe permet de charger et récupérer les données d'une page, ou d'utiliser les méthodes associés au pages (créer une page, modifier la barre latérale, ..).

class Page {
 
    // Le constructeur n'est pas utilisé
    public function __construct();
 
    // Initialise une page dans l'objet
    // Si aucun argument n'est passé, c'est la page courante qui est chargée
    // Exemple: $page->setup();
    // Exemple: $page->setup('nouveautes', 'slug');
    // Exemple: $page->setup(3, 'id');
    // Retourne true si l'utilisateur existe, false sinon
    // $pageType peut prendre les valeurs suivantes:
    //     "all": correspond à n'importe quel page (public comme admin)
    //     "public": correspond aux pages créées par l'utilisateur
    //     "admin": correspond aux pages du CMS: connexion, inscription, ..
    public function setup($data = REQUEST_SLUG, $type = 'slug', $pageType = 'all');
 
    // Retourne une valeur associée à la page
    // Exemple: $page->get('title');
    public function get($index);
 
    // Retourne un tableau contenant les données d'une page, en fonction de $array
    // Exemple: $page->getPage(array('id' => 3));
    // Exemple: $page->getPage(array('is_parent' => 1, 'type' => 'custom'));
    // Attention, la méthode retourne un résultat que si une et une seule page a été trouvé
    public function getPage(array $array, $pageType = 'all');
 
    // Retourne un tableau contenant toutes les pages en fonction de $array
    // Exemple: $page->getPages(array('type' => 'plugin'));
    public function getPages(array $array = null, $type = 'all');
 
    // Retourne un tableau contenant toutes les pages qui sont des dossiers
    public function getParents();
 
    // Retourne un tableau contenant toutes les pages qui sont dans un dossier
    // Note: peut lancer une exception
    public function getChilds($parent_id);
 
    // Retourne true si le slug est déjà enregistré
    // Exemple: $page->slugExist('nouveautes');
    public function slugExist($slug);
 
    // Si $value n'est pas précisé: retourne le tableau contenant les données de la page d'accueil
    // Sinon, retourne directement la valeur correspondante
    // Exemple: $page->getHomePage(); // Retourne le tableau
    // Exemple: $page->getHomePage('title'); // Retourne le titre de la page d'accueil
    public function getHomePage($value = null);
 
    // Retourne true si la page est dans un dossier
    public function isChild();
 
    // Retourne tous les modules de la barre latérale dans un tableau
    public function getSidebar();
 
    // Défini l'ordre de la barre latérale en fonction des id des modules
    // Exemple: $page->setSidebarOrder(array(3, 4, 1, 2));
    public function setSidebarOrder($order);
 
    // Met à jour le module de la barre latérale correspondant à $id
    public function updateSidebar($id, $title, $data);
 
    // Supprime le module de la barre latérale
    public function deleteSidebar($id);
 
    // Si $pageId n'est pas précisé: Supprime la page chargée dans l'objet
    // Sinon: supprime la page avec l'id $pageId
    public function delete($pageId = null);
 
    // Créé une page
    // Note: seul le titre est obligatoire
    // Note: peut lancer une exception
    public function create($title, $description = '', $is_parent = 0, 
                           $parent_id = 0, $home = 0, $content = '',
                           $header = null, $header_data = '', $p_view = 0,
                           $p_edit = 3, $type = 'custom', $type_data = '',
                           $state = 0, $position = null);
 
    // Met à jour une page avec $data
    // Exemple: $page->update(3, array('title' => 'Nouveautés'));
    // Note: peut lancer une exception
    public function update($id, $data);
 
}

// Charge la page courante
$page = new Page;
$page->setup();
 
// Affiche la description de la page
echo e($page->get('description'));

// Charge la page "Nouveautés"
$page = new Page;
$pageExists = $page->setup('nouveautes', 'slug');
 
// Met à jour la page
if ($pageExists) {
    $page->update(array('title' => 'Actualités'));
}

Cette classe est statique, et permet de récupérer ou ajouter des traductions.

class Translate {
 
    // Ajoute un dossier contenant des traductions
    // $path doit être un dossier, contenant les fichiers de langue: "fr.php", "en.php", etc..
    // Ainsi le CMS ajoute la langue du CMS, et s'il ne la trouve pas alors il utilise $defaultLanguage
    // Exemple: Translate::addPath('plugin/Slider/lang/');
    // Note: le CMS ajoute automatiquement votre dossier de langue
    public static function addPath($path, $defaultLanguage = 'en');
 
    // Retourne la traduction correspondante à $tag
    // Si la traduction n'est pas trouvé:
    //     Si $default est omis, alors le tag est retourné
    //     Sinon, $default est retourné
    // Exemple: Translate::get('abcdef'); // Retourne "abcdef"
    // Exemple: Translate::get('abcdef', '123'); // Retourne "123"
    public static function get($tag, $default = false);
 
    // Retourne la traduction et l'échappe
    // Cette méthode doit être utilisée à la place de ::get dans la plupart des cas !
    public static function escape($tag, $default = false);
 
    // Retourne toutes les traductions
    public static function getAll();
 
}

// Ajoute d'autre traductions
Translate::addPath(PLUGIN . 'Slider/extra/');
 
// Retourne la traduction, ou NULL
$translation = Translate::escape('SLIDER_TITLE', null);

Ces fonctions permettent de crypter/décrypter des données avec différentes algorithmes.

AES

Le cryptage AES permet d'encoder et de décoder des données, avec la même clé.

// Créé une clé aléatoire de 32 caractères
function aes_random_key();
 
// Encrypte $data avec la clé $key (doit être de 32 caractères)
// Si la clé n'est pas précisée, alors la constante KEY_MEDIUM est utilisée
function aes_encrypt($data, $key = KEY_MEDIUM);
 
// Décrypte $data avec la clé $key
function aes_decrypt($data, $key = KEY_MEDIUM);

RSA

Le cryptage RSA encode des données avec une clé, mais ne peut les décoder qu'avec une autre clé.

// Retourne un tableau contenant la clé publique (pour encrypter) et la clé privée (pour décrypter)
// Exemple: list($publicKey, $privateKey) = rsa_random_key();
function rsa_random_key($bits = 2048);
 
// Encrypte avec une clé publique
function rsa_encrypt($data, $publicKey);
 
// Décrypte avec une clé privée
function rsa_decrypt($data, $privateKey);
 
// Formate la clé publique pour être utilisée par les fonctions ci dessus
function rsa_format_public($key);
 
// Formate la clé privée pour être utilisée par les fonctions ci dessus
function rsa_format_private($key);
 
// Compresse la clé publique
function rsa_minify_public($key);
 
// Compresse la clé privée
function rsa_minify_private($key);

Hash

Le hashage est irréversible, c'est à dire que les données sont encryptés, mais on ne peut pas les décrypter. A utiliser pour les mots de passe.

// Créé le hash de $data, avec l'algorithme $algo
function hash_create($data, $algo = 'sha256');
 
// Vérifie si $data correspond au $hash (voir exemple plus bas)
function hash_compare($hash, $data, $algo = 'sha256');

// AES
$key = aes_random_key();
$encrypted = aes_encrypt('Bonjour !', $key);
$decrypted = aes_decrypt($encrypted, $key);
echo $decrypted; // "Bonjour !"

// RSA
list($publicKey, $privateKey) = rsa_random_key();
$encrypted = rsa_encrypt('Bonjour !', $publicKey);
$decrypted = rsa_decrypt($encrypted, $privateKey);
echo $decrypted; // "Bonjour !"

// Hash
$hash = hash_create('Bonjour !');
echo hash_compare($hash, 'Bonjour !') ? 'True' : 'False'; // "True"

Cette classe permet de gérer et modifier la session.

class Session {
 
    // Retourne la valeur associé à la clé $index
    public function get($index);
 
    // Retourne true si une valeur pour $index existe
    public function exists($index);
 
    // Modifie/Insère la valeur $value pour la clé $index
    public function set($index, $value);
 
    // Supprime la valeur associé à la clé $index
    // Si $index est omis, alors toutes les données de session sont détruites
    public function delete($index = null);
 
}

$session = new Session;
if ($session->exists('plugin.slider.start')) {
    $start = $session->get('plugin.slider.start');
} else {
    $start = 1;
}

with(new Session)->set('plugin.slider.settings', array('controller' => true));

Permet l'envoie de mail simplement, sans s'occuper de l'encodage ni du template.

Pour qu'un mail puisse être envoyé, il faut au minimum avoir renseigné:
- le destinataire
- le sujet ou le titre
- le message du mail

Si vous voulez insérer du code HTML, préférez l'utilisation des variables (exemple 1). Pour utiliser une traduction avec $mail→text(), utilisez Translate::get() pour éviter d'échapper 2 fois le texte.

class Mail {
 
    // Défini l'email de l'expéditeur, et son nom (facultatif)
    // Note: peut lancer une exception
    public function from($email, $name = null);
 
    // Défini l'email du destinataire, et son nom (facultatif)
    // Note: peut lancer une exception
    public function to($email, $name = null);
 
    // Défini le sujet de l'email
    public function subject($subject, $escape = true);
 
    // Défini le titre de l'email
    public function title($title, $escape = true);
 
    // Défini le message du mail (sera échappé)
    public function text($message);
 
    // Défini le html du mail (ne sera pas échappé)
    public function html($html);
 
    // Ajoute une paire de clé / valeur à remplacer
    public function bind($key, $value);
 
    // Envoie le mail
    // Note: peut lancer une exception
    public function send();
 
}

// Lien du site
$url = e(URL . HTTP_ROOT);
 
// Création du mail
$mail = new Mail;
 
// Destinataire
$mail->to('john@gmail.com');
 
// Définition du sujet
// Si le titre n'est pas précisé, alors le sujet sera aussi utilisé comme titre et inversement
$mail->subject('Hého !');
 
// Le message sera échappé, donc pas de problème d'accent/code HTML
$mail->text("Bonjour,\n Rends toi sur notre site ! \n Clique >>> %link%");
 
// Les variables sont directement remplacées, donc utile pour insérer du code HTML
$mail->bind('link', '<a href="' . $url . '">' . $url . '</a>');
 
$mail->send();

$mail = new Mail;
$mail->to('jane@outlook.com');
$mail->subject('< Coucou >');
$mail->html('Ce texte ne sera pas échappé, attention au code HTML ! <br> &raquo; Bye !');
$mail->send();

Le parser permet de charger du code HTML et de gérer les blocks (voir l'exemple concret sur la page Contenu).

Commencez par les exemples pour comprendre comment fonctionne la classe.

Pour comprendre son fonctionnement, regardez comment les plugins "Slider" et "Blog" utilise cette classe. A noter que la classe n'est pas du tout obligatoire, vous pouvez même utiliser d'autre modèles de blocks pour vos templates si vous le voulez.

class Parser {
 
    // Charge le code HTML depuis un fichier et parse les blocks
    public function loadFile($file, $blocks = array());
 
    // Charge le code HTML depuis une chaîne de caractère et parse les blocks
    public function loadString($string, $blocks = array());
 
    // Ajoute une variable qui sera remplacé à la fin
    // $key peut être un tableau de plusieurs key => value
    public function bind($key, $value = null);
 
    // Génère le code HTML final
    public function render();
 
    // Les méthodes ci dessous dépendent d'un block
 
    // Retourne le HTML d'un block
    public function getHtml();
 
    // Remplace le HTML d'un block par $html
    public function replace($html);
 
    // Ajoute un block
    // Si $vars est un tableau, les variables sont remplacées
    public function add($vars = array());
 
    // Parse le block
    // Si $vars ets un tableau, les variables sont remplacées
    public function parse($vars = array());
 
    // Le block est ajouté si $test est vrai
    public function addIf($test, $vars = array());
 
    // Le block est parsé si $test est vrai, sinon il est supprimé
    public function parseIf($test, $vars = array());
 
    // Supprime le block
    public function remove();
 
}

slider.htm

<div class="slider">
    <!-- %SLIDER_BLOCK% -->
    <div style="width: 100%; background: url(%PICTURE%); background-size: cover;">
        <h1>%TITLE%</h1>
    </div>
    <!-- %SLIDER_BLOCK% -->
    <a href="#">« {@PREVIOUS}</a> - <a href="#">{@NEXT} »</a>
</div>

core.php

<?php
 
defined('IN_ENV') or die;
 
$data = json_decode($data, true);
 
// Si aucun slide n'est configuré, on n'affiche rien
if (!is_array($data) or empty($data))
    return false;
 
// Récupère le fichier slider.htm du thème ou du plugin
$parser = new Parser;
$html = $parser->loadFile($template . 'slider.htm', array(
    'SLIDER_BLOCK'
));
 
foreach ($data['slide'] as $slide) {
 
    // On accède au block "SLIDER_BLOCK", et on ajoute des blocks à la suite
    $parser->slider_block->add(array(
        'TITLE' => e($slide['title']),
        'PICTURE' => e($slide['picture'])
    ));
 
}
 
return $parser->render();

Cette classe est statique, et permet d'ajouter du CSS, Javascript, ou de récupérer le HTML entre les tags PHP.

class Html {
 
    // Retourne la variable $key (par exemple "css", "js", ou "variables")
    public static function get($key);
 
    // Ajoute du CSS à la page qui sera affichée, avant la fin de la balise </head>
    // $style: CSS à ajouter, peut être un lien vers un fichier ou du CSS directement
    // Si $mode = "auto", alors la classe devinera si vous tentez d'ajouter un fichier, du style, ou du code autre
    // Si $mode = "style" ou "inline", le code sera inséré dans des balises "<style>"
    // Si $mode = "stylesheet" ou "url", le code sera inséré avec cette balise: <link href="xxx">
    // Si $mode = "free", alors le code sera inséré directement sans modification
    // Exemple: Html::CSS(HTTP_ROOT . $template . 'style.css'); // Ajoute un lien vers le fichier
    // Exemple: Html::CSS('<style>body { color: red; } </style>'); // Ajoute le style
    // Exemple: Html::CSS('<meta name="description" content="Super page !" />', 'free'); // Ajoute le code brut
    public static function CSS($style = false, $mode = 'auto');
 
    // Ajoute du JS à la page qui sera affichée, avant la fin de la balise </body>
    // $script: JS à ajouter, peut être un lien vers un fichier ou du JS directement
    // Si $mode = "auto", alors la classe devinera si vous tentez d'ajouter un fichier, un script, ou du code autre
    // Si $mode = "script" ou "inline", le code sera inséré dans des balises "<script>"
    // Si $mode = "src" ou "url", le code sera inséré avec cette balise: <script src="xxx">
    // Si $mode = "free", alors le code sera inséré directement sans modification
    // Exemple: Html::JS(HTTP_ROOT . $template . 'script.js'); // Ajoute un lien vers le fichier
    // Exemple: Html::JS('<script>alert('It works !');</script>'); // Ajoute le script
    // Exemple: Html::JS('<h1>Super page !</h1>', 'free'); // Ajoute le code brut
    public static function JS($script = false, $mode = 'auto');
 
    // Ajoute une variable, qui sera parsé à l'affichage de la page au format {TAG}
    // La valeur est automatiquement échappée
    // $replace: si true et si la clé $key existe déjà, remplace l'ancienne variable
    public static function bind($key, $value, $replace = false);
 
    // Ajoute une variable, qui sera parsé à l'affichage de la page au format {TAG}
    // La valeur n'est pas échappée
    // $replace: si true et si la clé $key existe déjà, remplace l'ancienne variable
    public static function bindRaw($key, $value, $replace = false);
 
    // Retourne une variable
    public static function getVar($key);
 
    // Capture tout ce qui va être affiché à l'écran (via echo ou les tags PHP)
    public static function listen();
 
    // Récupère tout ce qui est sorti depuis le dernier listen()
    // Si $vars est un tableau, les variables sont remplacés
    // Si $format = true, alors des "%" sont ajoutés aux tags des variables
    public static function output($vars = null, $format = true);
 
    // Parse les variables dans $content
    // Si $vars est un tableau, les variables sont remplacés
    // Si $format = true, alors des "%" sont ajoutés aux tags des variables
    public static function parse($content, $vars, $format = true);
 
    // Récupère le contenu d'un fichier s'il existe, et parse les variables s'il y en a
    public static function file($file, $vars = null, $format = true);
 
}

Html::listen();
?>
Bonjour !
Je suis %name%.
<?php
$html = Html::output(array('name' => 'John'));

Html::listen();
?>
<!-- Pratique pour afficher la syntaxe javascript avec un éditeur de texte comme notepad ou sublime text -->
<script>
function display() {
    alert('Bonjour !');
}
</script>
<?php
// Aucun n'argument n'est passé, alors Html utilise output() et l'ajoute au code JS de la page
// Le code ci dessus sera à la fin de la page courante
Html::JS();

Page suivante: Requête POST