first refonte

controllers/internals/Command.php

@@ -0,0 +1,107 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des commandes
+	 */
+	class Command extends \InternalController
+	{
+        private $model_command;
+
+        public function __construct (\PDO $bdd)
+        {
+            $this->model_command = new \models\Command($bdd);
+            $this->internal_event = new \controllers\internals\Event($bdd);
+        }
+
+
+		/**
+         * Return the list of commands as an array
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des commandes
+         */	
+		public function list ($nb_entry = false, $page = false)
+		{
+			//Recupération des commandes
+            $model_command = new \models\Command($this->bdd);
+            return $model_command->list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des commandes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des commandes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des commandes
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->get_by_ids($ids);
+        }
+
+        /**
+         * Cette fonction permet de compter le nombre de scheduleds
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer une commande
+		 * @param array $id : L'id de la commande à supprimer
+		 * @return int : Le nombre de commandes supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle commande
+         * @param array $command : La commande à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle commande insérée
+		 */
+        public function create ($name, $script, $admin)
+        {
+            $command = [
+                'name' => $name,
+                'script' => $script,
+                'admin' => $admin,
+            ];
+
+            $modelCommand = new \models\Command($this->bdd);
+            $result = $modelCommand->insert($command);
+
+            if (!$result)
+            {
+                return false;
+            }
+
+            $internalEvent = new \controllers\internals\Event($this->bdd); 
+            $internalEvent->create('COMMAND_ADD', 'Ajout commande : ' . $name . ' => ' . $script);
+            return $result;
+		}
+
+		/**
+         * Cette fonction met à jour un commande
+         * @return int : le nombre de ligne modifiées
+		 */
+		public function update ($id, $name, $script, $admin)
+        {
+            $modelCommand = new \models\Command($this->bdd);
+
+            $command = [
+                'name' => $name,
+                'script' => $script,
+                'admin' => $admin,
+            ];
+
+            $result = $modelCommand->update($id, $command);
+        
+            return $result;
+        }
+	}

controllers/internals/Console.php

