Mascali/raspisms
1
0
Fork 0
mirror of https://github.com/RaspbianFrance/raspisms.git synced 2025-04-20 16:37:48 +02:00
Code Issues Projects Releases Wiki Activity

Mise en place du code, jusqu'ici développé en local

Browse source
This commit is contained in:
Raspbian 2015-02-17 16:17:38 +01:00
parent d8e121057e
commit 538d242f18
160 changed files with 28859 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

157
controllers/commands.php Executable file
View file

@ -0,0 +1,157 @@
<?php
/**
* Page des commandes
*/
class commands extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne toutes les commandes, sous forme d'un tableau permettant l'administration de ces commandess
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
//Recupération des commandes
$commands = $db->getAll('commands');
$this->render('commands', array(
'commands' => $commands,
));
}
/**
* Cette fonction va supprimer une liste de commands
* @return void;
*/
public function delete()
{
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('commands', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Create de l'object de base de données
global $db;
$commands_ids = $_GET;
$db->deleteCommandsIn($commands_ids);
header('Location: ' . $this->generateUrl('commands'));
}
/**
* Cette fonction retourne la page d'ajout d'une commande
*/
public function add()
{
$this->render('addCommand');
}
/**
* Cette fonction retourne la page d'édition des contacts
*/
public function edit()
{
global $db;
$commands = $db->getCommandsIn($_GET);
$this->render('editCommands', array(
'commands' => $commands,
));
}
/**
* Cette fonction insert une nouvelle commande
*/
public function create()
{
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('commands', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
$nom = $_POST['name'];
$script = $_POST['script'];
$admin = (isset($_POST['admin']) ? $_POST['admin'] : false);
if ($db->createCommand($nom, $script, $admin))
{
$db->createEvent('COMMAND_ADD', 'Ajout commande : ' . $nom . ' => ' . $script);
header('Location: ' . $this->generateUrl('commands', 'showAll', array(
'successmessage' => 'La commande a bien été créée.'
)));
return true;
}
header('Location: ' . $this->generateUrl('commands', 'add', array(
'errormessage' => 'Impossible créer cette commande.'
)));
return false;
}
/**
* Cette fonction met à jour une commande
*/
public function update()
{
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('commands', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
$errors = array(); //On initialise le tableau qui contiendra les erreurs rencontrés
//Pour chaque commande reçu, on boucle en récupérant son id (la clef), et la commande elle-même (la value)
foreach ($_POST['commands'] as $id => $command)
{
$db->updateCommand($id, $command['name'], $command['script'], $command['admin']);
}
$message = 'Toutes les commandes ont été modifiées avec succès.';
header('Location: ' . $this->generateUrl('commands', 'showAll', array(
'successmessage' => $message,
)));
}
public function flagMeThat()
{
var_dump(internalTools::parseForFlag('[COMMAND:chauffer 35][PASSWORD:mon password qui rox][LOGin:monlogin]'));
}
}

133
controllers/connect.php Executable file
View file

@ -0,0 +1,133 @@
<?php
/**
* Page de connexion
*/
class connect extends Controller
{
/**
* Cette fonction est alias de login()
*/
public function byDefault()
{
$this->login();
}
/**
* Cette fonction retourne la fenetre de connexion
* @return void;
*/
public function login()
{
//Creation de l'object de base de données
global $db;
$this->render('login');
}
/**
* Cette fonction retourne la fenetre de changement de password
* @return void;
*/
public function forgetPassword()
{
//Creation de l'object de base de données
global $db;
$this->render('forgetPassword');
}
/**
* Cette fonction connecte un utilisateur, et le redirige sur la page d'accueil
* @param string $_POST['mail'] : L'email de l'utilisateur
* @param string $_POST['password'] : Le mot de passe de l'utilisateur
* @return void
*/
public function connection()
{
//Creation de l'object de base de données
global $db;
$email = $_POST['mail'];
$password = $_POST['password'];
if ($user = $db->getUserFromEmail($email))
{
if (sha1($password) == $user['password'])
{
$_SESSION['connect'] = true;
$_SESSION['admin'] = $user['admin'];
$_SESSION['email'] = $user['email'];
$_SESSION['csrf'] = str_shuffle(uniqid().uniqid());
header('Location: ' . $this->generateUrl(''));
return true;
}
header('Location: ' . $this->generateUrl('connect', 'login', array(
'errormessage' => 'Identifiants incorrects.'
)));
return false;
}
header('Location: ' . $this->generateUrl('connect', 'login', array(
'errormessage' => 'Cet e-mail n\'existe pas.'
)));
return false;
}
/**
* Cette fonction change le mot de passe d'un utilisateur à partir de son email. Un mot de passe aléatoire et généré, et lui est envoyé
* @param string $_POST['mail'] : L'email de l'utilisateur cible
* @return void;
*/
public function changePassword()
{
//Creation de l'object de base de données
global $db;
$email = $_POST['mail'];
if ($user = $db->getUserFromEmail($email))
{
$password = internalTools::generatePassword(rand(8,12));
$message = "Vous avez demandé un nouveau mot de passe pour le site " . HTTP_PWD . ".\n";
$message = "Votre nouveau mot de passe a été généré aléatoirement, et n'est connu que de vous. Le voici : \n";
$message .= "Nouveau mot de passe : " . $password . "\n\n";
$message .= "-------------------------------------\n";
$message .= "Pour plus d'informations sur le système RaspiSMS, rendez-vous sur le site http://raspbian-france.fr\n";
if (mail($email, 'RaspiSMS - Recuperation de mot de passe', $message))
{
$new_password = sha1($password);
if ($db->updateUser($user['id'], $user['email'], $new_password, $user['admin']))
{
header('Location: ' . $this->generateUrl('connect', 'login', array(
'successmessage' => 'Un nouveau mot de passe vous a été envoyé par mail.'
)));
return true;
}
}
header('Location: ' . $this->generateUrl('connect', 'forgetPassword', array(
'errormessage' => 'Impossible d\'envoyer les nouveaux identifiants.'
)));
return false;
}
header('Location: ' . $this->generateUrl('connect', 'forgetPassword', array(
'errormessage' => 'Cet e-mail n\'existe pas.'
)));
return false;
}
/**
* Cette fonction déconnecte un utilisateur et le renvoie sur la page d'accueil
* @return void
*/
public function logout()
{
session_unset();
session_destroy();
header('Location: ' . $this->generateUrl(''));
}
}

185
controllers/contacts.php Executable file
View file

@ -0,0 +1,185 @@
<?php
/**
* Page des contacts
*/
class contacts extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les contacts, sous forme d'un tableau permettant l'administration de ces contacts
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
//Recupération des nombres des 4 panneaux d'accueil
$contacts = $db->getAll('contacts');
$this->render('contacts', array(
'contacts' => $contacts,
));
}
/**
* Cette fonction supprimer une liste de contacts
* @return void;
*/
public function delete()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
}
//Create de l'object de base de données
global $db;
$contacts_ids = $_GET;
$db->deleteContactsIn($contacts_ids);
header('Location: ' . $this->generateUrl('contacts'));
}
/**
* Cette fonction retourne la page d'ajout d'un contact
*/
public function add()
{
$this->render('addContact');
}
/**
* Cette fonction retourne la page d'édition des contacts
*/
public function edit()
{
global $db;
$contacts = $db->getContactsIn($_GET);
$this->render('editContacts', array(
'contacts' => $contacts,
));
}
/**
* Cette fonction insert un nouveau contact
*/
public function create()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
}
global $db;
$nom = $_POST['name'];
$phone = $_POST['phone'];
if ($phone = internalTools::parsePhone($phone))
{
if ($db->createContact($nom, $phone))
{
$db->createEvent('CONTACT_ADD', 'Ajout contact : ' . $nom . ' (' . internalTools::phoneAddSpace($phone) . ')');
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'successmessage' => 'Le contact a bien été créé.'
)));
return true;
}
header('Location: ' . $this->generateUrl('contacts', 'add', array(
'errormessage' => 'Impossible créer ce contact.'
)));
return true;
}
header('Location: ' . $this->generateUrl('contacts', 'add', array(
'errormessage' => 'Numéro de téléphone incorrect.'
)));
}
/**
* Cette fonction met à jour une liste de contacts
*/
public function update()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
}
global $db;
$errors = array(); //On initialise le tableau qui contiendra les erreurs rencontrés
//Pour chaque contact reçu, on boucle en récupérant son id (la clef), et le contact lui-même (la value)
foreach ($_POST['contacts'] as $id => $contact)
{
if ($number = internalTools::parsePhone($contact['phone']))
{
$db->updateContact($id, $contact['name'], $number);
}
else
{
$errors[] = $contact['id'];
}
}
//Si on a eu des erreurs
if (count($errors))
{
$message = 'Certains contacts n\'ont pas pu êtres mis à jour. Voici leurs identifiants : ' . implode(', ', $errors);
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'errormessage' => $message,
)));
}
else
{
$message = 'Tous les contacts ont été modifiés avec succès.';
header('Location: ' . $this->generateUrl('contacts', 'showAll', array(
'successmessage' => $message,
)));
}
}
/**
* Cette fonction retourne la liste des contacts sous forme JSON
*/
public function jsonGetContacts()
{
global $db;
echo json_encode($db->getAll('contacts'));
}
}

