1535 lines
43 KiB
PHP
1535 lines
43 KiB
PHP
<?php
|
|
|
|
/**
|
|
* This file is part of Zwii.
|
|
* For full copyright and license information, please see the LICENSE
|
|
* file that was distributed with this source code.
|
|
*
|
|
* @author Rémi Jean <remi.jean@outlook.com>
|
|
* @copyright Copyright (C) 2008-2018, Rémi Jean
|
|
* @author Frédéric Tempez <frederic.tempez@outlook.com>
|
|
* @copyright Copyright (C) 2018-2024, Frédéric Tempez
|
|
* @license CC Attribution-NonCommercial-NoDerivatives 4.0 International
|
|
* @link http://zwiicms.fr/
|
|
*/
|
|
|
|
|
|
|
|
class common
|
|
{
|
|
|
|
const DISPLAY_RAW = 0;
|
|
const DISPLAY_JSON = 1;
|
|
const DISPLAY_RSS = 2;
|
|
const DISPLAY_LAYOUT_BLANK = 3;
|
|
const DISPLAY_LAYOUT_MAIN = 4;
|
|
const DISPLAY_LAYOUT_LIGHT = 5;
|
|
const GROUP_BANNED = -1;
|
|
const GROUP_VISITOR = 0;
|
|
const GROUP_MEMBER = 1;
|
|
const GROUP_EDITOR = 2;
|
|
// Groupe MODERATOR, compatibilité avec les anciens modules :
|
|
const GROUP_MODERATOR = 2;
|
|
const GROUP_ADMIN = 3;
|
|
const SIGNATURE_ID = 1;
|
|
const SIGNATURE_PSEUDO = 2;
|
|
const SIGNATURE_FIRSTLASTNAME = 3;
|
|
const SIGNATURE_LASTFIRSTNAME = 4;
|
|
// Dossier de travail
|
|
const BACKUP_DIR = 'site/backup/';
|
|
const DATA_DIR = 'site/data/';
|
|
const FILE_DIR = 'site/file/';
|
|
const TEMP_DIR = 'site/tmp/';
|
|
const I18N_DIR = 'site/i18n/';
|
|
const MODULE_DIR = 'module/';
|
|
|
|
// Miniatures de la galerie
|
|
const THUMBS_SEPARATOR = 'mini_';
|
|
const THUMBS_WIDTH = 640;
|
|
|
|
// Contrôle d'édition temps maxi en secondes avant déconnexion 30 minutes
|
|
const ACCESS_TIMER = 1800;
|
|
|
|
// Numéro de version
|
|
const ZWII_VERSION = '1.9.00';
|
|
|
|
// URL autoupdate
|
|
const ZWII_UPDATE_URL = 'https://forge.chapril.org/ZwiiCMS-Team/campus-update/raw/branch/master/';
|
|
const ZWII_UPDATE_CHANNEL = 'v1';
|
|
|
|
// Valeurs possibles multiple de 10, 10 autorise 9 profils, 100 autorise 99 profils
|
|
const MAX_PROFILS = 10;
|
|
|
|
// Constantes pourles contenus
|
|
|
|
// Modalités d'ouverture
|
|
const COURSE_ACCESS_OPEN = 0;
|
|
const COURSE_ACCESS_DATE = 1;
|
|
const COURSE_ACCESS_CLOSE = 2;
|
|
// Modalités d'inscription
|
|
const COURSE_ENROLMENT_GUEST = 0;
|
|
const COURSE_ENROLMENT_SELF = 1; // Ouvert à tous les membres
|
|
const COURSE_ENROLMENT_SELF_KEY = 2; // Ouvert à tous les membres disposant de la clé
|
|
const COURSE_ENROLMENT_MANDATORY = 3;
|
|
|
|
|
|
public static $actions = [];
|
|
public static $coreModuleIds = [
|
|
'config',
|
|
'course',
|
|
'install',
|
|
'language',
|
|
'maintenance',
|
|
'page',
|
|
'plugin',
|
|
'sitemap',
|
|
'theme',
|
|
'user'
|
|
];
|
|
public static $concurrentAccess = [
|
|
'config',
|
|
'edit',
|
|
'language',
|
|
'plugin',
|
|
'theme',
|
|
'user',
|
|
];
|
|
private $data = [];
|
|
private $hierarchy = [
|
|
'all' => [],
|
|
'visible' => [],
|
|
'bar' => []
|
|
];
|
|
private $input = [
|
|
'_COOKIE' => [],
|
|
'_POST' => []
|
|
];
|
|
public static $inputBefore = [];
|
|
public static $inputNotices = [];
|
|
public static $importNotices = [];
|
|
public static $coreNotices = [];
|
|
public $output = [
|
|
'access' => true,
|
|
'content' => '',
|
|
'contentLeft' => '',
|
|
'contentRight' => '',
|
|
'display' => self::DISPLAY_LAYOUT_MAIN,
|
|
'metaDescription' => '',
|
|
'metaTitle' => '',
|
|
'notification' => '',
|
|
'redirect' => '',
|
|
'script' => '',
|
|
'showBarEditButton' => false,
|
|
'showPageContent' => false,
|
|
'state' => false,
|
|
'style' => '',
|
|
'inlineStyle' => [],
|
|
'inlineScript' => [],
|
|
'title' => null,
|
|
// Null car un titre peut être vide
|
|
// Trié par ordre d'exécution
|
|
'vendor' => [
|
|
'jquery',
|
|
'normalize',
|
|
'lity',
|
|
'filemanager',
|
|
// 'tinycolorpicker', Désactivé par défaut
|
|
// 'tinymce', Désactivé par défaut
|
|
// 'codemirror', // Désactivé par défaut
|
|
'tippy',
|
|
'zwiico',
|
|
//'imagemap',
|
|
'simplelightbox',
|
|
//'datatables', désactivé par défaut
|
|
],
|
|
'view' => ''
|
|
];
|
|
public static $groups = [
|
|
self::GROUP_BANNED => 'Banni',
|
|
self::GROUP_VISITOR => 'Visiteur',
|
|
self::GROUP_MEMBER => 'Étudiant',
|
|
self::GROUP_EDITOR => 'Formateur',
|
|
self::GROUP_ADMIN => 'Administrateur'
|
|
];
|
|
public static $groupEdits = [
|
|
self::GROUP_BANNED => 'Banni',
|
|
self::GROUP_MEMBER => 'Étudiant',
|
|
self::GROUP_EDITOR => 'Formateur',
|
|
self::GROUP_ADMIN => 'Administrateur'
|
|
];
|
|
public static $groupNews = [
|
|
self::GROUP_MEMBER => 'Étudiant',
|
|
self::GROUP_EDITOR => 'Formateur',
|
|
self::GROUP_ADMIN => 'Administrateur'
|
|
];
|
|
public static $groupPublics = [
|
|
self::GROUP_VISITOR => 'Visiteur',
|
|
self::GROUP_MEMBER => 'Étudiant',
|
|
self::GROUP_EDITOR => 'Formateur',
|
|
self::GROUP_ADMIN => 'Administrateur'
|
|
];
|
|
|
|
//Langues de l'UI
|
|
// Langue de l'interface, tableau des dialogues
|
|
public static $dialog;
|
|
// Langue de l'interface sélectionnée
|
|
public static $i18nUI = 'fr_FR';
|
|
// Langues de contenu
|
|
public static $siteContent = 'home';
|
|
|
|
public static $languages = [
|
|
'de' => 'Deutsch',
|
|
'en_EN' => 'English',
|
|
'es' => 'Español',
|
|
'fr_FR' => 'Français',
|
|
'gr_GR' => 'Ελληνικά',
|
|
'it' => 'Italiano',
|
|
'pt_PT' => 'Português',
|
|
'tr_TR' => 'Türkçe',
|
|
// source: http://en.wikipedia.org/wiki/List_of_ISO_639-1_codes
|
|
];
|
|
|
|
|
|
// Zone de temps
|
|
public static $timezone;
|
|
private $url = '';
|
|
// Données de site
|
|
private $user = [];
|
|
|
|
// Descripteur de données Entrées / Sorties
|
|
// Liste ici tous les fichiers de données
|
|
public $dataFiles = [
|
|
'admin' => '',
|
|
'blacklist' => '',
|
|
'config' => '',
|
|
'core' => '',
|
|
'course' => '',
|
|
'font' => '',
|
|
'module' => '',
|
|
'page' => '',
|
|
'theme' => '',
|
|
'user' => '',
|
|
'language' => '',
|
|
'profil' => '',
|
|
'enrolment' => '',
|
|
'category' => '',
|
|
];
|
|
|
|
private $configFiles = [
|
|
'admin' => '',
|
|
'blacklist' => '',
|
|
'config' => '',
|
|
'course' => '',
|
|
'core' => '',
|
|
'font' => '',
|
|
'user' => '',
|
|
'language' => '',
|
|
'profil' => '',
|
|
'enrolment' => '',
|
|
'category' => '',
|
|
];
|
|
|
|
private $contentFiles = [
|
|
'page' => '',
|
|
'module' => '',
|
|
'theme' => '',
|
|
];
|
|
|
|
public static $fontsWebSafe = [
|
|
'arial' => [
|
|
'name' => 'Arial',
|
|
'font-family' => 'Arial, Helvetica, sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'arial-black' => [
|
|
'name' => 'Arial Black',
|
|
'font-family' => '\'Arial Black\', Gadget, sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'courrier' => [
|
|
'name' => 'Courier',
|
|
'font-family' => 'Courier, \'Liberation Mono\', monospace',
|
|
'resource' => 'websafe'
|
|
],
|
|
'courrier-new' => [
|
|
'name' => 'Courier New',
|
|
'font-family' => '\'Courier New\', Courier, monospace',
|
|
'resource' => 'websafe'
|
|
],
|
|
'garamond' => [
|
|
'name' => 'Garamond',
|
|
'font-family' => 'Garamond, serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'georgia' => [
|
|
'name' => 'Georgia',
|
|
'font-family' => 'Georgia, serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'impact' => [
|
|
'name' => 'Impact',
|
|
'font-family' => 'Impact, Charcoal, sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'lucida' => [
|
|
'name' => 'Lucida',
|
|
'font-family' => '\'Lucida Sans Unicode\', \'Lucida Grande\', sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'tahoma' => [
|
|
'name' => 'Tahoma',
|
|
'font-family' => 'Tahoma, Geneva, sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'times-new-roman' => [
|
|
'name' => 'Times New Roman',
|
|
'font-family' => '\'Times New Roman\', \'Liberation Serif\', serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'trebuchet' => [
|
|
'name' => 'Trebuchet',
|
|
'font-family' => '\'Trebuchet MS\', Arial, Helvetica, sans-serif',
|
|
'resource' => 'websafe'
|
|
],
|
|
'verdana' => [
|
|
'name' => 'Verdana',
|
|
'font-family' => 'Verdana, Geneva, sans-serif;',
|
|
'resource' => 'websafe'
|
|
]
|
|
];
|
|
|
|
// Boutons de navigation dans la page
|
|
public static $navIconTemplate = [
|
|
'open' => [
|
|
'left' => 'left-open',
|
|
'right' => 'right-open',
|
|
],
|
|
'dir' => [
|
|
'left' => 'left',
|
|
'right' => 'right-dir',
|
|
],
|
|
'big' => [
|
|
'left' => 'left-big',
|
|
'right' => 'right-big',
|
|
],
|
|
];
|
|
|
|
/**
|
|
* Constructeur commun
|
|
*/
|
|
public function __construct()
|
|
{
|
|
|
|
// Extraction des données http
|
|
if (isset($_POST)) {
|
|
$this->input['_POST'] = $_POST;
|
|
}
|
|
if (isset($_COOKIE)) {
|
|
$this->input['_COOKIE'] = $_COOKIE;
|
|
}
|
|
|
|
// Déterminer le contenu du site
|
|
if (isset($_SESSION['ZWII_SITE_CONTENT'])) {
|
|
// Déterminé par la session présente
|
|
self::$siteContent = $_SESSION['ZWII_SITE_CONTENT'];
|
|
}
|
|
|
|
// Instanciation de la classe des entrées / sorties
|
|
// Les fichiers de configuration
|
|
foreach ($this->configFiles as $module => $value) {
|
|
$this->initDB($module);
|
|
}
|
|
// Les fichiers des contenus
|
|
foreach ($this->contentFiles as $module => $value) {
|
|
$this->initDB($module, self::$siteContent);
|
|
}
|
|
|
|
// Installation fraîche, initialisation de la configuration inexistante
|
|
// Nécessaire pour le constructeur
|
|
if ($this->user === []) {
|
|
// Charge la configuration
|
|
foreach ($this->configFiles as $stageId => $item) {
|
|
if (file_exists(self::DATA_DIR . $stageId . '.json') === false) {
|
|
$this->saveConfig($stageId);
|
|
}
|
|
}
|
|
// Charge le site d'accueil
|
|
foreach ($this->contentFiles as $stageId => $item) {
|
|
if (
|
|
file_exists(self::DATA_DIR . self::$siteContent . '/' . $stageId . '.json') === false
|
|
) {
|
|
$this->initData($stageId, self::$siteContent);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Récupère un utilisateur connecté
|
|
if ($this->user === []) {
|
|
$this->user = $this->getData(['user', $this->getInput('ZWII_USER_ID')]);
|
|
}
|
|
|
|
// Langue de l'administration si le user est connecté
|
|
if ($this->getData(['user', $this->getUser('id'), 'language'])) {
|
|
// Langue sélectionnée dans le compte, la langue du cookie sinon celle du compte ouvert
|
|
self::$i18nUI = $this->getData(['user', $this->getUser('id'), 'language']);
|
|
// Validation de la langue
|
|
self::$i18nUI = isset(self::$i18nUI) && file_exists(self::I18N_DIR . self::$i18nUI . '.json')
|
|
? self::$i18nUI
|
|
: 'fr_FR';
|
|
} else {
|
|
if (isset($_SESSION['ZWII_UI'])) {
|
|
self::$i18nUI = $_SESSION['ZWII_UI'];
|
|
} elseif (isset($_COOKIE['ZWII_UI'])) {
|
|
self::$i18nUI = $_COOKIE['ZWII_UI'];
|
|
} else {
|
|
self::$i18nUI = 'fr_FR';
|
|
}
|
|
$_SESSION['ZWII_UI'] = self::$i18nUI;
|
|
}
|
|
// Stocker le cookie de langue pour l'éditeur de texte ainsi que l'url du contenu pour le theme
|
|
setcookie('ZWII_UI', self::$i18nUI, time() + 3600, '', '', false, false);
|
|
// Stocker l'courseId pour le thème de TinyMCE
|
|
setcookie('ZWII_SITE_CONTENT', self::$siteContent, time() + 3600, '', '', false, false);
|
|
setlocale(LC_ALL, self::$i18nUI);
|
|
|
|
// Construit la liste des pages parents/enfants
|
|
if ($this->hierarchy['all'] === []) {
|
|
$this->buildHierarchy();
|
|
}
|
|
|
|
// Construit l'url
|
|
if ($this->url === '') {
|
|
if ($url = $_SERVER['QUERY_STRING']) {
|
|
$this->url = $url;
|
|
} else {
|
|
$this->url = $this->homePageId();
|
|
}
|
|
}
|
|
|
|
// Chargement des dialogues
|
|
if (!file_exists(self::I18N_DIR . self::$i18nUI . '.json')) {
|
|
// Copie des fichiers de langue par défaut fr_FR si pas initialisé
|
|
$this->copyDir('core/module/install/ressource/i18n', self::I18N_DIR);
|
|
}
|
|
self::$dialog = json_decode(file_get_contents(self::I18N_DIR . self::$i18nUI . '.json'), true);
|
|
|
|
// Dialogue du module
|
|
if ($this->getData(['page', $this->getUrl(0), 'moduleId'])) {
|
|
$moduleId = $this->getData(['page', $this->getUrl(0), 'moduleId']);
|
|
if (
|
|
is_dir(self::MODULE_DIR . $moduleId . '/i18n')
|
|
&& file_exists(self::MODULE_DIR . $moduleId . '/i18n/' . self::$i18nUI . '.json')
|
|
) {
|
|
$d = json_decode(file_get_contents(self::MODULE_DIR . $moduleId . '/i18n/' . self::$i18nUI . '.json'), true);
|
|
self::$dialog = array_merge(self::$dialog, $d);
|
|
}
|
|
}
|
|
|
|
// Données de proxy
|
|
$proxy = $this->getData(['config', 'proxyType']) . $this->getData(['config', 'proxyUrl']) . ':' . $this->getData(['config', 'proxyPort']);
|
|
if (
|
|
!empty($this->getData(['config', 'proxyUrl'])) &&
|
|
!empty($this->getData(['config', 'proxyPort']))
|
|
) {
|
|
$context = array(
|
|
'http' => array(
|
|
'proxy' => $proxy,
|
|
'request_fulluri' => true,
|
|
'verify_peer' => false,
|
|
'verify_peer_name' => false,
|
|
),
|
|
'ssl' => array(
|
|
'verify_peer' => false,
|
|
'verify_peer_name' => false
|
|
)
|
|
);
|
|
stream_context_set_default($context);
|
|
}
|
|
|
|
// Mise à jour des données core
|
|
include ('core/include/update.inc.php');
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Ajoute les valeurs en sortie
|
|
* @param array $output Valeurs en sortie
|
|
*/
|
|
public function addOutput($output)
|
|
{
|
|
$this->output = array_merge($this->output, $output);
|
|
}
|
|
|
|
/**
|
|
* Ajoute une notice de champ obligatoire
|
|
* @param string $key Clef du champ
|
|
*/
|
|
public function addRequiredInputNotices($key)
|
|
{
|
|
// La clef est un tableau
|
|
if (preg_match('#\[(.*)\]#', $key, $secondKey)) {
|
|
$firstKey = explode('[', $key)[0];
|
|
$secondKey = $secondKey[1];
|
|
if (empty($this->input['_POST'][$firstKey][$secondKey])) {
|
|
common::$inputNotices[$firstKey . '_' . $secondKey] = helper::translate('Obligatoire');
|
|
}
|
|
}
|
|
// La clef est une chaine
|
|
elseif (empty($this->input['_POST'][$key])) {
|
|
common::$inputNotices[$key] = helper::translate('Obligatoire');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check du token CSRF (true = bo
|
|
*/
|
|
public function checkCSRF()
|
|
{
|
|
return ((empty($_POST['csrf']) or hash_equals($_POST['csrf'], $_SESSION['csrf']) === false) === false);
|
|
}
|
|
|
|
/**
|
|
* Supprime des données
|
|
* @param array $keys Clé(s) des données
|
|
*/
|
|
public function deleteData($keys)
|
|
{
|
|
// Descripteur de la base
|
|
$db = $this->dataFiles[$keys[0]];
|
|
// Initialisation de la requête par le nom de la base
|
|
$query = $keys[0];
|
|
// Construire la requête
|
|
for ($i = 1; $i <= count($keys) - 1; $i++) {
|
|
$query .= '.' . $keys[$i];
|
|
}
|
|
// Effacer la donnée
|
|
$success = $db->delete($query, true);
|
|
return is_object($success);
|
|
}
|
|
|
|
/**
|
|
* Sauvegarde des données
|
|
* @param array $keys Clé(s) des données
|
|
*/
|
|
public function setData($keys = [])
|
|
{
|
|
// Pas d'enregistrement lorsqu'une notice est présente ou tableau transmis vide
|
|
if (
|
|
!empty(self::$inputNotices)
|
|
or empty($keys)
|
|
) {
|
|
return false;
|
|
}
|
|
|
|
// Empêcher la sauvegarde d'une donnée nulle.
|
|
if (gettype($keys[count($keys) - 1]) === NULL) {
|
|
return false;
|
|
}
|
|
|
|
// Initialisation du retour en cas d'erreur de descripteur
|
|
$success = false;
|
|
// Construire la requête dans la base inf à 1 retourner toute la base
|
|
if (count($keys) >= 1) {
|
|
// Descripteur de la base
|
|
$db = $this->dataFiles[$keys[0]];
|
|
$query = $keys[0];
|
|
// Construire la requête
|
|
// Ne pas tenir compte du dernier élément qui une une value donc <
|
|
for ($i = 1; $i < count($keys) - 1; $i++) {
|
|
$query .= '.' . $keys[$i];
|
|
}
|
|
// Appliquer la modification, le dernier élément étant la donnée à sauvegarder
|
|
$success = is_object($db->set($query, $keys[count($keys) - 1], true));
|
|
}
|
|
return $success;
|
|
}
|
|
|
|
/**
|
|
* Accède aux données
|
|
* @param array $keys Clé(s) des données
|
|
* @return mixed
|
|
*/
|
|
public function getData($keys = [])
|
|
{
|
|
// Eviter une requete vide
|
|
if (count($keys) >= 1) {
|
|
// descripteur de la base
|
|
$db = $this->dataFiles[$keys[0]];
|
|
$query = $keys[0];
|
|
// Construire la requête
|
|
for ($i = 1; $i < count($keys); $i++) {
|
|
$query .= '.' . $keys[$i];
|
|
}
|
|
return $db->get($query);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Lire les données de la page
|
|
* @param string pageId
|
|
* @param string langue
|
|
* @return string contenu de la page
|
|
*/
|
|
public function getPage($page, $course)
|
|
{
|
|
|
|
// Le nom de la ressource et le fichier de contenu sont définis :
|
|
if (
|
|
$this->getData(['page', $page, 'content']) !== ''
|
|
&& file_exists(self::DATA_DIR . $course . '/content/' . $this->getData(['page', $page, 'content']))
|
|
) {
|
|
return file_get_contents(self::DATA_DIR . $course . '/content/' . $this->getData(['page', $page, 'content']));
|
|
} else {
|
|
return 'Aucun contenu trouvé.';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ecrire les données de la page
|
|
* @param string pageId
|
|
* @param string contenu de la page
|
|
* @return int nombre d'octets écrits ou erreur
|
|
*/
|
|
public function setPage($page, $value, $path)
|
|
{
|
|
|
|
return $this->secure_file_put_contents(self::DATA_DIR . $path . '/content/' . $page . '.html', $value);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Effacer les données de la page
|
|
* @param string pageId
|
|
* @return bool statut de l'effacement
|
|
*/
|
|
public function deletePage($page, $course)
|
|
{
|
|
return unlink(self::DATA_DIR . $course . '/content/' . $this->getData(['page', $page, 'content']));
|
|
}
|
|
|
|
|
|
/**
|
|
* Écrit les données dans un fichier avec plusieurs tentatives d'écriture et verrouillage
|
|
*
|
|
* @param string $filename Le nom du fichier
|
|
* @param array $data Les données à écrire dans le fichier
|
|
* @param int $flags Les drapeaux optionnels à passer à la fonction $this->secure_file_put_contents
|
|
* @return bool True si l'écriture a réussi, sinon false
|
|
*/
|
|
function secure_file_put_contents($filename, $data, $flags = 0)
|
|
{
|
|
|
|
// Initialise le compteur de tentatives
|
|
$attempts = 0;
|
|
|
|
// Convertit les données en chaîne de caractères
|
|
$serialized_data = serialize($data);
|
|
|
|
// Vérifie la longueur des données
|
|
$data_length = strlen($serialized_data);
|
|
|
|
// Effectue jusqu'à 5 tentatives d'écriture
|
|
while ($attempts < 5) {
|
|
// Essaye d'écrire les données dans le fichier avec verrouillage exclusif
|
|
$write_result = file_put_contents($filename, $data, LOCK_EX | $flags);
|
|
|
|
// Vérifie si l'écriture a réussi
|
|
if ($write_result !== false && $write_result === $data_length) {
|
|
// Sort de la boucle si l'écriture a réussi
|
|
return true;
|
|
}
|
|
|
|
// Incrémente le compteur de tentatives
|
|
$attempts++;
|
|
}
|
|
|
|
// Échec de l'écriture après plusieurs tentatives
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
public function initDB($module, $path = '')
|
|
{
|
|
// Instanciation de la classe des entrées / sorties
|
|
// Constructeur JsonDB;
|
|
$this->dataFiles[$module] = new \Prowebcraft\JsonDb([
|
|
'name' => $module . '.json',
|
|
'dir' => empty($path) ? self::DATA_DIR : self::DATA_DIR . $path . '/',
|
|
'backup' => file_exists('site/data/.backup')
|
|
]);
|
|
|
|
}
|
|
|
|
/**
|
|
* Initialisation des données sur un contenu ou la page d'accueil
|
|
* @param string $course : id du module à générer
|
|
* @param string $path : le dossier à créer
|
|
* Données valides : page ou module
|
|
*/
|
|
|
|
public function initData($module, $path)
|
|
{
|
|
|
|
// Tableau avec les données vierges
|
|
require_once ('core/module/install/ressource/defaultdata.php');
|
|
|
|
// L'arborescence
|
|
if (!file_exists(self::DATA_DIR . $path)) {
|
|
mkdir(self::DATA_DIR . $path, 0755);
|
|
}
|
|
if (!file_exists(self::DATA_DIR . $path . '/content')) {
|
|
mkdir(self::DATA_DIR . $path . '/content', 0755);
|
|
}
|
|
|
|
/*
|
|
* Le site d'accueil, home ne dispose pas des mêmes modèles
|
|
*/
|
|
$template = $path === 'home' ? init::$siteTemplate : init::$courseDefault;
|
|
// Création de page ou de module
|
|
$this->setData([$module, $template[$module]]);
|
|
// Création des pages
|
|
if ($module === 'page') {
|
|
$content = $path === 'home' ? init::$siteContent : init::$courseContent;
|
|
foreach ($content as $key => $value) {
|
|
$this->setPage($key, $value, $path);
|
|
}
|
|
}
|
|
|
|
common::$coreNotices[] = $module;
|
|
|
|
}
|
|
/**
|
|
* Initialisation des données
|
|
* @param string $module : if du module à générer
|
|
* choix valides : core config user theme page module
|
|
*/
|
|
public function saveConfig($module)
|
|
{
|
|
// Tableau avec les données vierges
|
|
require_once ('core/module/install/ressource/defaultdata.php');
|
|
// Installation des données des autres modules cad theme profil font config, admin et core
|
|
$this->setData([$module, init::$defaultData[$module]]);
|
|
common::$coreNotices[] = $module;
|
|
}
|
|
|
|
|
|
/**
|
|
* Accède à la liste des pages parents et de leurs enfants
|
|
* @param int $parentId Id de la page parent
|
|
* @param bool $onlyVisible Affiche seulement les pages visibles
|
|
* @param bool $onlyBlock Affiche seulement les pages de type barre
|
|
* @return array
|
|
*/
|
|
public function getHierarchy($parentId = null, $onlyVisible = true, $onlyBlock = false)
|
|
{
|
|
$hierarchy = $onlyVisible ? $this->hierarchy['visible'] : $this->hierarchy['all'];
|
|
$hierarchy = $onlyBlock ? $this->hierarchy['bar'] : $hierarchy;
|
|
// Enfants d'un parent
|
|
if ($parentId) {
|
|
if (array_key_exists($parentId, $hierarchy)) {
|
|
return $hierarchy[$parentId];
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
// Parents et leurs enfants
|
|
else {
|
|
return $hierarchy;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fonction pour construire le tableau des pages
|
|
*/
|
|
|
|
private function buildHierarchy()
|
|
{
|
|
|
|
$pages = helper::arrayColumn($this->getData(['page']), 'position', 'SORT_ASC');
|
|
// Parents
|
|
foreach ($pages as $pageId => $pagePosition) {
|
|
if (
|
|
// Page parent
|
|
$this->getData(['page', $pageId, 'parentPageId']) === ""
|
|
// Ignore les pages dont l'utilisateur n'a pas accès
|
|
and ($this->getData(['page', $pageId, 'group']) === self::GROUP_VISITOR
|
|
or ($this->getUser('password') === $this->getInput('ZWII_USER_PASSWORD')
|
|
//and $this->getUser('group') >= $this->getData(['page', $pageId, 'group'])
|
|
// Modification qui tient compte du profil de la page
|
|
and ($this->getUser('group') * self::MAX_PROFILS + $this->getUser('profil')) >= ($this->getData(['page', $pageId, 'group']) * self::MAX_PROFILS + $this->getData(['page', $pageId, 'profil']))
|
|
|
|
)
|
|
)
|
|
) {
|
|
if ($pagePosition !== 0) {
|
|
$this->hierarchy['visible'][$pageId] = [];
|
|
}
|
|
if ($this->getData(['page', $pageId, 'block']) === 'bar') {
|
|
$this->hierarchy['bar'][$pageId] = [];
|
|
}
|
|
$this->hierarchy['all'][$pageId] = [];
|
|
}
|
|
}
|
|
// Enfants
|
|
foreach ($pages as $pageId => $pagePosition) {
|
|
|
|
if (
|
|
// Page parent
|
|
$parentId = $this->getData(['page', $pageId, 'parentPageId'])
|
|
// Ignore les pages dont l'utilisateur n'a pas accès
|
|
and (
|
|
(
|
|
$this->getData(['page', $pageId, 'group']) === self::GROUP_VISITOR
|
|
and
|
|
$this->getData(['page', $parentId, 'group']) === self::GROUP_VISITOR
|
|
)
|
|
or (
|
|
$this->getUser('password') === $this->getInput('ZWII_USER_PASSWORD')
|
|
and
|
|
$this->getUser('group') * self::MAX_PROFILS + $this->getUser('profil')) >= ($this->getData(['page', $pageId, 'group']) * self::MAX_PROFILS + $this->getData(['page', $pageId, 'profil'])
|
|
|
|
)
|
|
)
|
|
) {
|
|
if ($pagePosition !== 0) {
|
|
$this->hierarchy['visible'][$parentId][] = $pageId;
|
|
}
|
|
if ($this->getData(['page', $pageId, 'block']) === 'bar') {
|
|
$this->hierarchy['bar'][$pageId] = [];
|
|
}
|
|
$this->hierarchy['all'][$parentId][] = $pageId;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Génère un fichier json avec la liste des pages
|
|
*
|
|
*/
|
|
private function tinyMcePages()
|
|
{
|
|
// Sauve la liste des pages pour TinyMCE
|
|
$parents = [];
|
|
$rewrite = (helper::checkRewrite()) ? '' : '?';
|
|
// Boucle de recherche des pages actives
|
|
foreach ($this->getHierarchy(null, false, false) as $parentId => $childIds) {
|
|
$children = [];
|
|
// Exclure les barres
|
|
if ($this->getData(['page', $parentId, 'block']) !== 'bar') {
|
|
// Boucler sur les enfants et récupérer le tableau children avec la liste des enfants
|
|
foreach ($childIds as $childId) {
|
|
$children[] = [
|
|
'title' => '↳' . html_entity_decode($this->getData(['page', $childId, 'title']), ENT_QUOTES),
|
|
'value' => $rewrite . $childId
|
|
];
|
|
}
|
|
// Traitement
|
|
if (empty($childIds)) {
|
|
// Pas d'enfant, uniquement l'entrée du parent
|
|
$parents[] = [
|
|
'title' => html_entity_decode($this->getData(['page', $parentId, 'title']), ENT_QUOTES),
|
|
'value' => $rewrite . $parentId
|
|
];
|
|
} else {
|
|
// Des enfants, on ajoute la page parent en premier
|
|
array_unshift($children, [
|
|
'title' => html_entity_decode($this->getData(['page', $parentId, 'title']), ENT_QUOTES),
|
|
'value' => $rewrite . $parentId
|
|
]);
|
|
// puis on ajoute les enfants au parent
|
|
$parents[] = [
|
|
'title' => html_entity_decode($this->getData(['page', $parentId, 'title']), ENT_QUOTES),
|
|
'value' => $rewrite . $parentId,
|
|
'menu' => $children
|
|
];
|
|
}
|
|
}
|
|
}
|
|
// Sitemap et Search
|
|
$children = [];
|
|
$children[] = [
|
|
'title' => 'Rechercher dans le site',
|
|
'value' => $rewrite . 'search'
|
|
];
|
|
$children[] = [
|
|
'title' => 'Plan du contenu',
|
|
'value' => $rewrite . 'sitemap'
|
|
];
|
|
$parents[] = [
|
|
'title' => 'Pages spéciales',
|
|
'value' => '#',
|
|
'menu' => $children
|
|
];
|
|
|
|
// Enregistrement : 3 tentatives
|
|
for ($i = 0; $i < 3; $i++) {
|
|
if (file_put_contents('core/vendor/tinymce/link_list.json', json_encode($parents, JSON_UNESCAPED_UNICODE), LOCK_EX) !== false) {
|
|
break;
|
|
}
|
|
// Pause de 10 millisecondes
|
|
usleep(10000);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Accède à une valeur des variables http (ordre de recherche en l'absence de type : _COOKIE, _POST)
|
|
* @param string $key Clé de la valeur
|
|
* @param int $filter Filtre à appliquer à la valeur
|
|
* @param bool $required Champ requis
|
|
* @return mixed
|
|
*/
|
|
public function getInput($key, $filter = helper::FILTER_STRING_SHORT, $required = false)
|
|
{
|
|
// La clef est un tableau
|
|
if (preg_match('#\[(.*)\]#', $key, $secondKey)) {
|
|
$firstKey = explode('[', $key)[0];
|
|
$secondKey = $secondKey[1];
|
|
foreach ($this->input as $type => $values) {
|
|
// Champ obligatoire
|
|
if ($required) {
|
|
$this->addRequiredInputNotices($key);
|
|
}
|
|
// Check de l'existence
|
|
// Également utile pour les checkbox qui ne retournent rien lorsqu'elles ne sont pas cochées
|
|
if (
|
|
array_key_exists($firstKey, $values)
|
|
and array_key_exists($secondKey, $values[$firstKey])
|
|
) {
|
|
// Retourne la valeur filtrée
|
|
if ($filter) {
|
|
return helper::filter($this->input[$type][$firstKey][$secondKey], $filter);
|
|
}
|
|
// Retourne la valeur
|
|
else {
|
|
return $this->input[$type][$firstKey][$secondKey];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// La clef est une chaîne
|
|
else {
|
|
foreach ($this->input as $type => $values) {
|
|
// Champ obligatoire
|
|
if ($required) {
|
|
$this->addRequiredInputNotices($key);
|
|
}
|
|
// Check de l'existence
|
|
// Également utile pour les checkbox qui ne retournent rien lorsqu'elles ne sont pas cochées
|
|
if (array_key_exists($key, $values)) {
|
|
// Retourne la valeur filtrée
|
|
if ($filter) {
|
|
return helper::filter($this->input[$type][$key], $filter);
|
|
}
|
|
// Retourne la valeur
|
|
else {
|
|
return $this->input[$type][$key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Sinon retourne null
|
|
return helper::filter(null, $filter);
|
|
}
|
|
|
|
/**
|
|
* Accède à une partie l'url ou à l'url complète
|
|
* @param int $key Clé de l'url
|
|
* @return string|null
|
|
*/
|
|
public function getUrl($key = null)
|
|
{
|
|
// Url complète
|
|
if ($key === null) {
|
|
return $this->url;
|
|
}
|
|
// Une partie de l'url
|
|
else {
|
|
$url = explode('/', $this->url);
|
|
return array_key_exists($key, $url) ? $url[$key] : null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Accède à l'utilisateur connecté
|
|
* @param int $key Clé de la valeur
|
|
* @return string|null
|
|
*/
|
|
public function getUser($key, $perm1 = null, $perm2 = null)
|
|
{
|
|
if (is_array($this->user) === false) {
|
|
return false;
|
|
} elseif ($key === 'id') {
|
|
return $this->getInput('ZWII_USER_ID');
|
|
} elseif ($key === 'permission') {
|
|
return $this->getPermission($perm1, $perm2);
|
|
} elseif (array_key_exists($key, $this->user)) {
|
|
return $this->user[$key];
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retourne les permissions de l'utilisateur connecté
|
|
* @param int $key Clé de la valeur du groupe
|
|
* @return string|null
|
|
*/
|
|
public function getPermission($key1, $key2 = null)
|
|
{
|
|
// Administrateur, toutes les permissions
|
|
if ($this->getUser('group') === self::GROUP_ADMIN) {
|
|
return true;
|
|
} elseif ($this->getUser('group') <= self::GROUP_VISITOR) { // Groupe sans autorisation
|
|
return false;
|
|
} elseif (
|
|
// Groupe avec profil, consultation des autorisations sur deux clés
|
|
$key1
|
|
&& $key2
|
|
&& $this->user
|
|
&& $this->getData(['profil', $this->user['group'], $this->user['profil'], $key1])
|
|
&& array_key_exists($key2, $this->getData(['profil', $this->user['group'], $this->user['profil'], $key1]))
|
|
) {
|
|
return $this->getData(['profil', $this->user['group'], $this->user['profil'], $key1, $key2]);
|
|
// Groupe avec profil, consultation des autorisations sur une seule clé
|
|
} elseif (
|
|
$key1
|
|
&& $this->user
|
|
&& $this->getData(['profil', $this->user['group'], $this->user['profil']])
|
|
&& array_key_exists($key1, $this->getData(['profil', $this->user['group'], $this->user['profil']]))
|
|
) {
|
|
return $this->getData(['profil', $this->user['group'], $this->user['profil'], $key1]);
|
|
} else {
|
|
// Une permission non spécifiée dans le profil est autorisée selon la valeur de $actions
|
|
if (class_exists($key1)) {
|
|
$module = new $key1;
|
|
if (array_key_exists($key2, $module::$actions)) {
|
|
return $this->getUser('group') >= $module::$actions[$key2];
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Check qu'une valeur est transmise par la méthode _POST
|
|
* @return bool
|
|
*/
|
|
public function isPost()
|
|
{
|
|
return ($this->checkCSRF() and $this->input['_POST'] !== []);
|
|
}
|
|
|
|
|
|
/**
|
|
* Retourne une chemin localisé pour l'enregistrement des données
|
|
* @param $stageId nom du module
|
|
* @param $course langue des pages
|
|
* @return string du dossier à créer
|
|
*/
|
|
public function dataPath($id, $course)
|
|
{
|
|
// Sauf pour les pages et les modules
|
|
if (
|
|
$id === 'page' ||
|
|
$id === 'module'
|
|
) {
|
|
$folder = self::DATA_DIR . $course . '/';
|
|
} else {
|
|
$folder = self::DATA_DIR;
|
|
}
|
|
return ($folder);
|
|
}
|
|
|
|
|
|
/**
|
|
* Génère un fichier un fichier sitemap.xml
|
|
* https://github.com/icamys/php-sitemap-generator
|
|
* all : génère un site map complet
|
|
* Sinon contient id de la page à créer
|
|
* @param string Valeurs possibles
|
|
*/
|
|
|
|
public function updateSitemap()
|
|
{
|
|
// Le drapeau prend true quand au moins une page est trouvée
|
|
$flag = false;
|
|
|
|
// Rafraîchit la liste des pages après une modification de pageId notamment
|
|
$this->buildHierarchy();
|
|
|
|
// Actualise la liste des pages pour TinyMCE
|
|
$this->tinyMcePages();
|
|
|
|
//require_once 'core/vendor/sitemap/SitemapGenerator.php';
|
|
|
|
$timezone = $this->getData(['config', 'timezone']);
|
|
$outputDir = getcwd();
|
|
$sitemap = new \Icamys\SitemapGenerator\SitemapGenerator(helper::baseurl(false), $outputDir);
|
|
|
|
// will create also compressed (gzipped) sitemap : option buguée
|
|
// $sitemap->enableCompression();
|
|
|
|
// determine how many urls should be put into one file
|
|
// according to standard protocol 50000 is maximum value (see http://www.sitemaps.org/protocol.html)
|
|
$sitemap->setMaxUrlsPerSitemap(50000);
|
|
|
|
// sitemap file name
|
|
$sitemap->setSitemapFileName('sitemap.xml');
|
|
|
|
|
|
// Set the sitemap index file name
|
|
$sitemap->setSitemapIndexFileName('sitemap-index.xml');
|
|
|
|
$datetime = new DateTime(date('c'));
|
|
$datetime->format(DateTime::ATOM); // Updated ISO8601
|
|
|
|
foreach ($this->getHierarchy() as $parentPageId => $childrenPageIds) {
|
|
// Exclure les barres et les pages non publiques et les pages masquées
|
|
if (
|
|
$this->getData(['page', $parentPageId, 'group']) !== 0 ||
|
|
$this->getData(['page', $parentPageId, 'block']) === 'bar'
|
|
) {
|
|
continue;
|
|
}
|
|
// Page désactivée, traiter les sous-pages sans prendre en compte la page parente.
|
|
if ($this->getData(['page', $parentPageId, 'disable']) !== true) {
|
|
// Cas de la page d'accueil ne pas dupliquer l'URL
|
|
$pageId = ($parentPageId !== $this->homePageId()) ? $parentPageId : '';
|
|
$sitemap->addUrl('/' . $pageId, $datetime);
|
|
$flag = true;
|
|
}
|
|
// Articles du blog
|
|
if (
|
|
$this->getData(['page', $parentPageId, 'moduleId']) === 'blog'
|
|
&& !empty($this->getData(['module', $parentPageId]))
|
|
&& $this->getData(['module', $parentPageId, 'posts'])
|
|
) {
|
|
foreach ($this->getData(['module', $parentPageId, 'posts']) as $articleId => $article) {
|
|
if ($this->getData(['module', $parentPageId, 'posts', $articleId, 'state']) === true) {
|
|
$date = $this->getData(['module', $parentPageId, 'posts', $articleId, 'publishedOn']);
|
|
$sitemap->addUrl('/' . $parentPageId . '/' . $articleId, DateTime::createFromFormat('U', $date));
|
|
$flag = true;
|
|
}
|
|
}
|
|
}
|
|
// Sous-pages
|
|
foreach ($childrenPageIds as $childKey) {
|
|
if ($this->getData(['page', $childKey, 'group']) !== 0 || $this->getData(['page', $childKey, 'disable']) === true) {
|
|
continue;
|
|
}
|
|
// Cas de la page d'accueil ne pas dupliquer l'URL
|
|
$pageId = ($childKey !== $this->homePageId()) ? $childKey : '';
|
|
$sitemap->addUrl('/' . $childKey, $datetime);
|
|
$flag = true;
|
|
|
|
// La sous-page est un blog
|
|
if (
|
|
$this->getData(['page', $childKey, 'moduleId']) === 'blog' &&
|
|
!empty($this->getData(['module', $childKey]))
|
|
) {
|
|
foreach ($this->getData(['module', $childKey, 'posts']) as $articleId => $article) {
|
|
if ($this->getData(['module', $childKey, 'posts', $articleId, 'state']) === true) {
|
|
$date = $this->getData(['module', $childKey, 'posts', $articleId, 'publishedOn']);
|
|
$sitemap->addUrl('/' . $childKey . '/' . $articleId, DateTime::createFromFormat('U', $date));
|
|
$flag = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ($flag === false) {
|
|
return false;
|
|
}
|
|
|
|
// Flush all stored urls from memory to the disk and close all necessary tags.
|
|
$sitemap->flush();
|
|
|
|
// Move flushed files to their final location. Compress if the option is enabled.
|
|
$sitemap->finalize();
|
|
|
|
// Update robots.txt file in output directory
|
|
|
|
if ($this->getData(['config', 'seo', 'robots']) === true) {
|
|
if (file_exists('robots.txt')) {
|
|
unlink('robots.txt');
|
|
}
|
|
$sitemap->updateRobots();
|
|
} else {
|
|
file_put_contents('robots.txt', 'User-agent: *' . PHP_EOL . 'Disallow: /');
|
|
}
|
|
|
|
// Submit your sitemaps to Google, Yahoo, Bing and Ask.com
|
|
if (empty($this->getData(['config', 'proxyType']) . $this->getData(['config', 'proxyUrl']) . ':' . $this->getData(['config', 'proxyPort']))) {
|
|
$sitemap->submitSitemap();
|
|
}
|
|
|
|
return (file_exists('sitemap.xml') && file_exists('robots.txt'));
|
|
|
|
}
|
|
|
|
/*
|
|
* Création d'une miniature
|
|
* Fonction utilisée lors de la mise à jour d'une version 9 à une version 10
|
|
* @param string $src image source
|
|
* @param string $dets image destination
|
|
* @param integer $desired_width largeur demandée
|
|
*/
|
|
function makeThumb($src, $dest, $desired_width)
|
|
{
|
|
// Vérifier l'existence du dossier de destination.
|
|
$fileInfo = pathinfo($dest);
|
|
if (!is_dir($fileInfo['dirname'])) {
|
|
mkdir($fileInfo['dirname'], 0755, true);
|
|
}
|
|
$source_image = '';
|
|
// Type d'image
|
|
switch ($fileInfo['extension']) {
|
|
case 'jpeg':
|
|
case 'jpg':
|
|
$source_image = imagecreatefromjpeg($src);
|
|
break;
|
|
case 'png':
|
|
$source_image = imagecreatefrompng($src);
|
|
break;
|
|
case 'gif':
|
|
$source_image = imagecreatefromgif($src);
|
|
break;
|
|
case 'webp':
|
|
$source_image = imagecreatefromwebp($src);
|
|
break;
|
|
case 'avif':
|
|
$source_image = function_exists('imagecreatefromavif') ? imagecreatefromavif($src) : null;
|
|
break;
|
|
}
|
|
// Image valide
|
|
if ($source_image) {
|
|
$width = imagesx($source_image);
|
|
$height = imagesy($source_image);
|
|
/* find the "desired height" of this thumbnail, relative to the desired width */
|
|
$desired_height = floor($height * ($desired_width / $width));
|
|
/* create a new, "virtual" image */
|
|
$virtual_image = imagecreatetruecolor($desired_width, $desired_height);
|
|
/* copy source image at a resized size */
|
|
imagecopyresampled($virtual_image, $source_image, 0, 0, 0, 0, $desired_width, $desired_height, $width, $height);
|
|
switch (mime_content_type($src)) {
|
|
case 'image/jpeg':
|
|
case 'image/jpg':
|
|
return (imagejpeg($virtual_image, $dest));
|
|
case 'image/png':
|
|
return (imagepng($virtual_image, $dest));
|
|
case 'image/gif':
|
|
return (imagegif($virtual_image, $dest));
|
|
case 'webp':
|
|
return (imagewebp($virtual_image, $dest));
|
|
case 'avif':
|
|
return (imageavif($virtual_image, $dest));
|
|
}
|
|
} else {
|
|
return (false);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Envoi un mail
|
|
* @param string|array $to Destinataire
|
|
* @param string $subject Sujet
|
|
* @param string $content Contenu
|
|
*/
|
|
public function sendMail($to, $subject, $content, $replyTo = null, $from = 'no-reply@localhost')
|
|
{
|
|
// Layout
|
|
ob_start();
|
|
include 'core/layout/mail.php';
|
|
$layout = ob_get_clean();
|
|
$mail = new PHPMailer\PHPMailer\PHPMailer;
|
|
$mail->setLanguage(substr(self::$i18nUI, 0, 2), 'core/class/phpmailer/i18n/');
|
|
$mail->CharSet = 'UTF-8';
|
|
$mail->Encoding = 'base64';
|
|
// Mail
|
|
try {
|
|
// Paramètres SMTP perso
|
|
if ($this->getdata(['config', 'smtp', 'enable'])) {
|
|
//$mail->SMTPDebug = PHPMailer\PHPMailer\SMTP::DEBUG_CLIENT;
|
|
$mail->isSMTP();
|
|
$mail->SMTPAutoTLS = false;
|
|
$mail->SMTPSecure = false;
|
|
$mail->SMTPAuth = false;
|
|
$mail->Host = $this->getdata(['config', 'smtp', 'host']);
|
|
$mail->Port = (int) $this->getdata(['config', 'smtp', 'port']);
|
|
if ($this->getData(['config', 'smtp', 'auth'])) {
|
|
$mail->SMTPSecure = true;
|
|
$mail->SMTPAuth = true;
|
|
$mail->Username = $this->getData(['config', 'smtp', 'username']);
|
|
$mail->Password = helper::decrypt($this->getData(['config', 'smtp', 'password']), $this->getData(['config', 'smtp', 'host']));
|
|
switch ($this->getData(['config', 'smtp', 'secure'])) {
|
|
case 'ssl':
|
|
$mail->SMTPSecure = PHPMailer\PHPMailer\PHPMailer::ENCRYPTION_SMTPS;
|
|
break;
|
|
case 'tls':
|
|
$mail->SMTPSecure = PHPMailer\PHPMailer\PHPMailer::ENCRYPTION_STARTTLS;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Expéditeur
|
|
$host = str_replace('www.', '', $_SERVER['HTTP_HOST']);
|
|
$from = $from ? $from : 'no-reply@' . $host;
|
|
$mail->setFrom($from, html_entity_decode($this->getData(['config', 'title'])));
|
|
|
|
// répondre à
|
|
if (is_null($replyTo)) {
|
|
$mail->addReplyTo($from, html_entity_decode($this->getData(['config', 'title'])));
|
|
} else {
|
|
$mail->addReplyTo($replyTo);
|
|
}
|
|
|
|
// Destinataires
|
|
if (is_array($to)) {
|
|
foreach ($to as $userMail) {
|
|
$mail->addAddress($userMail);
|
|
}
|
|
} else {
|
|
$mail->addAddress($to);
|
|
}
|
|
$mail->isHTML(true);
|
|
$mail->Subject = html_entity_decode($subject);
|
|
$mail->Body = $layout;
|
|
$mail->AltBody = strip_tags($content);
|
|
if ($mail->send()) {
|
|
return true;
|
|
} else {
|
|
return $mail->ErrorInfo;
|
|
}
|
|
} catch (Exception $e) {
|
|
return $mail->ErrorInfo;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Effacer un dossier non vide.
|
|
* @param string URL du dossier à supprimer
|
|
*/
|
|
public function deleteDir($path)
|
|
{
|
|
foreach (new DirectoryIterator($path) as $item) {
|
|
if ($item->isFile())
|
|
@unlink($item->getRealPath());
|
|
if (!$item->isDot() && $item->isDir())
|
|
$this->deleteDir($item->getRealPath());
|
|
}
|
|
return (rmdir($path));
|
|
}
|
|
|
|
|
|
/*
|
|
* Copie récursive de dossiers
|
|
* @param string $src dossier source
|
|
* @param string $dst dossier destination
|
|
* @return bool
|
|
*/
|
|
public function copyDir($src, $dst)
|
|
{
|
|
// Ouvrir le dossier source
|
|
$dir = opendir($src);
|
|
// Créer le dossier de destination
|
|
if (!is_dir($dst))
|
|
$success = mkdir($dst, 0755, true);
|
|
else
|
|
$success = true;
|
|
|
|
// Boucler dans le dossier source en l'absence d'échec de lecture écriture
|
|
while (
|
|
$success
|
|
and $file = readdir($dir)
|
|
) {
|
|
|
|
if (($file != '.') && ($file != '..')) {
|
|
if (is_dir($src . '/' . $file)) {
|
|
// Appel récursif des sous-dossiers
|
|
$s = $this->copyDir($src . '/' . $file, $dst . '/' . $file);
|
|
$success = $s || $success;
|
|
} else {
|
|
$s = copy($src . '/' . $file, $dst . '/' . $file);
|
|
$success = $s || $success;
|
|
}
|
|
}
|
|
}
|
|
return $success;
|
|
}
|
|
|
|
|
|
/**
|
|
* Fonction de parcours des données de module
|
|
* @param string $find donnée à rechercher
|
|
* @param string $replace donnée à remplacer
|
|
* @param array tableau à analyser
|
|
* @param int count nombres d'occurrences
|
|
* @return array avec les valeurs remplacées.
|
|
*/
|
|
public function recursive_array_replace($find, $replace, $array, &$count)
|
|
{
|
|
if (!is_array($array)) {
|
|
return str_replace($find, $replace, $array, $count);
|
|
}
|
|
|
|
$newArray = [];
|
|
foreach ($array as $key => $value) {
|
|
$newArray[$key] = $this->recursive_array_replace($find, $replace, $value, $c);
|
|
$count += $c;
|
|
}
|
|
return $newArray;
|
|
}
|
|
|
|
/**
|
|
* Génère une archive d'un dossier et des sous-dossiers
|
|
* @param string fileName path et nom de l'archive
|
|
* @param string folder path à zipper
|
|
* @param array filter dossiers à exclure
|
|
*/
|
|
public function makeZip($fileName, $folder, $filter = [])
|
|
{
|
|
$zip = new ZipArchive();
|
|
$zip->open($fileName, ZipArchive::CREATE | ZipArchive::OVERWRITE);
|
|
//$directory = 'site/';
|
|
$files = new RecursiveIteratorIterator(
|
|
new RecursiveCallbackFilterIterator(
|
|
new RecursiveDirectoryIterator(
|
|
$folder,
|
|
RecursiveDirectoryIterator::SKIP_DOTS
|
|
),
|
|
function ($fileInfo, $key, $iterator) use ($filter) {
|
|
return $fileInfo->isFile() || !in_array($fileInfo->getBaseName(), $filter);
|
|
}
|
|
)
|
|
);
|
|
foreach ($files as $name => $file) {
|
|
if (!$file->isDir()) {
|
|
$filePath = $file->getRealPath();
|
|
$relativePath = substr($filePath, strlen(realpath($folder)) + 1);
|
|
$zip->addFile($filePath, str_replace('\\', '/', $relativePath));
|
|
}
|
|
}
|
|
$zip->close();
|
|
}
|
|
|
|
/**
|
|
* Retourne l'id de la page d'accueil
|
|
* @return string pageId
|
|
*/
|
|
public function homePageId()
|
|
{
|
|
switch (self::$siteContent) {
|
|
case 'home':
|
|
return ($this->getData(['config', 'homePageId']));
|
|
default:
|
|
|
|
return ($this->getData(['course', self::$siteContent, 'homePageId']));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Journalisation
|
|
*/
|
|
public function saveLog($message = '')
|
|
{
|
|
// Journalisation
|
|
$dataLog = helper::dateUTF8('%Y%m%d', time(), self::$i18nUI) . ';' . helper::dateUTF8('%H:%M', time(), self::$i18nUI) . ';';
|
|
$dataLog .= helper::getIp($this->getData(['config', 'connect', 'anonymousIp'])) . ';';
|
|
$dataLog .= empty($this->getUser('id')) ? 'visitor;' : $this->getUser('id') . ';';
|
|
$dataLog .= $message ? $this->getUrl() . ';' . $message : $this->getUrl();
|
|
$dataLog .= PHP_EOL;
|
|
if ($this->getData(['config', 'connect', 'log'])) {
|
|
file_put_contents(self::DATA_DIR . 'journal.log', $dataLog, FILE_APPEND);
|
|
}
|
|
}
|
|
|
|
// Fonctions pour la gestion des contenus
|
|
|
|
/**
|
|
* Retourne les contenus d'un utilisateur
|
|
* @param string $userId identifiant
|
|
* @param string $serStatus teacher ou student ou admin
|
|
*
|
|
* CETTE FONCTION EST UTILISEE PAR LAYOUT
|
|
*
|
|
*/
|
|
public function getCoursesByProfil()
|
|
{
|
|
$courses = $this->getData([('course')]);
|
|
$courses = helper::arraycolumn($courses, 'title', 'SORT_ASC');
|
|
$filter = array();
|
|
switch ($this->getUser('group')) {
|
|
case self::GROUP_ADMIN:
|
|
// Affiche tout
|
|
return $courses;
|
|
case self::GROUP_EDITOR:
|
|
foreach ($courses as $courseId => $value) {
|
|
// Affiche les espaces gérés par l'éditeur, les espaces où il participe et les espaces anonymes
|
|
if (
|
|
// le membre est inscrit
|
|
($this->getData(['enrolment', $courseId]) && array_key_exists($this->getUser('id'), $this->getData(['enrolment', $courseId])))
|
|
// Il est l'auteur
|
|
|| $this->getUser('id') === $this->getData(['course', $courseId, 'author'])
|
|
// Le cours est ouvert
|
|
|| $this->getData(['course', $courseId, 'enrolment']) === self::COURSE_ENROLMENT_GUEST
|
|
) {
|
|
$filter[$courseId] = $courses[$courseId];
|
|
}
|
|
}
|
|
return $filter;
|
|
case self::GROUP_MEMBER:
|
|
foreach ($courses as $courseId => $value) {
|
|
// Affiche les espaces du participant et les espaces anonymes
|
|
if (
|
|
($this->getData(['enrolment', $courseId]) && array_key_exists($this->getUser('id'), $this->getData(['enrolment', $courseId])))
|
|
|| $this->getData(['course', $courseId, 'enrolment']) === self::COURSE_ENROLMENT_GUEST
|
|
) {
|
|
$filter[$courseId] = $courses[$courseId];
|
|
}
|
|
}
|
|
return $filter;
|
|
case self::GROUP_VISITOR:
|
|
foreach ($courses as $courseId => $value) {
|
|
// Affiche les espaces anonymes
|
|
if ($this->getData(['course', $courseId, 'enrolment']) === self::COURSE_ENROLMENT_GUEST) {
|
|
$filter[$courseId] = $courses[$courseId];
|
|
}
|
|
}
|
|
return $filter;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Retourne la signature d'un utilisateur
|
|
*/
|
|
public function signature($userId)
|
|
{
|
|
switch ($this->getData(['user', $userId, 'signature'])) {
|
|
case 1:
|
|
return $userId;
|
|
case 2:
|
|
return $this->getData(['user', $userId, 'pseudo']);
|
|
case 3:
|
|
return $this->getData(['user', $userId, 'firstname']) . ' ' . $this->getData(['user', $userId, 'lastname']);
|
|
case 4:
|
|
return $this->getData(['user', $userId, 'lastname']) . ' ' . $this->getData(['user', $userId, 'firstname']);
|
|
default:
|
|
return $this->getData(['user', $userId, 'firstname']);
|
|
}
|
|
}
|
|
|
|
} |