<?php

/**
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc.
 * (http://cakefoundation.org)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link http://cakephp.org CakePHP(tm) Project
 * @since 0.2.9
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace App\Controller;

use Cake\Controller\Controller;
use Cake\Event\Event;
use Cake\ORM\TableRegistry;
use Cake\Mailer\Email;
use Cake\Core\Configure;
use Cake\I18n\Time;
use Cake\I18n\Date;
use App\Model\Entity\Materiel;
use App\Model\Entity\Document;
use App\Model\Entity\Suivi;
use App\Model\Entity\Emprunt;

/**
 * Application Controller
 * Add your application-wide methods in the class below, your controllers
 * will inherit them.
 *
 * @link http://book.cakephp.org/3.0/en/controllers.html#the-app-controller
 */
class AppController extends Controller
{

    public $confLabinvent;

    const PROFILE_USER = 1;

    const PROFILE_RESPONSABLE = 2;

    const PROFILE_ADMIN = 3;

    const PROFILE_ADMINPLUS = 4;

    const PROFILE_SUPERADMIN = 5;

    // private $allProfiles = [
    const PROFILES = [
        'Utilisateur' => self::PROFILE_USER,
        'Responsable' => self::PROFILE_RESPONSABLE,
        'Administration' => self::PROFILE_ADMIN,
        'Administration Plus' => self::PROFILE_ADMINPLUS,
        'Super Administrateur' => self::PROFILE_SUPERADMIN
    ];

    // Current priviledged USER (if so, otherwise = NULL)
    private $CURRENT_PRIVILEDGED_USER = null;

    // Current ROLE (by default = "Utilisateur")
    private $CURRENT_ROLE = null;