117
controllers/dashboard.php Executable file
View file

@ -0,0 +1,117 @@
<?php
/**
* Page d'index, qui gère l'affichage par défaut temporairement
*/
class dashboard extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction retourne l'index temporaire du site
* @return void;
*/
public function byDefault()
{
$this->show();
}
public function show()
{
//Creation de l'object de base de données
global $db;
//Recupération des nombres des 4 panneaux d'accueil
$nb_contacts = $db->countContacts();
$nb_groups = $db->countGroups();
$nb_scheduleds = $db->countScheduleds();
$nb_commands = $db->countCommands();
//Création de la date d'il y a une semaine
$now = new DateTime();
$one_week = new DateInterval('P7D');
$date = $now->sub($one_week);
$formated_date = $date->format('Y-m-d');
//Récupération des 10 derniers SMS envoyés, SMS reçus et evenements enregistrés. Par date.
$sendeds = $db->getAll('sendeds', 'at', true, 10);
$receiveds = $db->getAll('receiveds', 'at', true, 10);
$events = $db->getAll('events', 'at', true, 10);
//Récupération du nombre de SMS envoyés et reçus depuis les 7 derniers jours
$nb_sendeds = $db->getNbSendedsSinceGroupDay($formated_date);
$nb_receiveds = $db->getNbReceivedsSinceGroupDay($formated_date);
//On va traduire ces données pour les afficher en graphique
$array_area_chart = array();
$now = new DateTime();
$now->sub(new DateInterval('P7D'));
$increment_day = new DateInterval('P1D');
$i = 0;
//On va construire un tableau avec la date en clef, et les données pour chaque date
while ($i < 7)
{
$now->add($increment_day);
$i ++;
$date_f = $now->format('Y-m-d');
$array_area_chart[$date_f] = array(
'period' => $date_f,
'sendeds' => 0,
'receiveds' => 0,
);
}
$total_sendeds = 0;
$total_receiveds = 0;
//0n remplie le tableau avec les données adaptées
foreach ($nb_sendeds as $nb_sended)
{
if (array_key_exists($nb_sended['at_ymd'], $array_area_chart))
{
$array_area_chart[$nb_sended['at_ymd']]['sendeds'] = $nb_sended['nb'];
$total_sendeds += $nb_sended['nb'];
}
}
foreach ($nb_receiveds as $nb_received)
{
if (array_key_exists($nb_received['at_ymd'], $array_area_chart))
{
$array_area_chart[$nb_received['at_ymd']]['receiveds'] = $nb_received['nb'];
$total_receiveds += $nb_received['nb'];
}
}
$avg_sendeds = round($total_sendeds / 7, 2);
$avg_receiveds = round($total_receiveds / 7, 2);
$array_area_chart = array_values($array_area_chart);
$this->render('dashboard', array(
'nb_contacts' => $nb_contacts,
'nb_groups' => $nb_groups,
'nb_scheduleds' => $nb_scheduleds,
'nb_commands' => $nb_commands,
'nb_sendeds' => $nb_sendeds,
'nb_receiveds' => $nb_receiveds,
'avg_sendeds' => $avg_sendeds,
'avg_receiveds' => $avg_receiveds,
'sendeds' => $sendeds,
'receiveds' => $receiveds,
'events' => $events,
'datas_area_chart' => json_encode($array_area_chart),
));
}
}