@@ -0,0 +1,420 @@
+<?php
+namespace controllers\internals;
+class Console extends \InternalController
+{
+
+    /**
+     * Cette fonction retourne l'aide de la console
+     */
+    public function help()
+    {
+        //On définit les commandes disponibles
+        $commands = array(
+            'sendScheduled' => array(
+                'description' => 'Cette commande permet d\'envoyer les SMS programmés qui doivent l\'êtres.',
+                'requireds' => array(),
+                'optionals' => array(),
+            ),
+            'parseReceivedSMS' => array(
+                'description' => 'Cette commande permet d\'enregistrer un SMS, et de l\'analyser pour voir s\'il contient une commande. Pour cela, il analyse le dossier PWD_RECEIVEDS',
+                'requireds' => array(
+                ),
+                'optionals' => array(),
+            ),
+            'sendTransfers' => array(
+                'description' => 'Cette commande permet d\'envoyer par mails les sms à transférés.',
+                'requireds' => [],
+                'optionals' => [],
+            ),
+        );
+
+        $message  = "Vous êtes ici dans l'aide de la console.\n";
+        $message .= "Voici la liste des commandes disponibles : \n";
+
+        //On écrit les texte pour la liste des commandes dispos
+        foreach ($commands as $name => $value)
+        {
+            $requireds = isset($value['requireds']) ? $value['requireds'] : array();
+            $optionals = isset($value['optionals']) ? $value['optionals'] : array();
+
+            $message .= '	' . $name . ' : ' . $value['description'] . "\n";
+            $message .= "		Arguments obligatoires : \n";
+            if (!count($requireds))
+            {
+                $message .= "			Pas d'argument\n";
+            }
+            else
+            {
+                foreach ($requireds as $argument => $desc)
+                {
+                    $message .= '				- ' . $argument . ' : ' . $desc . "\n";
+                }
+            }
+
+            $message .= "		Arguments optionnels : \n";
+            
+            if (!count($optionals))
+            {
+                $message .= "			Pas d'argument\n";
+            }
+            else
+            {
+                foreach ($optionals as $argument => $desc)
+                {
+                    $message .= '				- ' . $argument . ' : ' . $desc . "\n";
+                }
+            }
+        }
+
+        echo $message;
+    }
+
+    /**
+     * Cette fonction envoie tous les SMS programmés qui doivent l'être
+     */
+    public function sendScheduled()
+    {
+        //On créé l'objet de base de données
+        global $db;
+        
+        for ($i = 0; $i < 30; $i++)
+        {			
+            $now = new \DateTime();
+            $now = $now->format('Y-m-d H:i:s');
+
+            echo "Début de l'envoi des SMS programmés\n";
+
+            $scheduleds = $db->getScheduledNotInProgressBefore($now);
+
+            $ids_scheduleds = array();
+
+            //On passe en cours de progression tous les SMS
+            foreach ($scheduleds as $scheduled)
+            {
+                $ids_scheduleds[] = $scheduled['id'];
+            }
+
+            echo count($ids_scheduleds) . " SMS à envoyer ont été trouvés et ajoutés à la liste des SMS en cours d'envoi.\n";
+
+            $db->updateProgressScheduledIn($ids_scheduleds, true);
+
+            //Pour chaque SMS à envoyer
+            foreach ($scheduleds as $scheduled)
+            {
+                $id_scheduled = $scheduled['id'];
+                $text_sms = escapeshellarg($scheduled['content']);
+                $flash = $scheduled['flash'];
+ 
+                //On initialise les numéros auxquelles envoyer le SMS
+                $numbers = array();
+
+                //On récupère les numéros pour le SMS et on les ajoute
+                $target_numbers = $db->getNumbersForScheduled($id_scheduled);
+                foreach ($target_numbers as $target_number)
+                {
+                    $numbers[] = $target_number['number'];
+                }
+
+                //On récupère les contacts, et on ajoute les numéros
+                $contacts = $db->getContactForScheduled($id_scheduled);
+                foreach ($contacts as $contact)
+                {
+                    $numbers[] = $contact['number'];
+                }
+
+                //On récupère les groupes
+                $groupes = $db->getGroupeForScheduled($id_scheduled);
+                foreach ($groupes as $groupe)
+                {
+                    //On récupère les contacts du groupe et on les ajoute aux numéros
+                    $contacts = $db->getContactForGroupe($groupe['id']);
+                    foreach ($contacts as $contact)
+                    {
+                        $numbers[] = $contact['number'];
+                    }
+                }
+
+                $smsStops = $db->getFromTableWhere('smsstop');
+                
+                foreach ($numbers as $number)
+                {
+                    //Si les SMS STOP sont activés, on passe au numéro suivant si le numéro actuelle fait parti des SMS STOP
+                    if (RASPISMS_SETTINGS_SMSSTOPS)
+                    {
+                        foreach ($smsStops as $smsStop)
+                        {
+                            if (!($number == $smsStop['number']))
+                            {
+                                continue;
+                            }
+
+                            echo "Un SMS destiné au " . $number . " a été bloqué par SMS STOP\n";
+                            continue(2); //On passe au numéro suivant !
+                        }
+                    }
+
+                    echo "	Envoi d'un SMS au " . $number . "\n";
+                    //On ajoute le SMS aux SMS envoyés
+                    //Pour plus de précision, on remet la date à jour en réinstanciant l'objet \DateTime (et on reformatte la date, bien entendu)
+                    $now = new \DateTime();
+                    $now = $now->format('Y-m-d H:i:s');
+
+                    //On peut maintenant ajouter le SMS
+                    if (!$db->insertIntoTable('sendeds', ['at' => $now, 'target' => $number, 'content' => $scheduled['content'], 'before_delivered' => ceil(mb_strlen($scheduled['content'])/160)]))
+                    {
+                        echo 'Impossible d\'inserer le sms pour le numero ' . $number . "\n";
+                    }
+
+                    $id_sended = $db->lastId();
+                    
+                    //Commande qui envoie le SMS
+                    $commande_send_sms = 'gammu-smsd-inject TEXT ' . escapeshellarg($number) . ' -report -len ' . mb_strlen($text_sms) . ' -text ' . $text_sms;
+
+                    if (RASPISMS_SETTINGS_SMS_FLASH && $flash)
+                    {
+                        $commande_send_sms .= ' -flash';
+                    }
+
+                    //Commande qui s'assure de passer le SMS dans ceux envoyés, et de lui donner le bon statut
+
+                    //On va liée les deux commandes pour envoyer le SMS puis le passer en echec
+                    $commande = '(' . $commande_send_sms . ') >/dev/null 2>/dev/null &';
+                    exec($commande); //On execute la commande d'envoie d'un SMS
+                }
+            }
+
+            echo "Tous les SMS sont en cours d'envoi.\n";
+            //Tous les SMS ont été envoyés.	
+            $db->deleteScheduledIn($ids_scheduleds);
+
+            //On dors 2 secondes
+            sleep(2);
+        }
+    }
+
+    /**
+     * Cette fonction reçoit un SMS, et l'enregistre, en essayant dde trouver une commande au passage.
+     */
+    public function parseReceivedSMS()
+    {
+        //On créer l'objet de base de données
+        global $db;
+        
+        for ($i = 0; $i < 30; $i++)
+        {			
+            foreach (scandir(PWD_RECEIVEDS) as $dir)
+            {
+                //Si le fichier est un fichier système, on passe à l'itération suivante
+                if ($dir == '.' || $dir == '..' || $dir == '.tokeep')
+                {
+                    continue;
+                }				
+
+                echo "Analyse du SMS " . $dir . "\n";
+
+                //On récupère la date du SMS à la seconde près grâce au nom du fichier (Cf. parseSMS.sh)
+                //Il faut mettre la date au format Y-m-d H:i:s
+                $date = substr($dir, 0, 4) . '-' . substr($dir, 4, 2) . '-' . substr($dir, 6, 2) . ' ' . substr($dir, 8, 2) . ':' . substr($dir, 10, 2) . ':' . substr($dir, 12, 2);
+
+                //On récupère le fichier, et on récupère la chaine jusqu'au premier ':' pour le numéro de téléphone source, et la fin pour le message
+                $content_file = file_get_contents(PWD_RECEIVEDS . $dir);
+
+                //Si on peux pas ouvrir le fichier, on quitte en logant une erreur
+                if ($content_file == false)
+                {
+                    $this->wlog('Unable to read file "' . $dir);
+                    die(4);
+                }
+
+                //On supprime le fichier. Si on n'y arrive pas, alors on log
+                if (!unlink(PWD_RECEIVEDS . $dir))
+                {
+                    $this->wlog('Unable to delete file "' . $dir);
+                    die(8);
+                }
+
+                $content_file = explode(':', $content_file, 2);
+
+                //Si on a pas passé de numéro ou de message, alors on lève une erreur
+                if (!isset($content_file[0], $content_file[1]))
+                {
+                    $this->wlog('Missing params in file "' . $dir);
+                    die(5);
+                }
+
+                $number = $content_file[0];
+                $number = internalTool::parse_phone($number);
+                $text = $content_file[1];
+
+                //On gère les SMS STOP
+                if (trim($text) == 'STOP')
+                {
+                    echo 'STOP SMS detected ' . $number . "\n";
+                    $this->wlog('STOP SMS detected ' . $number);
+                    $db->insertIntoTable('smsstop', ['number' => $number]);
+                    continue;
+                }
+
+                //On gère les accusés de reception
+                if (trim($text) == 'Delivered' || trim($text) == 'Failed')
+                {
+                    echo 'Delivered or Failed SMS for ' . $number . "\n";
+                    $this->wlog('Delivered or Failed SMS for ' . $number);
+
+                    //On récupère les SMS pas encore validé, uniquement sur les dernières 12h
+                    $now = new \DateTime();
+                    $interval = new \DateInterval('PT12H');
+                    $sinceDate = $now->sub($interval)->format('Y-m-d H:i:s');
+
+                    if (!$sendeds = $db->getFromTableWhere('sendeds', ['target' => $number, 'delivered' => false, 'failed' => false, '>at' => $sinceDate], 'at', false, 1))
+                    {
+                        continue;
+                    }
+
+                    $sended = $sendeds[0];
+
+                    //On gère les echecs
+                    if (trim($text) == 'Failed')
+                    {
+                        $db->updateTableWhere('sendeds', ['before_delivered' => 0, 'failed' => true], ['id' => $sended['id']]);
+                        echo "Sended SMS id " . $sended['id'] . " pass to failed status\n";
+                        continue;
+                    }
+
+                    //On gère le cas des messages de plus de 160 caractères, lesquels impliquent plusieurs accusés
+                    if ($sended['before_delivered'] > 1)
+                    {
+                        $db->updateTableWhere('sendeds', ['before_delivered' => $sended['before_delivered'] - 1], ['id' => $sended['id']]);
+                        echo "Sended SMS id " . $sended['id'] . " before_delivered decrement\n";
+                        continue;
+                    }
+
+                    //Si tout est bon, que nous avons assez d'accusés, nous validons !
+                    $db->updateTableWhere('sendeds', ['before_delivered' => 0, 'delivered' => true], ['id' => $sended['id']]);
+                    echo "Sended SMS id " . $sended['id'] . " to delivered status\n";
+                    continue;
+                }
+                
+                if (!$number)
+                {
+                    $this->wlog('Invalid phone number in file "' . $dir);
+                    die(6);
+                }
+            
+                //On va vérifier si on a reçu une commande, et des identifiants
+                $flags = internalTool::parse_for_flag($text);
+
+                //On créer le tableau qui permettra de stocker les commandes trouvées
+
+                $found_commands = array();
+
+                //Si on reçu des identifiants
+                if (array_key_exists('LOGIN', $flags) && array_key_exists('PASSWORD', $flags))
+                {
+                    //Si on a bien un utilisateur avec les identifiants reçus
+                    $user = $db->getUserFromEmail($flags['LOGIN']);
+                    $this->wlog('We found ' . count($user) . ' users');
+                    if ($user && $user['password'] == sha1($flags['PASSWORD']))
+                    {
+                        $this->wlog('Password is valid');
+                        //On va passer en revue toutes les commandes, pour voir si on en trouve dans ce message
+                        $commands = $db->getFromTableWhere('commands');
+
+                        $this->wlog('We found ' . count($commands) . ' commands');
+                        foreach ($commands as $command)
+                        {
+                            $command_name = mb_strtoupper($command['name']);
+                            if (array_key_exists($command_name, $flags))
+                            {
+                                $this->wlog('We found command ' . $command_name);
+                                
+                                //Si la commande ne nécessite pas d'être admin, ou si on est admin
+                                if (!$command['admin'] || $user['admin'])
+                                {
+                                    $this->wlog('And the count is ok');
+                                    $found_commands[$command_name] = PWD_SCRIPTS . $command['script'] . escapeshellcmd($flags[$command_name]);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                //On va supprimer le mot de passe du SMS pour pouvoir l'enregistrer sans danger
+                if (isset($flags['PASSWORD']))
+                {
+                    $text = str_replace($flags['PASSWORD'], '*****', $text);
+                }
+
+                //On map les données et on créer le SMS reçu
+                $send_by = $number;
+                $content = $text;
+                $is_command = count($found_commands);
+                if (!$db->insertIntoTable('receiveds', ['at' => $date, 'send_by' => $send_by, 'content' => $content, 'is_command' => $is_command]))
+                {
+                    echo "Erreur lors de l'enregistrement du SMS\n";
+                    $this->wlog('Unable to process the SMS in file "' . $dir);
+                    die(7);
+                }
+
+                //On insert le SMS dans le tableau des sms à envoyer par mail
+                $db->insertIntoTable('transfers', ['id_received' => $db->lastId(), 'progress' => false]);
+
+                //Chaque commande sera executée.
+                foreach ($found_commands as $command_name => $command)
+                {
+                    echo 'Execution de la commande : ' . $command_name . ' :: ' . $command . "\n";
+                    exec($command);
+                }
+            }
+
+            //On attend 2 secondes
+            sleep(2);
+        }
+    }
+
+    /**
+     * Cette fonction permet d'envoyer par mail les sms à transférer
+     */
+    public function sendTransfers ()
+    {
+        if (!RASPISMS_SETTINGS_TRANSFER)
+        {
+            echo "Le transfer de SMS est désactivé ! \n";
+            return false;
+        }
+
+        global $db;
+        $transfers = $db->getFromTableWhere('transfers', ['progress' => false]);
+
+        $ids_transfers = [];
+        $ids_receiveds = [];
+        foreach ($transfers as $transfer)
+        {
+            $ids_transfers[] = $transfer['id'];
+            $ids_receiveds[] = $transfer['id_received'];
+        }
+        
+        $db->updateProgressTransfersIn($ids_transfers, true);
+        
+        $receiveds = $db->getReceivedIn($ids_receiveds);
+
+        $users = $db->getFromTableWhere('users', ['transfer' => true]);
+
+        foreach ($users as $user)
+        {
+            foreach ($receiveds as $received)
+            {
+                echo "Transfer d'un SMS du " . $received['send_by'] . " à l'email " . $user['email'];
+                $to = $user['email'];
+                $subject = '[RaspiSMS] - Transfert d\'un SMS du ' . $received['send_by'];
+                $message = "Le numéro " . $received['send_by'] . " vous a envoyé un SMS : \n" . $received['content'];
+                
+                $ok = mail($to, $subject, $message);
+                
+                echo " ... " . ($ok ? 'OK' : 'KO') . "\n";
+            }
+        }
+
+        $db->deleteTransfersIn($ids_transfers);
+    }
+}

controllers/internals/Contact.php

@@ -0,0 +1,121 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des contactes
+	 */
+	class Contact extends \InternalController
+	{
+
+		/**
+         * Cette fonction retourne une liste des contactes sous forme d'un tableau
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des contactes
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des contactes
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->get_list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des contactes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des contactes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des contactes
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->get_by_ids($ids);
+        }
+        
+        /**
+         * Cette fonction retourne un contact par son numéro de tel
+         * @param string $number : Le numéro du contact
+         * @return array : Le contact
+         */	
+		public function get_by_number ($number)
+		{
+			//Recupération des contactes
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->get_by_number($number);
+        }
+        
+        /**
+         * Cette fonction retourne un contact par son name
+         * @param string $name : Le name du contact
+         * @return array : Le contact
+         */	
+        public function get_by_name ($name)
+		{
+			//Recupération des contactes
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->get_by_name($name);
+        }
+        
+
+        /**
+         * Cette fonction permet de compter le nombre de contacts
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer un contact
+		 * @param array $id : L'id du contact à supprimer
+		 * @return int : Le nombre de contact supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelContact = new \models\Contact($this->bdd);
+            return $modelContact->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle contacte
+         * @param array $contact : Un tableau représentant la contacte à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle contacte insérée
+		 */
+        public function create ($number, $name)
+        {
+            $contact = [
+                'number' => $number,
+                'name' => $name,
+            ];
+
+            $modelContact = new \models\Contact($this->bdd);
+            
+            $result = $modelContact->insert($contact);
+            if (!$result)
+            {
+                return $result;
+            }
+
+            $internalEvent = new \controllers\internals\Event($this->bdd);
+            $internalEvent->create('CONTACT_ADD', 'Ajout contact : ' . $name . ' (' . \controllers\internals\Tool::phone_add_space($number) . ')');
+
+            return $result;
+		}
+
+		/**
+         * Cette fonction met à jour une série de contactes
+         * @return int : le nombre de ligne modifiées
+		 */
+		public function update ($id, $number, $name)
+        {
+            $modelContact = new \models\Contact($this->bdd);
+
+            $contact = [
+                'number' => $number,
+                'name' => $name,
+            ];
+        
+            return $modelContact->update($id, $contact);
+        }
+	}

controllers/internals/Event.php

@@ -0,0 +1,63 @@
+<?php
+    namespace controllers\internals;
+
+    /**
+     * Classe des Event
+	 */
+	class Event extends \InternalController
+	{
+
+		/**
+         * Cette fonction retourne une liste des events sous forme d'un tableau
+         * @param PDO $bdd :  instance PDO de la base de donnée
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des events
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des events
+            $modelEvent = new \models\Event($this->bdd);
+            return $modelEvent->get_list($nb_entry, $nb_entry * $page);
+		}
+
+        /**
+         * Cette fonction retourne les X dernières entrées triées par date
+         * @param mixed false|int $nb_entry : Nombre d'entrée à retourner ou faux pour tout
+         * @return array : Les dernières entrées
+         */
+        public function get_lasts_by_date ($nb_entry = false)
+        {
+            $modelEvent = new \models\Event($this->bdd);
+            return $modelEvent->get_lasts_by_date($nb_entry);
+        }
+
+		/**
+		 * Cette fonction va supprimer une liste de contacts
+		 * @param array $ids : Les id des contactes à supprimer
+		 * @return int : Le nombre de contactes supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelEvent = new \models\Event($this->bdd);
+            return $modelEvent->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert un nouvel event
+         * @param array $event : Un tableau représentant l'event à insérer
+         * @return mixed bool|int : false si echec, sinon l'id du nouvel event inséré
+		 */
+        public function create ($type, $text)
+        {
+            $modelEvent = new \models\Event($this->bdd);
+
+            $event = [
+                'type' => $type,
+                'text' => $text,
+            ];
+
+            return $modelEvent->insert($event);
+		}
+
+	}

controllers/internals/Groupe.php

@@ -0,0 +1,146 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des groupes
+	 */
+	class Groupe extends \InternalController
+	{
+
+		/**
+         * Cette fonction retourne une liste des groupes sous forme d'un tableau
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des groupes
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des groupes
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->get_list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des groupes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des groupes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des groupes
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->get_by_ids($ids);
+        }
+        
+        /**
+         * Cette fonction retourne un groupe par son name
+         * @param string $name : Le name du groupe
+         * @return array : Le groupe
+         */	
+        public function get_by_name ($name)
+		{
+			//Recupération des groupes
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->get_by_name($name);
+        }
+
+        /**
+         * Cette fonction permet de compter le nombre de groupe
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer une liste de groupe
+		 * @param array $ids : Les id des groupes à supprimer
+		 * @return int : Le nombre de groupes supprimées;
+		 */
+		public function delete ($ids)
+        {
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->delete_by_ids($ids);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle groupe
+         * @param array $name : le nom du groupe
+         * @param array $contacts_ids : Un tableau des ids des contact du groupe
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle groupe insérée
+		 */
+        public function create ($name, $contacts_ids)
+		{
+            $modelGroupe = new \models\Groupe($this->bdd);
+
+            $groupe = [
+                'name' => $name,
+            ]; 
+
+            $id_groupe = $modelGroupe->insert($groupe);
+            if (!$id_groupe)
+            {
+                return false;
+            }
+
+            foreach ($contacts_ids as $contact_id)
+            {
+                $modelGroupe->insert_groupe_contact($id_groupe, $contact_id);
+            }
+
+            $internalEvent = new \controllers\internals\Event($this->bdd);
+            $internalEvent->create('GROUP_ADD', 'Ajout groupe : ' . $name);
+
+            return $id_groupe;
+		}
+
+		/**
+         * Cette fonction met à jour un groupe
+         * @param int $id : L'id du groupe à update
+         * @param string $name : Le nom du groupe à update
+         * @param string $contacts_ids : Les ids des contact du groupe
+         * @return bool : True if all update ok, false else
+		 */
+		public function update ($id, $name, $contacts_ids)
+        {
+            $modelGroupe = new \models\Groupe($this->bdd);
+
+            $groupe = [
+                'name' => $name,
+            ];
+
+            $result = $modelGroupe->update($id, $groupe);
+
+            $modelGroupe->delete_groupe_contact($id);
+
+            $nb_contact_insert = 0;
+            foreach ($contacts_ids as $contact_id)
+            {
+                if ($modelGroupe->insert_groupe_contact($id, $contact_id))
+                {
+                    $nb_contact_insert ++;
+                }
+            }
+
+            if (!$result && $nb_contact_insert != count($contacts_ids))
+            {
+                return false;
+            }
+
+            return $true;
+        }
+        
+        /**
+         * Cette fonction retourne les contact pour un groupe
+         * @param string $id : L'id du groupe
+         * @return array : Un tableau avec les contact
+         */	
+        public function get_contact ($id)
+		{
+			//Recupération des groupes
+            $modelGroupe = new \models\Groupe($this->bdd);
+            return $modelGroupe->get_contact($id);
+        }
+
+	}

controllers/internals/Received.php

@@ -0,0 +1,165 @@
+<?php
+namespace controllers\internals;
+/**
+ * Classe des receivedes
+ */
+class Received extends \InternalController
+{
+
+    /**
+     * Cette fonction retourne une liste des receivedes sous forme d'un tableau
+     * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+     * @param mixed(int|bool) $page : Le numéro de page en cours
+     * @return array : La liste des receivedes
+     */	
+    public function get_list ($nb_entry = false, $page = false)
+    {
+        //Recupération des receivedes
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_list($nb_entry, $nb_entry * $page);
+    }
+    
+
+    /**
+     * Cette fonction retourne une liste des receivedes sous forme d'un tableau
+     * @param array int $ids : Les ids des entrées à retourner
+     * @return array : La liste des receivedes
+     */	
+    public function get_by_ids ($ids)
+    {
+        //Recupération des receivedes
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_by_ids($ids);
+    }
+    
+    /**
+     * Cette fonction retourne les X dernières entrées triées par date
+     * @param mixed false|int $nb_entry : Nombre d'entrée à retourner ou faux pour tout
+     * @return array : Les dernières entrées
+     */
+    public function get_lasts_by_date ($nb_entry = false)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_lasts_by_date($nb_entry);
+    }
+    
+    /**
+     * Cette fonction retourne une liste des receiveds sous forme d'un tableau
+     * @param string $origin : Le numéro depuis lequel est envoyé le message
+     * @return array : La liste des receiveds
+     */	
+    public function get_by_origin ($origin)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_by_origin($origin);
+    }
+
+    /**
+     * Récupère les SMS reçus depuis une date
+     * @param $date : La date depuis laquelle on veux les SMS (au format 2014-10-25 20:10:05)
+     * @return array : Tableau avec tous les SMS depuis la date
+     */
+    public function get_since_by_date ($date)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_since_by_date($date, $number);
+    }
+
+    /**
+     * Récupère les SMS reçus depuis une date pour un numero
+     * @param $date : La date depuis laquelle on veux les SMS (au format 2014-10-25 20:10:05)
+     * @param $number : Le numéro
+     * @return array : Tableau avec tous les SMS depuis la date
+     */
+    public function get_since_for_number_by_date ($date, $number)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_since_for_number_by_date($date, $number);
+    }
+
+    /**
+     * Cette fonction va supprimer une liste de receiveds
+     * @param array $ids : Les id des receivedes à supprimer
+     * @return int : Le nombre de receivedes supprimées;
+     */
+    public function delete ($id)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->delete_by_id($id);
+    }
+
+    /**
+     * Cette fonction insert une nouvelle receivede
+     * @param array $received : Un tableau représentant la receivede à insérer
+     * @return mixed bool|int : false si echec, sinon l'id de la nouvelle receivede insérée
+     */
+    public function create ($at, $origin, $content, $is_command)
+    {
+        $received = [
+            'at' => $at,
+            'origin' => $origin,
+            'content' => $content,
+            'is_command' => $is_command,
+        ];
+
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->create($received);
+    }
+
+    /**
+     * Cette fonction met à jour une série de receivedes
+     * @return int : le nombre de ligne modifiées
+     */
+    public function update ($id, $at, $origin, $content, $is_command)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        
+        $received = [
+            'at' => $at,
+            'origin' => $origin,
+            'content' => $content,
+            'is_command' => $is_command,
+        ];
+
+        return $modelReceived->update($id, $received);
+    }
+
+    /**
+     * Cette fonction permet de compter le nombre de receiveds
+     * @return int : Le nombre d'entrées dans la table
+     */
+    public function count ()
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->count();
+    }
+
+    /**
+     * Cette fonction compte le nombre de receiveds par jour depuis une date
+     * @return array : un tableau avec en clef la date et en valeure le nombre de sms envoyés
+     */
+    public function count_by_day_since ($date)
+    {
+        $modelReceived = new \models\Received($this->bdd);
+
+        $counts_by_day = $modelReceived->count_by_day_since($date);
+        $return = [];
+        
+        foreach ($counts_by_day as $count_by_day)
+        {
+            $return[$count_by_day['at_ymd']] = $count_by_day['nb'];
+        }
+
+        return $return;
+    }
+    
+    /**
+     * Cette fonction retourne les discussions avec un numéro
+     * @return array : Un tableau avec la date de l'échange et le numéro de la personne
+     */
+    public function get_discussions ()
+    {
+        $modelReceived = new \models\Received($this->bdd);
+        return $modelReceived->get_discussions();
+    }
+}