    // EP 08/2017
    // protected $easyACL = array(
    const easyACL = array(
        
        /**
         * Default ACL for ALL (logged) users
         *
         * Les actions non mentionnées sont accessibles à tous (par défaut),
         * exemple 'find', 'index'...
         * Ces default ACL peuvent être surchargées pour un profil précis
         * (par exemple pour 'USER' qui est plus restreint)
         */
        // 'ALL' => array (
        'DEFAULT' => array(
            // 'action' => 'condition for execution' (= 'Y', 'N', or '<condition>'),
            // with <condition> like "'field name' == 'value'"
            // !!! Used for test, DO NOT REMOVE : !!!
            'action_CAS4_Y' => 'Y',
            'action_CAS4_N' => 'N'
            // YOUR RULES :
            // CRUD actions :
            // 'edit' => 'N', // update
            // 'delete' => 'N',
        ),
        
        // Ajoute des ACL plus spécifiques (ci-dessus) pour le profil USER qui est plus restreint
        // Les actions absentes ne sont pas surchargées (elles sont exécutées selon les conditions définies pour 'ALL')
        'USER' => array(
            // !!! Used for test, DO NOT REMOVE : !!!
            'action_CAS3_Y' => 'Y',
            'action_CAS3_N' => 'N',
            // YOUR RULES :
            // CRUD actions
            'add' => 'Y', // C
            'index' => 'Y', // R all
            'view' => 'Y', // R one
                           // 'edit' => 'N', // U
            'edit' => 'is_creator', // is_creator = (nom_createur == CURRENT_USER_NAME)
            'delete' => 'N', // D
                             // OTHER actions
            'find' => 'Y' // create
            /*
         * ceci n'a aucun sens car l'action sur le modèle "Pages" s'appelle toujours "display" (et non pas tools, infos, ou printers...)
         * 'tools' => 'N',
         * 'infos' => 'N',
         * 'printers' => 'N',
         */
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil RESPONSABLE qui est plus restreint
        // Les actions absentes ne sont pas surchargées (elles sont exécutées selon les conditions définies pour 'ALL')
        'RESPONSABLE' => array(),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil ADMIN
        'ADMIN' => array(
            // 'add' => 'Y', // create
            'edit' => 'Y' // update
                               // 'delete' => 'Y', // update
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil ADMINPLUS
        'ADMINPLUS' => array(
            // 'edit' => 'Y', // update
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil SUPERADMIN
        'SUPERADMIN' => array(
            // 'add' => 'Y', // create
            // 'edit' => 'Y', // update
            'delete' => 'Y'
        )
    );
 // $easyACL
       
    // if (isset($this->easyACL['DEFAULT'][$action])) {
    public function hasACLRule($easyACL, $role, $action)
    {
        // return isset($this->easyACL[$role][$action]);
        // return (null !== self::easyACL[$role][$action]);
        // return array_key_exists($role, self::easyACL) && array_key_exists($action, self::easyACL[$role]);
        return array_key_exists($role, $easyACL) && array_key_exists($action, $easyACL[$role]);
    }

    // @todo
    public function startsWith($haystack, $needle)
    {
        return strpos($haystack, $needle) === 0;
    }

    /*
     * //@todo
     * public function endsWith($haystack, $needle) {
     * return strpos($haystack, $needle, strlen($haystack)-1) === 0;
     * }
     */
    public function evalACL($condition)
    {
        return $condition;
        // Simple case
        if ($condition == 'Y')
            return true;
        if ($condition == 'F')
            return false;
        // Complex case
        // @todo
        return true;
    }

    public function evalSpecificRule($condition, AppController $controller, $user, $role, $action, $id = null)
    {
        // if starts with "&&" eval DEFAULT rule && specific rule
        if ($this->startsWith($condition, '&&')) {
            //debug($condition);
            //if (! isset($controller::easyACL['DEFAULT'][$action])) return new \Exception('bad rule');
            if (! array_key_exists($action, $controller::easyACL['DEFAULT']) ) return new \Exception('bad rule');
            //return $this->evalACL($controller->easyACL['DEFAULT'][$action]) && $this->evalACL($condition);
            return $this->evalACL($controller::easyACL['DEFAULT'][$action]).' ' . $this->evalACL($condition);
        }
        // otherwise, eval only specific rule
        return $this->evalACL($condition);
    }

    /**
     *
     * @param AppController $controller
     *            // a subclass of AppController (MaterielsController or any other)
     * @param array $user
     * @param string $role
     * @param string $action
     * @param string $id
     */
    // public function isAuthorizedAction(AppController $controller, $roleLong, $action, $id=null, $user=null) {
    public function isAuthorizedAction($controller, $roleLong, $action, $id = null, $user = null)
    {
        $doDEBUG = true;
        $doDEBUG = false;
        
        switch ($roleLong) {
            case 'Utilisateur':
                $role = 'USER';
                break;
            case 'Responsable':
                $role = 'RESPONSABLE';
                break;
            case 'Administration':
                $role = 'ADMIN';
                break;
            case 'Administration Plus':
                $role = 'ADMINPLUS';
                break;
            case 'Super Administrateur':
                $role = 'SUPERADMIN';
                break;
        }
        if ($doDEBUG)
            debug("role is $role");
        
        // 1) SPECIFIC controller SPECIFIC (role) rule for action
        // if (isset($controller->easyACL[$role][$action])) {
        if (self::hasACLRule($controller::easyACL, $role, $action)) {
            if ($doDEBUG)
                debug("CAS1");
            return $this->evalSpecificRule($controller::easyACL[$role][$action], $controller, $user, $role, $action);
        }
        
        // 2) SPECIFIC controller DEFAULT rule for action
        // if (null !== $controller::easyACL['DEFAULT'][$action]) {
        if (self::hasACLRule($controller::easyACL, 'DEFAULT', $action)) {
            if ($doDEBUG)
                debug("CAS2");
            return $this->evalACL($controller::easyACL['DEFAULT'][$action]);
        }
        
        // 3) ALL controllers (AppController) SPECIFIC (role) rule for action
        // if (isset($this->easyACL[$role][$action])) {
        if (self::hasACLRule(self::easyACL, $role, $action)) {
            if ($doDEBUG)
                debug("CAS3");
            return $this->evalSpecificRule(self::easyACL[$role][$action], $this, $user, $role, $action);
        }
        
        // 4) ALL controllers (AppController) DEFAULT rule for action
        // if (isset($this->easyACL['DEFAULT'][$action])) {
        // if (self::hasACLRule('DEFAULT',$action)) {
        if (self::hasACLRule(self::easyACL, 'DEFAULT', $action)) {
            if ($doDEBUG)
                debug("CAS4");
            return $this->evalACL(self::easyACL['DEFAULT'][$action]);
            // return $this->evalACL(parent::getACLRule('DEFAULT',$action));
        }
        
        /*
         * (RECURSIVE CALL)
         * 5) SPECIFIC controller PREVIOUS SPECIFIC (role) rule for action
         * ex: if role is 'SUPER', use 'ADMIN' rule
         * ex: if role is 'ADMIN', use 'RESP' rule
         * ex: if role is 'RESP', use 'USER' rule
         * ex: if role is 'USER', stop recursive call
         * Stop recursive call if role is 'USER' => no rule found, so DEFAULT IS AUTHORIZE (Y) !!! => permissive ACL
         */
        // if ($role == 'USER') return true;
        if ($role == 'USER') {
            if ($doDEBUG)
                debug("CAS5");
            return 'Y';
        }
        if ($doDEBUG)
            debug("CAS6");
        return $this->isAuthorizedAction($controller, $this->getPreviousRole($role), $action, $id, $user);
    }

    // @todo
    public function getMandatoryFieldsForAction($action)
    {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }

    // @todo
    public function getHiddenFieldsForAction($action)
    {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }

    // @todo
    public function getReadOnlyFieldsForAction($action)
    {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }

    // @todo
    public function getDefaultValueFieldsForAction($action)
    {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }

    public static function getRoleLevel($role)
    {
        // return $this->allProfiles[$role];
        // debug("role is" .$role);
        return self::PROFILES[$role];
    }

    public static function getPreviousRole($role)
    {
        switch ($role) {
            /*
             * case 'RESPONSABLE': $rolePrev='USER'; break;
             * case 'ADMIN': $rolePrev='RESPONSABLE'; break;
             * case 'ADMINPLUS': $rolePrev='ADMIN'; break;
             * case 'SUPERADMIN': $rolePrev='ADMINPLUS'; break;
             */
            case 'RESPONSABLE':
                $rolePrev = 'Utilisateur';
                break;
            case 'ADMIN':
                $rolePrev = 'Responsable';
                break;
            case 'ADMINPLUS':
                $rolePrev = 'Administration';
                break;
            case 'SUPERADMIN':
                $rolePrev = 'Administration Plus';
                break;
        }
        return $rolePrev;
    }

    public function getActionPassed()
    {
        // BETTER:
        // return $this->request->getAttribute('params')['action'];
        return $this->request->getParam('action');
    }

    public function getIdPassed()
    {
        // return (int) $this->request->getAttribute('params')['pass'][0];
        return (int) $this->request->getParam('pass.0');
    }

    /**
     * Initialization hook method.
     * Use this method to add common initialization code like loading components.
     * e.g. `$this->loadComponent('Security');`
     *
     * @return void
     */
    public function initialize()
    {
        parent::initialize();
        
        $this->loadComponent('RequestHandler');
        $this->loadComponent('Flash');
        $this->loadComponent('LdapAuth', [
            'authorize' => [
                'Controller'
            ],
            'loginRedirect' => [
                'controller' => 'Pages',
                'action' => 'home'
            ],
            'logoutRedirect' => [
                'controller' => 'Pages',
                'action' => 'home'
            ]
        ]);
        // On charge la configuration
        /*
        $this->confLabinvent = TableRegistry::get('Configurations')->find()
            ->where([
            'id =' => 1
        ])
            ->first();
        */
        $this->confLabinvent = TableRegistry::get('Configurations')->find()->first();
    }

    /**
     * Autorisations fréquentes utilisées par bcp de isAuthorized() de controlleurs
     * Ca évite de répéter 10 fois la meme chose !!!
     */
    public function isAuthorizedCommons($user)
    {
        $action = $this->getActionPassed();
        // $role = $this->getUserRole($user);
        
        // Seul Administration (et +) peut ajouter, supprimer ou modifier
        if (in_array($action, [
            'add',
            'delete',
            'edit'
        ])) {
            if ($this->USER_IS_ADMIN_AT_LEAST())
                return true;
            // Les autres n'y ont pas accès
            return false;
        }
        
        // By default
        // return parent::isAuthorized($user);
        return AppController::isAuthorized($user);
    }

    /**
     *
     * @param
     *            $user
     * @return boolean isAuthorized is located in the Auth component
     *         Check whether a LOGGED in user has a set of permissions to perform a given action
     *         Give authorization in general
     *        
     *         2) Autorisation APRES connexion
     *         (Avant, c'est beforeFilter() qui s'en occupe)
     */
    public function isAuthorized($user)
    {
        /*
         * // ATTENTION, normalement, on devrait tester si role est défini..., mais c'est sans doute pas utile
         * // cf https://book.cakephp.org/3.0/fr/tutorials-and-examples/blog-auth-example/auth.html
         * if (isset($user['role']) && $user['role'] === 'admin') {
         * return true;
         * }
         */
        $configuration = $this->confLabinvent;
        $role = $this->getUserRole($user);
        /*
         * $role = TableRegistry::get('Users')->find()
         * ->where(['username' => $user[$configuration->authentificationType_ldap][0]])
         * ->first()['role'];
         */
        $this->myDebug("role is " . $role);
        
        // BETTER:
        // $action = $this->request->getAttribute('params')['action'];
        // $action = $this->request->getParam('action');
        $action = $this->getActionPassed();
        
        // error_log($action);
        
        // ACL : Actions accessibles à tous les roles (profils)
        if (in_array($action, [
            'index',
            'view',
            'add',
            'find',
            'creer',
            'getNextDate',
            'getDateGarantie'
        ]))
            return true;
        
        // ACL : Super-Admin peut accéder à toutes les actions
        if ($role == 'Super Administrateur')
            return true;
        
        // ACL : Par défaut refuser
        return false;
    }

    public function getTablePriviledgedUserFromCurrentSessionUserIfExists($user = null)
    {
        if (! $this->CURRENT_PRIVILEDGED_USER) {
            $configuration = $this->confLabinvent;
            $username = $user ? $user[$configuration->authentificationType_ldap][0] : $this->LdapAuth->user($configuration->authentificationType_ldap)[0];
            $priviledgedUser = TableRegistry::get('Users')->find()
                ->where([
                'username' => $username
            ])
                ->
            // ->where(['username' => $this->LdapAuth->user('cn')[0]])
            first();
            // if (! $priviledgedUser) $priviledgedUser = "Unpriviledged User (not in table utilisateurs)";
            $this->CURRENT_PRIVILEDGED_USER = $priviledgedUser;
        }
        return $this->CURRENT_PRIVILEDGED_USER;
    }

    public function getUserRole($user = null)
    {
        if (! $this->CURRENT_ROLE) {
            $priviledgedUser = $this->getTablePriviledgedUserFromCurrentSessionUserIfExists($user);
            // default role is "Utilisateur" (for people who are not in the table utilisateurs)
            $this->CURRENT_ROLE = ($priviledgedUser) ? $priviledgedUser['role'] : 'Utilisateur';
        }
        return $this->CURRENT_ROLE;
    }

    private function userHasRole($expectedRole, $ORMORE = false)
    {
        $role = $this->getUserRole();
        if (! $ORMORE)
            return ($role == $expectedRole);
        return ($this->getRoleLevel($role) >= $this->getRoleLevel($expectedRole));
        /*
         * //$hasRole = false;
         * switch ($expectedRole) {
         * case 'Super Administrateur' :
         * return (in_array($role, ['Super Administrateur']));
         * break;
         * case 'Administration Plus' :
         * return (in_array($role, ['Administration Plus', 'Super Administrateur']));
         * break;
         * case 'Administration' :
         * return (in_array($role, ['Administration', 'Administration Plus', 'Super Administrateur' ]));
         * break;
         * case 'Responsable' :
         * return (in_array($role, ['Responsable', 'Administration', 'Administration Plus', 'Super Administrateur']));
         * break;
         * case 'Utilisateur' :
         * return (in_array($role, ['Utilisateur', 'Responsable', 'Administration', 'Administration Plus', 'Super Administrateur']));
         * break;
         * }
         * return $false;
         */
    }

    public function userHasRoleAtLeast($expectedRole)
    {
        return $this->userHasRole($expectedRole, true);
    }

    public function USER_IS_ADMIN_AT_LEAST()
    {
        return $this->userHasRoleAtLeast('Administration');
    }

    public function USER_IS_RESP_AT_LEAST()
    {
        return $this->userHasRoleAtLeast('Responsable');
    }

    public function USER_IS_SUPERADMIN()
    {
        return $this->userHasRole('Super Administrateur');
    }

    public function USER_IS_ADMIN()
    {
        return $this->userHasRole('Administration');
    }

    public function USER_IS_RESP()
    {
        return $this->userHasRole('Responsable');
    }

    public function USER_IS_USER()
    {
        return $this->userHasRole('Utilisateur');
    }

    /**
     *
     * {@inheritdoc}
     *
     * @see \Cake\Controller\Controller::beforeFilter() 1) Autorisations SANS (ou AVANT) connexion
     *      2) Ensuite, c'est isAuthorized qui gère
     *     
     */
    public function beforeFilter(Event $event)
    {
        // !!! Ne jamais autoriser l'action 'login', sinon cela va créer des problèmes sur le fonctionnement normal de AuthComponent (cf doc) !!!
        // parent::beforeFilter($event);
        
        /*
         * EXEMPLES d'utilisation:
         * // to allow all access to all actions:
         * if (isset($this->Auth)) {
         * $this->Auth->allow('*');
         * }
         * // Allow access to index & view actions:
         * if (isset($this->Auth)) {
         * $this->Auth->allowedActions = array('index', 'view');
         * }
         */
        $configuration = $this->confLabinvent;
        
        if ($configuration->mode_install)
            $this->LdapAuth->allow([
                'display',
                'add',
                'edit',
                'installOff'
            ]);
        else
            $this->LdapAuth->allow([
                'display'
            ]);
        
        $this->LdapAuth->config('authError', "Désolé, vous n'êtes pas autorisé à accéder à cette zone.");
    }

    public function afterFilter(Event $event)
    {
        if (in_array($this->request->getAttribute('params')['action'], [
            'edit',
            'add'
        ]))
            $this->request->session()->write("retourForm1", true);
        else if ($this->request->getAttribute('params')['action'] != 'creer')
            $this->request->session()->write("retourForm1", false);
    }

    /**
     * Before render callback.
     *
     * @param \Cake\Event\Event $event
     *            The beforeRender event
     * @return void
     */
    public function beforeRender(Event $event)
    {
        $this->set('PROFILE_USER', self::PROFILE_USER);
        $this->set('PROFILE_ADMIN', self::PROFILE_ADMIN);
        $this->set('PROFILE_RESPONSABLE', self::PROFILE_RESPONSABLE);
        $this->set('PROFILE_ADMINPLUS', self::PROFILE_ADMINPLUS);
        $this->set('PROFILE_SUPERADMIN', self::PROFILE_SUPERADMIN);
        // $this->set('allProfiles', $this->allProfiles);
        $this->set('allProfiles', self::PROFILES);
        
        if (! array_key_exists('_serialize', $this->viewVars) && in_array($this->response->type(), [
            'application/json',
            'application/xml'
        ]))
            $this->set('_serialize', true);
        
        $this->set('username', $this->LdapAuth->user('sn')[0] . ' ' . $this->LdapAuth->user('givenname')[0]);
        
        $configuration = $this->confLabinvent;
        $this->set('configuration', $configuration);
        $this->request->session()->write("authType", $configuration->authentificationType_ldap);
        
        // ATTENTION, $priviledgedUser = NULL si l'utilisateur courant n'est pas un utilisateur privilégié
        // (c'est à dire s'il n'est pas dans la table "utilisateurs")
        $priviledgedUser = $this->getTablePriviledgedUserFromCurrentSessionUserIfExists();
        /*
         * $user = TableRegistry::get('Users')->find()
         * ->where(['username' => $this->LdapAuth->user($configuration->authentificationType_ldap)[0]])
         * ->first();
         * $role = $user['role'];
         * if ($role == null)
         * $role = 'Utilisateur';
         */
        // Role = 'Utilisateur', 'Responsable", ...
        $role = $this->getUserRole();
        $this->set('role', $role);
        
        // Profile = PROFILE_USER (=1), PROFILE_RESPONSABLE (=2), ...
        // $profile = $this->allProfiles["$role"];
        $profile = self::PROFILES["$role"];
        $this->set('profile', $profile);
        
        $USER_IS_UTILISATEUR = ($profile == self::PROFILE_USER);
        $USER_IS_RESPONSABLE = ($profile == self::PROFILE_RESPONSABLE);
        $USER_IS_ADMIN = ($profile == self::PROFILE_ADMIN);
        $USER_IS_ADMINPLUS = ($profile == self::PROFILE_ADMINPLUS);
        $USER_IS_SUPERADMIN = ($profile == self::PROFILE_SUPERADMIN);
        $USER_IS_RESPONSABLE_OR_MORE = ($profile >= self::PROFILE_RESPONSABLE);
        $USER_IS_ADMIN_OR_MORE = ($profile >= self::PROFILE_ADMIN);
        $USER_IS_ADMINPLUS_OR_MORE = ($profile >= self::PROFILE_ADMINPLUS);
        
        $this->set('USER_IS_UTILISATEUR', $USER_IS_UTILISATEUR);
        $this->set('USER_IS_RESPONSABLE', $USER_IS_RESPONSABLE);
        $this->set('USER_IS_ADMIN', $USER_IS_ADMIN);
        $this->set('USER_IS_ADMINPLUS', $USER_IS_ADMINPLUS);
        $this->set('USER_IS_SUPERADMIN', $USER_IS_SUPERADMIN);
        $this->set('USER_IS_RESPONSABLE_OR_MORE', $USER_IS_RESPONSABLE_OR_MORE);
        $this->set('USER_IS_ADMIN_OR_MORE', $USER_IS_ADMIN_OR_MORE);
        $this->set('USER_IS_ADMINPLUS_OR_MORE', $USER_IS_ADMINPLUS_OR_MORE);
        
        $this->set('priviledgedUser', $priviledgedUser);
        
        /*
         * @todo EP 08/2017 Nouvelle organisation des ACL avec $easyACL
         */
        $action = $this->getActionPassed();
        if (in_array($action, array(
            'add',
            'edit',
            'view',
            'index'
        ))) {
            $hiddenFields = $this->getHiddenFieldsForAction($action);
            $this->set('hiddenFields', $hiddenFields);
            $this->myDebug("hiddenFields=", $hiddenFields);
            if (in_array($action, array(
                'add',
                'edit'
            ))) {
                $mandatoryFields = $this->getMandatoryFieldsForAction($action);
                $this->set('mandatoryFields', $mandatoryFields);
                $readOnlyFields = $this->getReadOnlyFieldsForAction($action);
                $this->set('readOnlyFields', $readOnlyFields);
                $haveDefaultValueFields = $this->getDefaultValueFieldsForAction($action);
                $this->set('haveDefaultValueFields', $haveDefaultValueFields);
                $this->myDebug("mandat, ro, default fields=", $mandatoryFields, $readOnlyFields, $haveDefaultValueFields);
            }
        }
        
        $this->set('idGmNa', TableRegistry::get('GroupesMetiers')->find()
            ->where([
            'nom =' => 'N/A'
        ])
            ->first()['id']);
        $this->set('idGtNa', TableRegistry::get('GroupesThematiques')->find()
            ->where([
            'nom =' => 'N/A'
        ])
            ->first()['id']);
        
        $displayElement = function ($nom, $valeur, $params = "") {
            $balise = ($params != "") ? '<td ' . $params . '>' : '<td>';
            // Ca c'est parce que sinon y'a au moins deux tests qui passent pas, a cause de l'espace dans la balise ...
            if ($valeur != "")
                echo '<tr><td><strong>' . $nom . ' </strong></td>' . $balise . $valeur . '</td></tr>';
        };
        $this->set('displayElement', $displayElement);
        
        // Pass this function to all views
        // @todo : Si cette fonction ne concerne que SuivisController, il faut la déplacer dans ce controleur
        $dateProchainControleVerif = function ($t) {
            $time = Time::now(); // On récupère la date et l'heure actuelles
            $today = new \DateTime((new date("$time->year-$time->month-$time->day"))->format('Y-m-d'));
            $time1 = new time($t);
            $dateTime1 = new \DateTime((new date("$time1->year-$time1->month-$time1->day"))->format('y-m-d'));
            $interval = ($today->diff($dateTime1));
            $strInterval = $interval->format('%a');
            return (int) $strInterval;
        };
        $this->set('dateProchainControleVerif', $dateProchainControleVerif);
    }

    // "le materiel", "le suivi"...
    protected function getArticle()
    {
        return "Le ";
    }

    static function isLabinventDebugMode()
    {
        return TableRegistry::get('Configurations')->find()->first()->mode_debug;
        /*
        return TableRegistry::get('Configurations')->find()
            ->where([
            'id =' => 1
        ])
            ->first()->mode_debug;
        */
    }

    function myDebug($arg, $stop = false)
    {
        if ($this->isLabinventDebugMode()) {
            Configure::write('debug', true);
            debug($arg);
            if ($stop)
                exit();
        }
    }

    /**
     * Envoi un mail avec un sujet, contenant un message à destination d'une liste de mails, selon l'action effectuée.
     *
     * @param $entity :
     *            L'entité concernée (principalement un Matériel, mais ça peut aussi etre un Document)
     * @param $subject :
     *            Sujet du message à envoyer. Si $subject n'est pas renseigné, un sujet par défaut sera généré.
     * @param $msg :
     *            Message à envoyer. Si $msg n'est pas renseigné, un message par défaut sera généré.
     */
    public function sendEmail($entity, $subject = null, $msg = null)
    {
        /*
         * $_SESSION['Auth']['User'] pour retrouver TOUTES les infos de la session courante (tout est du string) :
         * nom $_SESSION['Auth']['User']['sn'][0]
         * prenom $_SESSION['Auth']['User']['givenname'][0]
         * mail $_SESSION['Auth']['User']['mail'][0]
         * login $_SESSION['Auth']['User']['xxx'][0] /!\ Ce champ est suceptible de changer de nom, dans les tests ce champ est ['cn'][0]
         * mdp $_SESSION['Auth']['User']['userpassword'][0]
         */
        $configuration = $this->confLabinvent;
        $action = $this->request->getAttribute('params')['action']; // add or edit or delete or ...
                                                                    
        // Si les deux cases "Activer l'envoi des mails.." sont décochées, on se fatigue pas à exécuter la fonction
        if (! $configuration->envoi_mail && ! $configuration->envoi_mail_guests)
            return null;
        
        $mailList = array();
        
        // On détermine le message et le sujet du mail en fonction de l'action effectuee
        $acteur = $_SESSION['Auth']['User']['givenname'][0] . ' ' . $_SESSION['Auth']['User']['sn'][0];
        // if ($entity != null) {
        if ($entity instanceof Materiel) {
            $materiel = $entity;
            $nom_materiel = $materiel->designation;
            if ($subject == null && $msg == null) {
                $msgMore = '';
                Switch ($action) {
                    case 'add':
                        $subject = "Ajout d'un matériel";
                        $msg = "$acteur a ajouté le matériel \"$nom_materiel\"";
                        break;
                    case 'edit':
                        $subject = "Modification d'un matériel";
                        $msg = "$acteur a modifié le matériel \"$nom_materiel\"";
                        break;
                    case 'delete':
                        $subject = "Suppression d'un matériel";
                        $msg = "$acteur a supprimé le matériel \"$nom_materiel\"";
                        // @todo: mettre le nom des domaine, categ, et sous-categ, et non pas l'id
                        if ($materiel->sur_categorie_id != "")
                            $msgMore .= "\n\nDomaine : " . $materiel->sur_categorie_id;
                        if ($materiel->categorie_id != "")
                            $msgMore .= "\n\nCatégorie : " . $materiel->categorie_id;
                        if ($materiel->sous_categorie_id != "")
                            $msgMore .= "\n\nSous-catégorie : " . $materiel->sous_categorie_id;
                        if ($materiel->description != "")
                            $msgMore .= "\n\nDescription :\n" . $materiel->description;
                        break;
                    case 'statusCreated':
                        $subject = "Dé-validation d'un matériel";
                        $msg = "$acteur a dé-validé le matériel \"$nom_materiel\"";
                        break;
                    case 'statusValidated':
                        $subject = "Validation d'un matériel";
                        $msg = "$acteur a validé le matériel \"$nom_materiel\"";
                        break;
                    case 'statusToBeArchived':
                        $subject = "Demande d'archivage d'un matériel";
                        $msg = "$acteur a demandé l'archivage du matériel \"$nom_materiel\"";
                        break;
                    case 'statusArchived':
                        $subject = "Archivage  d'un matériel";
                        $msg = "$acteur a archivé le matériel \"$nom_materiel\"";
                        break;
                    case 'setLabelIsPlaced':
                        $subject = "Etiquette posée sur un matériel";
                        $msg = "Etiquette posée sur le matériel \"$nom_materiel\"";
                        break;
                    case 'printLabelRuban':
                        $subject = "Etiquette imprimée";
                        $msg = "L'étiquette concerant votre matériel \"$nom_materiel\" a été imprimée";
                        $mailList[0] = $materiel->email_responsable;
                    default:
                        $subject = "Action \"$action\" sur un matériel";
                        $msg = "$acteur a effectué l'action \"$action\" sur le matériel \"$nom_materiel\"";
                        break;
                } // end switch
                  // (EP) Ajout de l'ID du materiel !!!
                $msg .= " (id=" . $materiel->id . ").";
                // Only for "delete" action (for the moment...)
                if ($msgMore)
                    $msg .= $msgMore;
                // $msg .= "\n\n";
            } // subject is null
              
            // Et maintenant on construit la liste de mails...
              // Si l'envoi général est activé (et que l'action ne correspond pas à 'printLabelRuban'):
            if ($configuration->envoi_mail && $action != 'printLabelRuban') {
                
                // owner's mail (utilisateur du matériel)
                $mailList[0] = $materiel->email_responsable;
                
                // resp's mail
                $mailsRespMetier = null;
                $mailRespThematique = null;
                
                if ($materiel->groupes_metier_id != null && $materiel->groupes_metier_id != 1) {
                    // Le ..!= 1 c'est parce que le groupe métier/thématique d'id 1 correspond au groupe N/A, soit aucun groupe
                    $mailsRespMetier = TableRegistry::get('Users')->find()
                        ->select('email')
                        ->where([
                        'role =' => 'Responsable',
                        'groupes_metier_id =' => $materiel->groupes_metier_id
                    ])
                        ->toArray();
                    $mailRespThematique = TableRegistry::get('Users')->find()
                        ->select('email')
                        ->where([
                        'role =' => 'Responsable',
                        'groupe_thematique_id =' => $materiel->groupes_thematique_id
                    ])
                        ->toArray();
                }
                
                if ($mailsRespMetier != null || $mailRespThematique != null) {
                    $mailsResp = array_unique(array_merge($mailsRespMetier, $mailRespThematique));
                    for ($i = 0; $i < sizeof($mailsResp); $i ++) {
                        $mailList[] = $mailsResp[$i]['email'];
                        // $mailList[sizeof($mailList)] = $mailsResp[$i]['email'];
                    }
                }
                
                // mail admin de reference (ici appele gestionnaire) -> Partie administration
                // Cela a été mis en commentaire car de toute façon l'utilisateur va voir un administratif pour faire valider sa fiche,
                // Pas la peine de spam l'administration de mails non plus hein !
                
                /*
                 * if ($action != 'statusValidated' && $action != 'statusArchived') {
                 * $mailsAdmin = TableRegistry::get('Users')->find()->select('email')
                 * ->where(['role =' => 'Administration'])
                 * ->toArray();
                 * for ($i = 0; $i < sizeof($mailsAdmin); $i ++) {
                 * $mailList[sizeof($mailList)] = $mailsAdmin[$i]['email'];
                 * }
                 * }
                 */
            }
        } // Materiel
          
        // @todo: ajouter quelques infos dans ces cas :
        else if ($entity instanceof Document) {
            ;
        } else if ($entity instanceof Suivi) {
            ;
        } else if ($entity instanceof Emprunt) {
            ;
        }
        /*
         * @todo:
         * else if ($entity instanceof Configuration) {
         * ;
         * }
         * ... etc ... (il faut qu'on soit plus précis)
         */
        
        // Si l'envoi à la liste spécifiée est activé (et que l'action ne correspond pas à 'printLabelRuban'):
        $specificUsers = [];
        if ($configuration->envoi_mail_guests && $action != 'printLabelRuban') {
            // mail aux adresses specifiees dans la config
            for ($i = 0; $i < 11; $i ++) {
                $specificUser = $configuration['emailGuest' . $i];
                if ($specificUser)
                    $specificUsers[] = $specificUser;
                // $mailList[sizeof($mailList)] = $configuration['emailGuest' . $i];
                $mailList[] = $specificUser;
                // Le if vérifie que la ligne soit pas null
            }
        }
        
        // On dedoublonne la liste des mails, c'pas tres cool de se faire spam 2-3 fois pour la meme action sur le meme materiel, non mais !
        $mailList = array_unique($mailList);
        
        // ... Pour envoyer les mails aux personnes concernees
        foreach ($mailList as $mail) {
            // On envoi des mails à toute la liste, sauf pour "l'acteur", il sait ce qu'il a fait, pas besoin de le spam non plus hein
            if ($mail == $_SESSION['Auth']['User']['mail'][0])
                continue;
            $message = $msg; // Sisi, cette variable $message est utile, m'enfin vous pouvez toujours essayer de la supprimer ..... Et pensez à regarder le contenu de vos mails !!! Sinon ca fait une tumeur
                             // Génération du message "Vous recevez ce message en tant que $role"
                             // Si $role inexistant (lorsque c'est un mail de la liste entrée en configuration), le message est plutot "Vous recevez ce message car vous avez demandé à le recevoir. [...]"
            if ($specificUsers)
                $role = 'car vous etes dans la liste spécifique des emails de LabInvent. Pour faire retirer votre mail de cette liste, veuillez contacter un SuperAdmin.';
            else {
                $role = TableRegistry::get('Users')->find()
                    ->select('role')
                    ->where([
                    'email =' => $mail
                ])
                    ->first()['role'];
                // Default role is Utilisateur (for people in LDAP but without priviledge, not in the users table)
                if (is_null($role))
                    $role = 'Utilisateur';
                $role = 'en tant que ' . $role;
            }
            if ($entity != null && ! in_array($action, [
                'delete',
                'statusValidated',
                'statusCreated'
            ]))
                $message .= "\n\nVeuillez vérifier et compléter si besoin la fiche corespondante.";
            $message .= "\n\nVous recevez ce message " . $role;
            $this->sendEmailTo("$subject", $message, $mail, $configuration);
        }
        return $mailList;
    }

    // Fonction d'envoi de mails
    private function sendEmailTo($subject, $msg, $mail, $config)
    {
        if ($mail != null && ! $config->test) {
            if (filter_var($mail, FILTER_VALIDATE_EMAIL)) {
                $email = new Email();
                $etiquetteFrom = explode("@", $config->sender_mail);
                $email->transport('default')
                    ->from([
                    $config->sender_mail => $etiquetteFrom[0]
                ])
                    ->to($mail)
                    ->subject("[LabInvent] " . $subject)
                    ->send($msg);
            }
        }
    }
}