50
controllers/events.php Executable file
View file

@ -0,0 +1,50 @@
<?php
/**
* Page des events
*/
class events extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les événements, sous forme d'un tableau permettant l'administration de ces événements
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
$page = (int)(isset($_GET['page']) ? $_GET['page'] : 0);
$limit = 25;
$offset = $limit * $page;
//Récupération des évènements triés par date, du plus récent au plus ancien, par paquets de $limit, en ignorant les $offset premiers
$events = $db->getAll('events', 'at', true, $limit, $offset);
$this->render('events', array(
'events' => $events,
'page' => $page,
'limit' => $limit,
'nbResults' => count($events),
));
}
}

176
controllers/groups.php Executable file
View file

@ -0,0 +1,176 @@
<?php
/**
* Page des groups
*/
class groups extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les groupes, sous forme d'un tableau permettant l'administration de ces groupes
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
$groups = $db->getGroupsWithContactsNb();
$this->render('groups', array(
'groups' => $groups,
));
}
/**
* Cette fonction supprime une liste de groupes
* @return void;
*/
public function delete()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Create de l'object de base de données
global $db;
$groups_ids = $_GET;
$db->deleteGroupsIn($groups_ids);
header('Location: ' . $this->generateUrl('groups'));
}
/**
* Cette fonction retourne la page d'ajout d'un group
*/
public function add()
{
$this->render('addGroup');
}
/**
* Cette fonction retourne la page d'édition des groupes
*/
public function edit()
{
global $db;
$groups = $db->getGroupsIn($_GET);
$blocks = array(); //On défini la variable qui correspondra à un bloc groupe et contacts
//Pour chaque groupe, on récupère les contacts liés
foreach ($groups as $key => $group)
{
$groups[$key]['contacts'] = $db->getContactsForGroup($group['id']);
}
$this->render('editGroups', array(
'groups' => $groups,
));
}
/**
* Cette fonction insert un nouveau contact
*/
public function create()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
$nom = $_POST['name'];
if ($db->createGroup($nom))
{
$id_group = $db->lastId();
$db->createEvent('GROUP_ADD', 'Ajout du groupe : ' . $nom);
foreach ($_POST['contacts'] as $id_contact)
{
$db->createGroups_contacts($id_group, $id_contact);
}
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'successmessage' => 'Le groupe a bien été créé.'
)));
return true;
}
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'errormessage' => 'Impossible de créer ce groupe.'
)));
}
/**
* Cette fonction met à jour une liste de groupes
*/
public function update()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
//Pour chaque groupe reçu, on boucle en récupérant son id (la clef), et le contact le tableau du groupe (nom et liste des contacts)
foreach ($_POST['groups'] as $id_group => $group)
{
$db->updateGroup($id_group, $group['name']); //On met à jour le nom du groupe
$db->deleteGroups_contactsForGroup($id_group); //On supprime tous les contacts de ce groupe
foreach ($group['contacts'] as $id_contact) //Pour chaque contact on l'ajoute au groupe
{
$db->createGroups_contacts($id_group, $id_contact);
}
}
$message = 'Tous les groupes ont été modifiés avec succès.';
header('Location: ' . $this->generateUrl('groups', 'showAll', array(
'successmessage' => $message,
)));
}
/**
* Cette fonction retourne la liste des groupes sous forme JSON
*/
public function jsonGetGroups()
{
global $db;
echo json_encode($db->getAll('groups'));
}
}

266
controllers/internalConsole.php Executable file
View file