controllers/internals/SMSStop.php

@@ -0,0 +1,99 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des smsstopes
+	 */
+	class SMSStop extends \InternalController
+	{
+		/**
+         * Cette fonction retourne une liste des smsstopes sous forme d'un tableau
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des smsstopes
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des smsstopes
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->get_list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des smsstopes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des smsstopes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des smsstopes
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->get_by_ids($ids);
+        }
+        
+        /**
+         * Cette fonction retourne un smsstop par son numéro de tel
+         * @param string $number : Le numéro du smsstop
+         * @return array : Le smsstop
+         */	
+		public function get_by_number ($number)
+		{
+			//Recupération des smsstopes
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->get_by_number($number);
+        }
+        
+
+        /**
+         * Cette fonction permet de compter le nombre de smsstops
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer une liste de smsstops
+		 * @param array $ids : Les id des smsstopes à supprimer
+		 * @return int : Le nombre de smsstopes supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle smsstope
+         * @param array $smsstop : Un tableau représentant la smsstope à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle smsstope insérée
+		 */
+        public function create ($smsstop)
+		{
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            return $modelSMSStop->insert($smsstop);
+		}
+
+		/**
+         * Cette fonction met à jour une série de smsstopes
+         * @return int : le nombre de ligne modifiées
+		 */
+		public function update ($smsstops)
+        {
+            $modelSMSStop = new \models\SMSStop($this->bdd);
+            
+            $nb_update = 0;
+            foreach ($smsstops as $smsstop)
+            {
+                $result = $modelSMSStop->update($smsstop['id'], $smsstop);
+
+                if ($result)
+                {
+                    $nb_update ++;
+                }
+            }
+        
+            return $nb_update;
+        }
+	}