@ -0,0 +1,266 @@
<?php
class internalConsole extends Controller
{
/**
* Cette fonction retourne l'aide de la console
*/
public function help()
{
//On défini les commandes dispo
$commands = array(
'sendScheduleds' => 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(),
),
);
$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'arguments\n";
}
else
{
foreach ($requireds as $argument => $desc)
{
$message .= ' - ' . $argument . ' : ' . $desc . "\n";
}
}
$message .= " Arguments optionels : \n";
if (!count($optionals))
{
$message .= " Pas d'arguments\n";
}
else
{
foreach ($optionals as $argument => $desc)
{
$message .= ' - ' . $argument . ' : ' . $desc . "\n";
}
}
}
echo $message;
}
/**
* Cette fonction envoie tous les SMS programmés qui doivent l'êtres
*/
public function sendScheduleds()
{
//On créer l'objet de base de données
global $db;
$now = new DateTime();
$now = $now->format('Y-m-d H:i:s');
echo "Début de l'envoie des SMS programmés\n";
$scheduleds = $db->getScheduledsNotInProgressBefore($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é à la liste des SMS en cours d'envoie.\n";
$db->updateProgressScheduledsIn($ids_scheduleds, true);
//Pour chaque SMS à envoyer
foreach ($scheduleds as $scheduled)
{
$id_scheduled = $scheduled['id'];
$text_sms = escapeshellarg($scheduled['content']);
//On initialise les numéros auxquelles envoyer le SMS
$numbers = array();
//On récupère les numéros pour le SMS et on les ajoutes
$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->getContactsForScheduled($id_scheduled);
foreach ($contacts as $contact)
{
$numbers[] = $contact['number'];
}
//On récupère les groupes
$groups = $db->getGroupsForScheduled($id_scheduled);
foreach ($groups as $group)
{
//On récupère les contacts du groupe et on les ajoutes aux numéros
$contacts = $db->getContactsForGroup($group['id']);
foreach ($contacts as $contact)
{
$numbers[] = $contact['number'];
}
}
foreach ($numbers as $number)
{
echo " Envoie d'un SMS au " . $number . "\n";
//On ajoute le SMS aux SMS envoyés
$db->createSended($now, $number, $scheduled['content']);
$id_sended = $db->lastId();
//Commande qui envoie le SMS
$commande_send_sms = 'gammu-smsd-inject TEXT ' . escapeshellarg($number) . ' -len ' . mb_strlen($text_sms) . ' -text ' . $text_sms;
//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'envoie.\n";
//Tous les SMS ont été envoyés.
$db->deleteScheduledsIn($ids_scheduleds);
}
/**
* 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;
foreach (scandir(PWD_RECEIVEDS) as $dir)
{
//Si le fichier est un fichier système, on passe à l'itération suivante
if ($dir == '.' || $dir == '..')
{
continue;
}
//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)
{
$this->wlog('Impossible to read file "' . $dir);
die(4);
}
//On delete le fichier. Si on y arrive pas on log
if (!unlink(PWD_RECEIVEDS . $dir))
{
$this->wlog('Impossible to delete file "' . $dir);
die(8);
}
$content_file = explode(':', $content_file, 2);
//Si on a pas passé de SMS ou de numéro on leve une erreure
if (!isset($content_file[0], $content_file[1]))
{
$this->wlog('Missing params in file "' . $dir);
die(5);
}
$number = $content_file[0];
$number = internalTools::parsePhone($number);
$text = $content_file[1];
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 = internalTools::parseForFlag($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 faire toutes les commandes, pour voir si on en trouve dans ce message
$commands = $db->getAll('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 demande 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 dangers
$text = str_replace($flags['PASSWORD'], '*****', $text);
//On map les données et on créer le SMS reçu
$now = new DateTime();
$date = $now->format('Y-m-d H:i');
$send_by = $number;
$content = $text;
$is_command = count($found_commands);
if (!$db->createReceived($date, $send_by, $content, $is_command))
{
echo "Erreur lors de l'enregistrement du SMS\n";
$this->wlog('Impossible to register the SMS in file "' . $dir);
die(7);
}
//Pour chaque commande, on execute la commande.
foreach ($found_commands as $command_name => $command)
{
echo 'Execution de la commande : ' . $command_name . ' :: ' . $command . "\n";
exec($command);
}
}
}
}

43
controllers/internalIncs.php Executable file
View file

@ -0,0 +1,43 @@
<?php
class internalIncs extends Controller
{
/**
* Cette fonction retourne le template du head html
* @param string $title : Optionnel. Il s'agit du titre à utiliser. Si non fourni, on utilisera simplement 'RaspiSMS'
* @return void
*/
public function head($title = '')
{
$title = (!empty($title)) ? $title . ' - RaspiSMS' : 'RaspiSMS';
$author = 'Ajani';
$error_message = (isset($_GET['errormessage'])) ? $_GET['errormessage'] : '';
$success_message = (isset($_GET['successmessage'])) ? $_GET['successmessage'] : '';
$this->render('head', array(
'title' => $title,
'author' => $author,
'error_message' => $error_message,
'success_message' => $success_message,
));
}
/**
* Cette fonction retourne le template du menu
* @param string $page : Optionnel. Le nom de la page courante. Utilisé pour mettre en surbrillance la partie adaptée du menu
* @return void
*/
public function nav($page = '')
{
$email = isset($_SESSION['email']) ? $_SESSION['email'] : 'Mon compte';
$this->render('nav', array(
'email' => $email,
'page' => $page,
));
}
public function footer()
{
$this->render('footer');
}
}

145
controllers/internalTools.php Executable file
View file

@ -0,0 +1,145 @@
<?php
class internalTools extends Controller
{
/**
* 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 parsePhone($number)
{
$number = preg_replace('#[^0-9+]#', '', $number);
if (preg_match('#^(0|\+33)[1-9][0-9]{8}$#', $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 phoneAddSpace($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 eventTypeToIcon($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 validateDate($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 parseForFlag($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 generatePassword($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 verifyConnect()
{
if (!isset($_SESSION['connect']) || !$_SESSION['connect'])
{
$controller = new Controller();
header('Location: ' . $controller->generateUrl('connect'));
die();
}
}
/**
* Cette fonction vérifie si un argument csrf a été fourni et est valide
* @param string $csrf : argument optionel, qui est la chaine csrf à vérifier. Si non fournie, la fonction cherchera à utiliser $_GET['csrf'] ou $_POST['csrf'].
* @return boolean : True si le csrf est valide. False sinon.
*/
public static function verifyCSRF($csrf = '')
{
if (!$csrf)
{
$csrf = isset($_GET['csrf']) ? $_GET['csrf'] : $csrf;
$csrf = isset($_POST['csrf']) ? $_POST['csrf'] : $csrf;
}
if ($csrf == $_SESSION['csrf'])
{
return true;
}
return false;
}
}

182
controllers/profile.php Executable file
View file

@ -0,0 +1,182 @@
<?php
/**
* Page de profile
*/
class profile extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de show()
*/
public function byDefault()
{
$this->show();
}
/**
* Cette fonction retourne la fenetre du profile
* @return void;
*/
public function show()
{
//Creation de l'object de base de données
global $db;
$this->render('profile');
}
/**
* Cette fonction change le mot de passe de l'utilisateur
* @param string $_POST['password'] : Le nouveau mot de passe de l'utilisateur
* @param string $_POST['verif_password'] : La vérification du nouveau mot de passe de l'utilisateur
* @return void;
*/
public function changePassword()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('profile', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Creation de l'object de base de données
global $db;
if (empty($_POST['password']) || empty($_POST['verif_password']) || $_POST['password'] != $_POST['verif_password'])
{
header('Location: ' . $this->generateUrl('profile', 'show', array(
'errormessage' => 'Les mots de passe ne correspondent pas.'
)));
return false;
}
$user = $db->getUserFromEmail($_SESSION['email']);
$password = sha1($_POST['password']);
if ($db->updateUser($user['id'], $user['email'], $password, $user['admin']))
{
header('Location: ' . $this->generateUrl('profile', 'show', array(
'successmessage' => 'Les données ont été mises à jour.'
)));
return false;
}
}
/**
* Cette fonction change l'email de l'utilisateur
* @param string $_POST['email'] : Le nouvel email de l'utilisateur
* @param string $_POST['verif_email'] : La vérification du nouvel email de l'utilisateur
* @return void;
*/
public function changeEmail()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('profile', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Creation de l'object de base de données
global $db;
if (empty($_POST['mail']) || empty($_POST['verif_mail']) || $_POST['mail'] != $_POST['verif_mail'])
{
header('Location: ' . $this->generateUrl('profile', 'show', array(
'errormessage' => 'Les e-mails ne correspondent pas.'
)));
return false;
}
$email = $_POST['mail'];
if (!filter_var($email, FILTER_VALIDATE_EMAIL))
{
header('Location: ' . $this->generateUrl('profile', 'show', array(
'errormessage' => 'L\'adresse e-mail est invalide.'
)));
return false;
}
$user = $db->getUserFromEmail($_SESSION['email']);
if ($db->updateUser($user['id'], $email, $user['password'], $user['admin']))
{
$_SESSION['email'] = $email;
header('Location: ' . $this->generateUrl('profile', 'show', array(
'successmessage' => 'Les données ont été mises à jour.'
)));
return false;
}
header('Location: ' . $this->generateUrl('profile', 'show', array(
'errormessage' => 'Cette adresse e-mail est déjà utilisée.'
)));
return false;
}
/**
* Cette fonction supprime l'utilisateur
* @param string $_POST['delete_account'] : La vérification que l'on veux bien supprimer l'utilisateur
* @return void;
*/
public function delete()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('profile', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Creation de l'object de base de données
global $db;
//Si l'utilisateur veux vraiment supprimer son compte
if (!empty($_POST['delete_account']))
{
$user = $db->getUserFromEmail($_SESSION['email']); //On récupère l'utilisateur en base
$db->deleteUsersIn(array($user['id'])); //On supprime l'utilisateur
$this->logout();
return true;
}
header('Location: ' . $this->generateUrl('profile', 'show', array(
'errormessage' => 'Le compte n\'a pas été supprimé'
)));
return false;
}
/**
* Cette fonction déconnecte un utilisateur et le renvoie sur la page d'accueil
* @return void
*/
public function logout()
{
session_unset();
session_destroy();
header('Location: ' . $this->generateUrl(''));
return true;
}
}

50
controllers/receiveds.php Executable file
View file

@ -0,0 +1,50 @@
<?php
/**
* Page des SMS reçus
*/
class receiveds extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les SMS envoyés, sous forme d'un tableau
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
$page = (int)(isset($_GET['page']) ? $_GET['page'] : 0);
$limit = 25;
$offset = $limit * $page;
//Récupération des SMS envoyés triés par date, du plus récent au plus ancien, par paquets de $limit, en ignorant les $offset premiers
$receiveds = $db->getAll('receiveds', 'at', true, $limit, $offset);
$this->render('receiveds', array(
'receiveds' => $receiveds,
'page' => $page,
'limit' => $limit,
'nbResults' => count($receiveds),
));
}
}

315
controllers/scheduleds.php Executable file
View file

@ -0,0 +1,315 @@
<?php
/**
* Page des sms programmés
*/
class scheduleds extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les sms programmés, sous forme d'un tableau permettant l'administration de ces sms
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
$scheduleds = $db->getAll('scheduleds');
$this->render('scheduleds', array(
'scheduleds' => $scheduleds,
));
}
/**
* Cette fonction supprime une liste de groupes
* @return void;
*/
public function delete()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Create de l'object de base de données
global $db;
$scheduleds_ids = $_GET;
$db->deleteScheduledsIn($scheduleds_ids);
header('Location: ' . $this->generateUrl('scheduleds'));
}
/**
* Cette fonction retourne la page d'ajout d'un group
*/
public function add()
{
$now = new DateTime();
$babyonemoretime = new DateInterval('PT1M'); //Haha, i'm so a funny guy
$now->add($babyonemoretime);
$now = $now->format('Y-m-d H:i');
$this->render('addScheduled', array(
'now' => $now
));
}
/**
* Cette fonction retourne la page d'édition des sms programmés
*/
public function edit()
{
global $db;
$scheduleds = $db->getScheduledsIn($_GET);
//Pour chaque groupe, on récupère les contacts liés
foreach ($scheduleds as $key => $scheduled)
{
$date = new DateTime($scheduled['at']);
$scheduleds[$key]['at'] = $date->format('Y-m-d H:i');
$scheduleds[$key]['numbers'] = $db->getNumbersForScheduled($scheduled['id']);
$scheduleds[$key]['contacts'] = $db->getContactsForScheduled($scheduled['id']);
$scheduleds[$key]['groups'] = $db->getGroupsForScheduled($scheduled['id']);
}
$this->render('editScheduleds', array(
'scheduleds' => $scheduleds,
));
}
/**
* Cette fonction insert un nouveau SMS programmé
* @param optionnal boolean $api : Si vrai (faux par défaut), on retourne des réponses au lieu de rediriger
*/
public function create($api = false)
{
if (!$api)
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
}
global $db;
$date = $_POST['date'];
$content = $_POST['content'];
$numbers = (isset($_POST['numbers'])) ? $_POST['numbers'] : array();
$contacts = (isset($_POST['contacts'])) ? $_POST['contacts'] : array();
$groups = (isset($_POST['groups'])) ? $_POST['groups'] : array();
//Si pas de contenu dans le SMS
if (!$content)
{
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Pas de texte pour ce SMS !'
)));
}
return false;
}
//Si pas numéros, contacts, ou groupes cibles
if (!$numbers && !$contacts && !$groups)
{
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Pas numéro, de contacts, ni de groupes définis pour envoyer ce SMS !'
)));
}
return false;
}
if (!internalTools::validateDate($date, 'Y-m-d H:i'))
{
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'add', array(
'errormessage' => 'La date renseignée est invalide.'
)));
}
return false;
}
if ($db->createScheduleds($date, $content))
{
$id_scheduled = $db->lastId();
$db->createEvent('SCHEDULED_ADD', 'Ajout d\'un SMS pour le ' . $date);
$errors = false;
foreach ($numbers as $number)
{
if ($number = internalTools::parsePhone($number))
{
$db->createScheduleds_numbers($id_scheduled, $number);
}
else
{
$errors = true;
}
}
foreach ($contacts as $id_contact)
{
if (!$db->createScheduleds_contacts($id_scheduled, $id_contact))
{
$errors = true;
}
}
foreach ($groups as $id_group)
{
if (!$db->createScheduleds_groups($id_scheduled, $id_group))
{
$errors = true;
}
}
if ($errors)
{
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Le SMS a bien été créé, mais certains numéro ne sont pas valides.'
)));
}
return true;
}
else
{
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'successmessage' => 'Le SMS a bien été créé.'
)));
}
return true;
}
}
if (!$api)
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Impossible de créer ce SMS.'
)));
}
return false;
}
/**
* Cette fonction met à jour une liste de sms
*/
public function update()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
$errors = false;
//Pour chaque SMS programmé reçu, on boucle en récupérant son id (la clef), et sont contenu
foreach ($_POST['scheduleds'] as $id_scheduled => $scheduled)
{
$date = $scheduled['date'];
if (!internalTools::validateDate($date, 'Y-m-d H:i'))
{
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => 'La date renseignée pour le SMS numéro ' . $scheduled['id'] . ' est invalide.'
)));
return true;
}
//Si la date fournie est passée, on la change pour dans 2 minutes
$objectDate = DateTime::createFromFormat('Y-m-d H:i', $date);
$db->updateScheduled($id_scheduled, $date, $scheduled['content'], false); //On met à jour le sms
$db->deleteScheduleds_numbersForScheduled($id_scheduled); //On supprime tous les numéros pour ce SMS
$db->deleteScheduleds_contactsForScheduled($id_scheduled); //On supprime tous les contacts pour ce SMS
$db->deleteScheduleds_GroupsForScheduled($id_scheduled); //On supprime tous les groupes pour ce SMS
//Pour chaque numéro, on va le vérifier et l'ajouter au sms
foreach ($scheduled['numbers'] as $number)
{
if (internalTools::parsePhone($number))
{
$db->createScheduleds_numbers($id_scheduled, $number);
}
else
{
$errors = true;
}
}
//Pour chaque contact, on va l'ajouter au sms
foreach ($scheduled['contacts'] as $id_contact)
{
if (!$db->createScheduleds_contacts($id_scheduled, $id_contact))
{
$errors = true;
}
}
//Pour chaque groupe, on va l'ajouter au sms
foreach ($scheduled['groups'] as $id_group)
{
if (!$db->createScheduleds_groups($id_scheduled, $id_group))
{
$errors = true;
}
}
}
if (!$errors)
{
$message = 'Tous les SMS ont été modifiés avec succès.';
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'successmessage' => $message,
)));
}
else
{
$message = 'Tous les SMS ont été modifiés mais certaines données incorrects ont été ignorées.';
header('Location: ' . $this->generateUrl('scheduleds', 'showAll', array(
'errormessage' => $message,
)));
}
}
}