controllers/internals/Scheduled.php

@@ -0,0 +1,183 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des scheduledes
+	 */
+	class Scheduled extends \InternalController
+	{
+        
+		/**
+         * Cette fonction retourne une liste des scheduledes sous forme d'un tableau
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des scheduledes
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des scheduledes
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des scheduledes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des scheduledes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des scheduledes
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_by_ids($ids);
+        }
+
+        /**
+         * Cette fonction retourne les messages programmés avant une date et pour un numéro
+         * @param \DateTime $date : La date avant laquelle on veux le message
+         * @param string $number : Le numéro
+         * @return array : Les messages programmés avant la date
+         */
+        public function get_before_date_for_number ($date, $number)
+        {
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_before_date_for_number($date, $number);
+        }
+
+        /**
+         * Cette fonction permet de compter le nombre de scheduled
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer un scheduled
+		 * @param int $id : L'id du scheduled à supprimer
+		 * @return int : Le nombre de scheduledes supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert un nouveau scheduled
+         * @param array $scheduled : Le scheduled à créer avec at, content, flash, progress
+         * @param array $numbers : Les numéros auxquels envoyer le scheduled
+         * @param array $contacts_ids : Les ids des contact auquels envoyer le scheduled
+         * @param array $groupes_ids : Les ids des groupe auxquels envoyer le scheduled
+         * @return mixed bool|int : false si echec, sinon l'id du nouveau scheduled inséré
+		 */
+        public function create ($scheduled, $numbers = [], $contacts_ids = [], $groupes_ids = [])
+		{
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            
+            if (!$id_scheduled = $modelScheduled->insert($scheduled))
+            {
+                $internalEvent = new \controllers\internals\Event($this->bdd);
+                $internalEvent->create('SCHEDULED_ADD', 'Ajout d\'un SMS pour le ' . $date . '.');
+
+                return false;
+            }
+
+            foreach ($numbers as $number)
+            {
+                $modelScheduled->insert_scheduled_number($id_scheduled, $number);
+            }
+
+            foreach ($contacts_ids as $contact_id)
+            {
+                $modelScheduled->insert_scheduled_contact($id_scheduled, $contact_id);
+            }
+            
+            foreach ($groupes_ids as $groupe_id)
+            {
+                $modelScheduled->insert_scheduled_groupe($id_scheduled, $groupe_id);
+            }
+
+            return $id_scheduled;
+		}
+
+		/**
+         * Cette fonction met à jour une série de scheduledes
+         * @param array $scheduleds : Un tableau de scheduled à modifier avec at, content, flash, progress + pour chaque scheduled number, contact_ids, groupe_ids
+         * @param array $numbers : Les numéros auxquels envoyer le scheduled
+         * @param array $contacts_ids : Les ids des contact auquels envoyer le scheduled
+         * @param array $groupes_ids : Les ids des groupe auxquels envoyer le scheduled
+         * @return int : le nombre de ligne modifiées
+		 */
+        public function update ($scheduleds)
+        {
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            
+            $nb_update = 0;
+            foreach ($scheduleds as $scheduled)
+            {
+                $result = $modelScheduled->update($scheduled['scheduled']['id'], $scheduled['scheduled']);
+
+                $modelScheduled->delete_scheduled_number($scheduled['scheduled']['id']);
+                $modelScheduled->delete_scheduled_contact($scheduled['scheduled']['id']);
+                $modelScheduled->delete_scheduled_groupe($scheduled['scheduled']['id']);
+
+                foreach ($scheduled['number'] as $number)
+                {
+                    $modelScheduled->insert_scheduled_number($scheduled['scheduled']['id'], $number);
+                }
+
+                foreach ($scheduled['contact_ids'] as $contact_id)
+                {
+                    $modelScheduled->insert_scheduled_contact($scheduled['scheduled']['id'], $contact_id);
+                }
+                
+                foreach ($scheduled['groupe_ids'] as $groupe_id)
+                {
+                    $modelScheduled->insert_scheduled_groupe($scheduled['scheduled']['id'], $groupe_id);
+                }
+                
+
+                $nb_update ++;
+            }
+        
+            return $nb_update;
+        }
+        
+        /**
+         * Cette fonction retourne une liste de numéro pour un scheduled
+         * @param int $id_scheduled : L'id du scheduled pour lequel on veux le numéro
+         * @return array : La liste des scheduledes
+         */	
+        public function get_number ($id_scheduled)
+		{
+			//Recupération des scheduledes
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_number($id_scheduled);
+		}
+
+        /**
+         * Cette fonction retourne une liste de contact pour un scheduled
+         * @param int $id_scheduled : L'id du scheduled pour lequel on veux le numéro
+         * @return array : La liste des contact
+         */	
+        public function get_contact ($id_scheduled)
+		{
+			//Recupération des scheduledes
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_contact($id_scheduled);
+		}
+        
+        /**
+         * Cette fonction retourne une liste de groupe pour un scheduled
+         * @param int $id_scheduled : L'id du scheduled pour lequel on veux le numéro
+         * @return array : La liste des groupe
+         */	
+        public function get_groupe ($id_scheduled)
+		{
+			//Recupération des scheduledes
+            $modelScheduled = new \models\Scheduled($this->bdd);
+            return $modelScheduled->get_groupe($id_scheduled);
+		}
+	}