50
controllers/sendeds.php Executable file
View file

@ -0,0 +1,50 @@
<?php
/**
* Page des SMS envoyés
*/
class sendeds extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les SMS envoyés, sous forme d'un tableau
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
$page = (int)(isset($_GET['page']) ? $_GET['page'] : 0);
$limit = 25;
$offset = $limit * $page;
//Récupération des SMS envoyés triés par date, du plus récent au plus ancien, par paquets de $limit, en ignorant les $offset premiers
$sendeds = $db->getAll('sendeds', 'at', true, $limit, $offset);
$this->render('sendeds', array(
'sendeds' => $sendeds,
'page' => $page,
'limit' => $limit,
'nbResults' => count($sendeds),
));
}
}

147
controllers/smsAPI.php Executable file
View file

@ -0,0 +1,147 @@
<?php
/**
* Page de l'API pour créer un SMS
*/
class smsAPI extends Controller
{
//On défini les constantes qui servent pour les retours d'API
const API_ERROR_NO = 0;
const API_ERROR_BAD_ID = 1;
const API_ERROR_CREATION_FAILED = 2;
const API_ERROR_MISSING_FIELD = 3;
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->send();
}
/**
* Cette fonction permet d'envoyer un SMS, en passant simplement des arguments à l'URL (ou pas $_GET)
* @param string text = Le contenu du SMS
* @param mixed numbers = Les numéros auxquels envoyer les SMS. Soit un seul numéro, et il s'agit d'un string. Soit plusieurs numéros, et il s'agit d'un tableau
* @param mixed contacts = Les noms des contacts auxquels envoyer les SMS. Soit un seul et il s'agit d'un string. Soit plusieurs, et il s'agit d'un tableau
* @param mixed groups = Les noms des groupes auxquels envoyer les SMS. Soit un seul et il s'agit d'un string. Soit plusieurs, et il s'agit d'un tableau
* @param optionnal string date = La date à laquelle doit être envoyé le SMS. Au format 'Y-m-d H:i'. Si non fourni, le SMS sera envoyé dans 2 minutes
*/
public function send()
{
global $db;
//On récupère l'email et le password
$email = isset($_GET['email']) ? $_GET['email'] : NULL;
$email = isset($_POST['email']) ? $_POST['email'] : $email;
$password = isset($_GET['password']) ? $_GET['password'] : NULL;
$password = isset($_POST['password']) ? $_POST['password'] : $password;
//Si les identifiants sont incorrect on retourne une erreur
$user = $db->getUserFromEmail($email);
if (!$user || sha1($password) != $user['password'])
{
echo json_encode(array(
'error' => self::API_ERROR_BAD_ID,
));
return true;
}
//On map les variables $_GET
$get_numbers = isset($_GET['numbers']) ? $_GET['numbers'] : array();
$get_contacts = isset($_GET['contacts']) ? $_GET['contacts'] : array();
$get_groups = isset($_GET['groups']) ? $_GET['groups'] : array();
//On map les variables POST
$post_numbers = isset($_POST['numbers']) ? $_POST['numbers'] : array();
$post_contacts = isset($_POST['contacts']) ? $_POST['contacts'] : array();
$post_groups = isset($_POST['groups']) ? $_POST['groups'] : array();
//On map le texte et la date à part car c'est les seuls arguments qui ne sera jamais un tableau
$text = isset($_GET['text']) ? $_GET['text'] : NULL;
$text = isset($_POST['text']) ? $_POST['text'] : $text;
$date = isset($_GET['date']) ? $_GET['date'] : NULL;
$date = isset($_POST['date']) ? $_POST['date'] : $date;
//On passe tous les paramètres GET en tableau
$get_numbers = is_array($get_numbers) ? $get_numbers : ($get_numbers ? array($get_numbers) : array());
$get_contacts = is_array($get_contacts) ? $get_contacts : array($get_contacts);
$get_groups = is_array($get_groups) ? $get_groups : array($get_groups);
//On passe tous les paramètres POST en tableau
$post_numbers = is_array($post_numbers) ? $post_numbers : array($post_numbers);
$post_contacts = is_array($post_contacts) ? $post_contacts : array($post_contacts);
$post_groups = is_array($post_groups) ? $post_groups : array($post_groups);
//On merge les données reçus en GET, et celles en POST
$numbers = array_merge($get_numbers, $post_numbers);
$contacts = array_merge($get_contacts, $post_contacts);
$groups = array_merge($get_groups, $post_groups);
//Pour chaque contact, on récupère l'id du contact
foreach ($contacts as $key => $name)
{
if ($contact = $db->getContactFromName($name))
{
$contacts[$key] = $contact['id'];
}
else
{
unset($contacts[$key]);
}
}
//Pour chaque groupe, on récupère l'id du groupe
foreach ($groups as $key => $name)
{
if ($group = $db->getGroupFromName($name))
{
$groups[$key] = $group['id'];
}
else
{
unset($groups[$key]);
}
}
//Si la date n'est pas définie, on la met à la date du jour
if (!$date)
{
$now = new DateTime();
$date = $now->format('Y-m-d H:i');
}
//Si il manque des champs essentiels, on leve une erreur
if (!$text || (!$numbers && !$contacts && !$groups))
{
echo json_encode(array(
'error' => self::API_ERROR_MISSING_FIELD,
));
return true;
}
//On assigne les variable POST (après avoir vidé $_POST) en prévision de la création du SMS
$_POST = array();
$_POST['content'] = $text;
$_POST['date'] = $date;
$_POST['numbers'] = $numbers;
$_POST['contacts'] = $contacts;
$_POST['groups'] = $groups;
$scheduleds = new scheduleds();
$success = $scheduleds->create(true);
if ($success)
{
echo json_encode(array(
'error' => self::API_ERROR_NO,
));
}
else
{
echo json_encode(array(
'error' => self::API_ERROR_CREATION_FAILED,
));
}
}
}

160
controllers/users.php Executable file
View file

@ -0,0 +1,160 @@
<?php
/**
* Page des utilisateurs
*/
class users extends Controller
{
/**
* Cette fonction est appelée avant toute les autres :
* Elle vérifie que l'utilisateur est bien connecté
* @return void;
*/
public function before()
{
internalTools::verifyConnect();
}
/**
* Cette fonction est alias de showAll()
*/
public function byDefault()
{
$this->showAll();
}
/**
* Cette fonction retourne tous les utilisateurs, sous forme d'un tableau permettant l'administration de ces utilisateurs
* @return void;
*/
public function showAll()
{
//Creation de l'object de base de données
global $db;
//Récupération des utilisateurs
$users = $db->getAll('users');
$this->render('users', array(
'users' => $users,
));
}
/**
* Cette fonction retourne la page d'ajout d'un utilisateur
*/
public function add()
{
$this->render('addUser');
}
/**
* Cette fonction insert un nouvel utilisateur
*/
public function create()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('users', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
global $db;
if (!isset($_POST['email']) || !isset($_POST['email_confirm']) || $_POST['email'] != $_POST['email_confirm'])
{
header('Location: ' . $this->generateUrl('users', 'add', array(
'errormessage' => 'Les e-mails fournis ne correspondent pas.'
)));
return false;
}
$email = $_POST['email'];
$no_crypt_password = internalTools::generatePassword(rand(8,12));
$password = sha1($no_crypt_password);
if (!filter_var($email, FILTER_VALIDATE_EMAIL))
{
header('Location: ' . $this->generateUrl('users', 'add', array(
'errormessage' => 'L\'e-mail fourni présente un format incorrect.'
)));
return false;
}
$admin = false;
if (isset($_SESSION['admin']) && $_SESSION['admin'])
{
if (isset($_POST['admin']) && $_POST['admin'])
{
$admin = true;
}
}
$message = "Votre compte a été créé sur le site " . HTTP_PWD . " avec les identifiants suivants : \n";
$message .= "Adresse e-mail : " . $email . "\n";
$message .= "Mot de passe : " . $no_crypt_password . "\n\n";
$message .= "-------------------------------------\n";
$message .= "Pour plus d'informations sur le système RaspiSMS, rendez-vous sur le site http://raspbian-france.fr\n";
if (mail($email, 'Identifiants RaspiSMS', $message))
{
if ($db->createUser($email, $password, $admin))
{
$db->createEvent('USER_ADD', 'Ajout de l\'utilisateur : ' . $email);
header('Location: ' . $this->generateUrl('users', 'showAll', array(
'successmessage' => 'L\'utilisateur a bien été créé.'
)));
return true;
}
header('Location: ' . $this->generateUrl('users', 'add', array(
'errormessage' => 'Impossible de créer cet utilisateur.'
)));
return false;
}
else
{
header('Location: ' . $this->generateUrl('users', 'showAll', array(
'errormessage' => 'Impossible d\'envoyer le SMS d\'inscription à l\'utilisateur. Le compte n\'a donc pas été créé.'
)));
return false;
}
}
/**
* Cette fonction supprimer une liste d'utilisateur
* @return void;
*/
public function delete()
{
//On vérifie que le jeton csrf est bon
if (!internalTools::verifyCSRF())
{
header('Location: ' . $this->generateUrl('users', 'showAll', array(
'errormessage' => 'Jeton CSRF invalide !'
)));
return true;
}
//Create de l'object de base de données
global $db;
//Si on est pas admin
if (!$_SESSION['admin'])
{
header('Location: ' . $this->generateUrl('users', 'showAll', array(
'errormessage' => 'Vous devez être administrateur pour effectuer cette action.'
)));
return false;
}
$users_ids = $_GET;
$db->deleteUsersIn($users_ids);
header('Location: ' . $this->generateUrl('users'));
}
}