controllers/internals/Sended.php

@@ -0,0 +1,130 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des sendedes
+	 */
+	class Sended extends \InternalController
+	{
+
+		/**
+         * Cette fonction retourne une liste des sendedes sous forme d'un tableau
+         * @param mixed(int|bool) $nb_entry : Le nombre d'entrées à retourner par page
+         * @param mixed(int|bool) $page : Le numéro de page en cours
+         * @return array : La liste des sendedes
+         */	
+		public function get_list ($nb_entry = false, $page = false)
+		{
+			//Recupération des sendedes
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->get_list($nb_entry, $nb_entry * $page);
+		}
+
+		/**
+         * Cette fonction retourne une liste des sendedes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des sendedes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des sendedes
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->get_by_ids($ids);
+        }
+
+        /**
+         * Cette fonction retourne les X dernières entrées triées par date
+         * @param mixed false|int $nb_entry : Nombre d'entrée à retourner ou faux pour tout
+         * @return array : Les dernières entrées
+         */
+        public function get_lasts_by_date ($nb_entry = false)
+        {
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->get_lasts_by_date($nb_entry);
+        }
+        
+        /**
+         * Cette fonction retourne une liste des receivedes sous forme d'un tableau
+         * @param string $target : Le numéro de à qui est envoyé le message
+         * @return array : La liste des sendeds
+         */	
+		public function get_by_target ($target)
+		{
+			//Recupération des sendeds
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->get_by_target($target);
+        }
+
+
+		/**
+		 * Cette fonction va supprimer une liste de sendeds
+		 * @param array $ids : Les id des sendedes à supprimer
+		 * @return int : Le nombre de sendedes supprimées;
+		 */
+		public function delete ($id)
+        {
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->delete_by_id($id);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle sendede
+         * @param array $sended : Un tableau représentant la sendede à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle sendede insérée
+		 */
+        public function create ($sended)
+		{
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->create($sended);
+		}
+
+		/**
+         * Cette fonction met à jour une série de sendedes
+         * @return int : le nombre de ligne modifiées
+		 */
+		public function update ($sendeds)
+        {
+            $modelSended = new \models\Sended($this->bdd);
+            
+            $nb_update = 0;
+            foreach ($sendeds as $sended)
+            {
+                $result = $modelSended->update($sended['id'], $sended);
+
+                if ($result)
+                {
+                    $nb_update ++;
+                }
+            }
+        
+            return $nb_update;
+        }
+        
+        /**
+         * Cette fonction permet de compter le nombre de sendeds
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelSended = new \models\Sended($this->bdd);
+            return $modelSended->count();
+        }
+
+        /**
+         * Cette fonction compte le nombre de sendeds par jour depuis une date
+         * @return array : un tableau avec en clef la date et en valeure le nombre de sms envoyés
+         */
+        public function count_by_day_since ($date)
+        {
+            $modelSended = new \models\Sended($this->bdd);
+
+            $counts_by_day = $modelSended->count_by_day_since($date);
+            $return = [];
+            
+            foreach ($counts_by_day as $count_by_day)
+            {
+                $return[$count_by_day['at_ymd']] = $count_by_day['nb'];
+            }
+
+            return $return;
+        }
+	}

controllers/internals/Setting.php

@@ -0,0 +1,29 @@
+<?php
+    namespace controllers\internals;
+
+    class Setting extends \InternalController
+    {
+        private $model_setting;
+
+        public function __construct (\PDO $bdd)
+        {
+            $this->model_setting = new \models\Setting($bdd);
+        }
+
+		/**
+         * Return all settings
+         * @return array || false
+         */	
+        public function all ()
+		{
+            return $this->model_setting->all();
+		}
+
+		/**
+         * Update a setting by his name
+		 */
+		public function update (string $name, $value) : boolean
+        {
+            return (bool) $this->model_setting->update($name, $value);
+        }
+	}

controllers/internals/Tool.php

@@ -0,0 +1,150 @@
+<?php
+    namespace controllers\internals;
+	class Tool extends \InternalController
+	{
+		/**
+		 * Cette fonction parse un numéro pour le retourner sans espaces, etc.
+		 * @param string $number : Le numéro de téléphone à parser
+		 * @return mixed : Si le numéro est bien un numéro de téléphone, on retourne le numéro parsé. Sinon, on retourne faux
+		 */
+		public static function parse_phone($number)
+		{
+			$number = preg_replace('#[^-0-9+]#', '', $number);
+			if (preg_match('#^(0|\+[1-9]{1,3}|\+1\-[0-9]{3})[1-9][0-9]{8,10}$#', $number))
+			{
+				return $number;
+			}
+			
+			return false;
+		}
+
+		/**
+		 * Cette fonction parse un numéro pour le retourner avec des espaces, etc.
+		 * @param string $number : Le numéro de téléphone à parser
+		 * @return mixed : Si le numéro est bien un numéro de téléphone, on retourne le numéro parsé. Sinon, on retourne faux
+		 */
+		public static function phone_add_space($number)
+		{
+			return preg_replace('#(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})#', '$1 $2 $3 $4 $5', $number);
+		}
+
+		/**
+		 * Cette fonction fait la correspondance entre un type d'evenement et une icone font awesome.
+		 * @param string $type : Le type de l'évenement à analyser
+		 * @return string : Le nom de l'icone à afficher (ex : fa-user)
+		 */
+		public static function event_type_to_icon($type)
+		{
+			switch ($type)
+			{
+				case 'USER_ADD' :
+					$logo = 'fa-user';
+					break;
+				case 'CONTACT_ADD' :
+					$logo = 'fa-user';
+					break;
+				case 'GROUP_ADD' :
+					$logo = 'fa-group';
+					break;
+				case 'SCHEDULED_ADD' :
+					$logo = 'fa-calendar';
+					break;
+				case 'COMMAND_ADD' :
+					$logo = 'fa-terminal';
+					break;
+				default :
+					$logo = 'fa-question';
+			}
+
+			return $logo;	
+		}
+
+		/**
+		 * Cette fonction vérifie une date
+		 * @param string $date : La date a valider
+		 * @param string $format : Le format de la date
+		 * @return boolean : Vrai si la date et valide, faux sinon
+		 */
+		public static function validate_date($date, $format)
+		{
+			$objectDate = \DateTime::createFromFormat($format, $date);
+			return ($objectDate && $objectDate->format($format) == $date);
+		}
+
+		/**
+		 * Cette fonction parse un texte, pour en extraire des données contenu dans des drapeaux au format [FLAG:contenu du drapeau]
+		 * @param string $texte : Le texte à parser
+		 * @return mixed : Tableau de la forme 'FLAG' => 'contenu du drapeau'. si on trouve une forme correcte (Le contenu de FLAG sera mis en majuscule automatiquement). Sinon le tableau vide.
+		 */
+		public static function parse_for_flag($texte)
+		{
+			$returns = array();
+			$results = array();
+			while(preg_match('#\[(.*)(?<!\\\):(.*)(?<!\\\)\]#Uui', $texte, $results)) //Tant qu'on recuèpre un flag
+			{
+				$returns[mb_strtoupper($results[1])] = $results[2];
+				$texte = str_replace($results[0], '', $texte);
+			}
+			
+			return $returns;
+		}
+
+		/**
+		 * Cette fonction retourne un mot de passe généré aléatoirement
+		 * @param int $length : Taille du mot de passe à générer
+		 * @return string : Le mot de passe aléatoire
+		 */
+		public static function generate_password($length)
+		{
+			$chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-@()?.:!%*$&/';
+			$password = '';
+			$chars_length = mb_strlen($chars) - 1;
+			$i = 0;
+			while ($i < $length)
+			{
+				$i ++;
+				$password .= $chars[rand(0, $chars_length)];
+			}
+			return $password;	
+		}
+
+		/**
+		 * Cette fonction vérifie si un utilisateur et connecté, et si il ne l'est pas, redirige sur la page de connexion
+		 * @return void
+		 */
+		public static function verify_connect()
+		{
+			if (!isset($_SESSION['connect']) || !$_SESSION['connect'])
+			{
+				header('Location: /');
+				die();
+			}
+        }
+        
+        /**
+         * Check if the user is admin.
+         * @return Bool : True if admin, False else
+		 */
+		public static function is_admin()
+		{
+			if (!isset($_SESSION['user']) || !$_SESSION['connect']['admin'])
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+        /**
+         * Cette fonction s'occupe d'envoyer les emails
+         * @param string $to : L'adresse mail à laquelle envoyer le mail
+         * @param array $settings : Les settings du mail, type, sujet, template
+         * @param array $datas : Les données à fournir au template du mail
+         */
+        public function send_email ($to, $settings, $datas = [])
+        {
+            $controller = new \Controller();
+            $content = $controller->render($settings['template'], $datas, true);
+            return true;#mail($to, $settings['subject'], $content); 
+        }
+	}

controllers/internals/User.php

@@ -0,0 +1,142 @@
+<?php
+    namespace controllers\internals;
+
+    class User extends \InternalController
+	{
+        private $model_user;
+
+        public function __construct (\PDO $bdd)
+        {
+            $this->model_user = new \models\User($bdd);
+            $this->internal_event = new \controllers\internals\Event($bdd);
+        }
+
+		/**
+         * Return list of users as an array
+         * @param mixed(int|bool) $nb_entry : Number of entry to return
+         * @param mixed(int|bool) $page : Numero of page
+         * @return array|bool : List of user or false
+         */	
+        public function list (?int $nb_entry = null, ?int $page = null)
+        {
+            return $this->model_user->list($nb_entry, $page);
+        }
+        
+        /**
+		 * Cette fonction va supprimer une liste de users
+		 * @param array $ids : Les id des useres à supprimer
+		 * @return int : Le nombre de useres supprimées;
+		 */
+		public function delete ($id)
+        {
+            return $this->model_user->remove($id);
+		}
+
+		/**
+         * Cette fonction vérifie s'il existe un utilisateur qui corresponde à ce couple login/password
+         * @param string $email : L'eamil de l'utilisateur
+         * @param string $password : Le mot de passe de l'utilisateur
+         * @return mixed false | array : False si pas de user, le user correspondant sous forme d'array sinon
+		 */
+		public function check_credentials ($email, $password)
+        {
+            $user = $this->model_user->get_by_email($email);
+            if (!$user)
+            {
+                return false;
+            }
+
+            if (!password_verify($password, $user['password']))
+            {
+                return false;
+            }
+
+            return $user;
+		}
+
+		/**
+         * Update a user password
+         * @param string $id : User id
+         * @param string $password : New password
+		 * @return boolean;
+		 */
+		public function update_password (int $id, string $password) : boolean
+		{
+            $password = password_hash($password, PASSWORD_DEFAULT);
+            return (bool) $this->model_user->update_password($id, $password);
+        }
+        
+        /**
+         * Update a user transfer property value
+         * @param string $id : User id
+         * @param string $transfer : New value of property transfer
+		 * @return boolean;
+		 */
+		public function update_transfer (int $id, int $transfer) : boolean
+		{
+            return (bool) $this->model_user->update_transfer($id, $transfer);
+        }
+        
+        /**
+         * Update user email
+         * @param string $id : user id
+         * @param string $email : new mail
+		 * @return boolean;
+		 */
+		public function update_email ($id, $email)
+		{
+            return (bool) $this->model_user->update_email($id, $email);
+        }
+
+        /**
+         * Cette fonction retourne un utilisateur pour un mail donné
+         * @param string $email : L'email de l'utilisateur
+         * @return mixed boolean | array : false si pas de user pour le mail, le user sinon
+         */
+        public function get_by_email ($email)
+        {
+            return $model_user->get_by_email($email);
+        }
+
+		/**
+         * Cette fonction met à jour une série de users
+         * @return int : le nombre de ligne modifiées
+		 */
+        public function update ($id, $email, $password, $admin, $transfer)
+        {
+            $user = [
+                'email' => $email,
+                'password' => password_hash($password, PASSWORD_DEFAULT),
+                'admin' => $admin,
+                'transfer' => $transfer,
+            ];
+
+            return $model_user->update($id, $user); 
+        }
+        
+        /**
+         * Cette fonction insert une nouvelle usere
+         * @param array $user : Un tableau représentant la usere à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle usere insérée
+		 */
+        public function create ($email, $password, $admin, $transfer = false)
+        {
+            $user = [
+                'email' => $email,
+                'password' => password_hash($password, PASSWORD_DEFAULT),
+                'admin' => $admin,
+                'transfer' => $transfer,
+            ];
+
+            $result = $model_user->insert($user);
+
+            if (!$result)
+            {
+                return false;
+            }
+
+            $internal_event->create('CONTACT_ADD', 'Ajout de l\'utilisateur : ' . $email . '.');
+            
+            return $result;
+		}
+	}

controllers/internals/toto.php

@@ -0,0 +1,113 @@
+<?php
+namespace controllers\internals;
+	/**
+	 * Classe des commandes
+	 */
+	class Command extends \InternalController
+	{
+
+		public function populate_database ($nb_entry = false, $page = false)
+        {
+            global $bdd;
+            $internalContact = new \controllers\internals\Contact($bdd);
+            $internalGroupe = new \controllers\internals\Groupe($bdd);
+
+            #On insert des contacts & regroupe aléatoirement les ids en groupes
+            $groupes_contacts_ids = [];
+            for ($i = 0; $i < 100; $i ++)
+            {
+                $contact = [
+                    'name' => 'Contact N°' . $i,
+                    'number' => '06' . rand(10,99) . rand(10,99) . rand(10,99) . rand(10,99),
+                ]
+
+                if (!$id_contact = $internalContact->create($contact))
+                {
+                    continue;
+                }
+
+                $nb_groupe = rand(0,14);
+
+                if (!isset($groupes[$nb_groupe]))
+                {
+                    $groupes_contacts_ids[$nb_groupe] = [];
+                }
+
+                $groupes_contacts_ids[$nb_groupe][] = $id_contact;
+            }
+
+            #On insert les groupes
+            foreach ($groupes_contacts_ids as $key => $groupe_contacts_ids)
+            {
+                $internalGroupe->create(['name' => 'Groupe N°' . $key], $groupe_contacts_ids);
+            }
+
+
+        }
+
+		/**
+         * Cette fonction retourne une liste des commandes sous forme d'un tableau
+         * @param array int $ids : Les ids des entrées à retourner
+         * @return array : La liste des commandes
+         */	
+		public function get_by_ids ($ids)
+		{
+			//Recupération des commandes
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->get_by_ids($ids);
+        }
+
+        /**
+         * Cette fonction permet de compter le nombre de scheduleds
+         * @return int : Le nombre d'entrées dans la table
+         */
+        public function count ()
+        {
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->count();
+        }
+
+		/**
+		 * Cette fonction va supprimer une liste de commands
+		 * @param array $ids : Les id des commandes à supprimer
+		 * @return int : Le nombre de commandes supprimées;
+		 */
+		public function delete ($ids)
+        {
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->delete_by_ids($ids);
+		}
+
+		/**
+         * Cette fonction insert une nouvelle commande
+         * @param array $command : La commande à insérer
+         * @return mixed bool|int : false si echec, sinon l'id de la nouvelle commande insérée
+		 */
+        public function create ($command)
+		{
+            $modelCommand = new \models\Command($this->bdd);
+            return $modelCommand->insert($command);
+		}
+
+		/**
+         * Cette fonction met à jour une série de commandes
+         * @return int : le nombre de ligne modifiées
+		 */
+		public function update ($commands)
+        {
+            $modelCommand = new \models\Command($this->bdd);
+            
+            $nb_update = 0;
+            foreach ($commands as $command)
+            {
+                $result = $modelCommand->update($command['id'], $command);
+
+                if ($result)
+                {
+                    $nb_update ++;
+                }
+            }
+        
+            return $nb_update;
+        }
+	}