Subversion Repositories Applications.annuaire

Compare Revisions

No changes between revisions

Ignore whitespace Rev 435 → Rev 436

/tags/v1.2-autel/jrest/.htaccess
New file
0,0 → 1,4
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-d
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule ^.*$ index.php/
/tags/v1.2-autel/jrest/bibliotheque/JRestService.php
New file
0,0 → 1,367
<?php
/**
* Classe mère abstraite contenant les méthodes génériques des services.
* Encodage en entrée : utf8
* Encodage en sortie : utf8
*
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2009
*/
abstract class JRestService {
 
public $config;
protected $bdd;
protected $ressources;
protected $log = array();
protected $messages = array();
protected $debug = array();
protected $distinct = false;
protected $orderby = null;
protected $formatRetour = 'objet';
protected $start = 0;
protected $limit = 150;
 
public function __construct($config, $demarrer_session = true) {
// Tableau contenant la config de Jrest
$this->config = $config;
 
// Connection à la base de données
$this->bdd = $this->connecterPDO($this->config, 'appli');
 
// Nettoyage du $_GET (sécurité)
if (isset($_GET)) {
$get_params = array('orderby', 'distinct', 'start', 'limit', 'formatRetour');
foreach ($get_params as $get) {
$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
$_GET[$get] = str_replace($verifier, '', $_GET[$get]);
if (isset($_GET[$get]) && $_GET[$get] != '') {
$this->$get = $_GET[$get];
} else {
$_GET[$get] = null;
}
}
}
}
 
/**
* Méthode appelée quand aucun paramètre n'est passé dans l'url et avec une requête de type GET.
*/
public function getRessource() {
$this->getElement(array());
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de l'ENVOIE au NAVIGATEUR
 
protected function envoyerJson($donnees, $encodage = 'utf-8') {
$contenu = json_encode($donnees);
$this->envoyer($contenu, 'application/json', $encodage, false);
}
 
protected function envoyerJsonVar($variable, $donnees = null, $encodage = 'utf-8') {
$contenu = "var $variable = ".json_encode($donnees);
$this->envoyer($contenu, 'text/html', $encodage, false);
}
 
protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') {
$contenu = $_GET['callback'].'('.json_encode($donnees).');';
$this->envoyer($contenu, 'text/html', $encodage, false);
}
 
protected function envoyerTxt($donnees, $encodage = 'utf-8') {
$this->envoyer($contenu, 'text/html', $encodage, false);
}
 
protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8', $json = true) {
// Traitements des messages d'erreurs et données
if (count($this->messages) != 0) {
header('HTTP/1.1 500 Internal Server Error');
$mime = 'text/html';
$encodage = 'utf-8';
$json = true;
$sortie = $this->messages;
} else {
$sortie = $donnees;
if (is_null($donnees)) {
$sortie = 'OK';
}
}
 
// Gestion de l'envoie du déboguage
$this->envoyerDebogage();
 
// Encodage au format et JSON et envoie sur la sortie standard
$contenu = $json ? json_encode($sortie) : $sortie;
$this->envoyerContenu($encodage, $mime, $contenu);
}
 
private function envoyerDebogage() {
if (!is_array($this->debug)) {
$this->debug[] = $this->debug;
}
if (count($this->debug) != 0) {
foreach ($this->debug as $cle => $val) {
if (is_array($val)) {
$this->debug[$cle] = print_r($val, true);
}
}
header('X-DebugJrest-Data:'.json_encode($this->debug));
}
}
 
private function envoyerContenu($encodage, $mime, $contenu) {
if (!is_null($mime) && !is_null($encodage)) {
header("Content-Type: $mime; charset=$encodage");
} else if (!is_null($mime) && is_null($encodage)) {
header("Content-Type: $mime");
}
print $contenu;
}
 
private function envoyerAuth($message_accueil, $message_echec) {
header('HTTP/1.0 401 Unauthorized');
header('WWW-Authenticate: Basic realm="'.mb_convert_encoding($message_accueil, 'ISO-8859-1', 'UTF-8').'"');
header('Content-type: text/plain; charset=UTF-8');
print $message_echec;
exit(0);
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION de la BASE de DONNÉES
 
private function connecterPDO($config, $base = 'database') {
$cfg = $config[$base];
// ATTENTION : la connexin à la bdd peut échouer si l'host vaut localhost. Utiliser 127.0.0.1 à la place.
$dsn = $cfg['phptype'].':dbname='.$cfg['database'].';host='.$cfg['hostspec'];
try {
// Création de la connexion en UTF-8 à la BDD
$PDO = new PDO($dsn, $cfg['username'], $cfg['password'], array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES 'UTF8'"));
} catch (PDOException $e) {
echo 'La connexion à la base de donnée via PDO a échouée : ' .$dsn. $e->getMessage();
}
// Affiche les erreurs détectées par PDO (sinon mode silencieux => aucune erreur affiché)
$PDO->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
return $PDO;
}
 
protected function getTxt($id) {
$sortie = '';
switch ($id) {
case 'sql_erreur' : $sortie = 'Requête echec. Fichier : "%s". Ligne : "%s". Message : %s'; break;
default : $sortie = $id;
}
return $sortie;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// TRAITEMENT des URLs et des PARAMÊTRES
 
protected function traiterNomMethodeGet($nom) {
$methode = 'get';
$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
return $methode;
}
 
protected function traiterNomMethodePost($nom) {
$methode = 'update';
$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
return $methode;
}
 
protected function traiterNomMethodePut($nom) {
$methode = 'create';
$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom))));
return $methode;
}
 
protected function traiterParametresUrl($params_attendu, $params, $pourBDD = true) {
$sortie = array();
foreach ($params_attendu as $num => $nom) {
if (isset($params[$num]) && $params[$num] != '*') {
if ($pourBDD) {
$params[$num] = $this->bdd->quote($params[$num]);
}
$sortie[$nom] = $params[$num];
}
}
return $sortie;
}
 
protected function traiterParametresPost($params) {
$sortie = array();
foreach ($params as $cle => $valeur) {
$sortie[$cle] = $this->bdd->quote($valeur);
}
return $sortie;
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DE L'IDENTIFICATION
 
protected function getIdentification(&$params) {
// Initialisation des variables
$utilisateur = array(0, session_id());
 
// L'id utilisateur est soit passé par le POST soit dans l'url
if (is_array($params) && isset($params['cmhl_ce_modifier_par'])) {
$utilisateur[0] = $params['cmhl_ce_modifier_par'];
unset($params['cmhl_ce_modifier_par']);
} else if (is_string($params)) {
$utilisateur[0] = $params;
}
 
return $utilisateur;
}
 
protected function etreAutorise($id_utilisateur) {
$autorisation = false;
if (($_SESSION['coel_utilisateur'] != '') && $_SESSION['coel_utilisateur']['id'] != $id_utilisateur) {
$this->messages[] = 'Accès interdit.';
} else if ($_SESSION['coel_utilisateur'] == '') {
$this->messages[] = 'Veuillez vous identifiez pour accéder à cette fonction.';
} else {
$autorisation = true;
}
return $autorisation;
}
 
private function gererIdentificationPermanente() {
// Pour maintenir l'utilisateur tjrs réellement identifié nous sommes obligé de recréer une SESSION et de le recharger depuis la bdd
if ($this->getUtilisateur() == ''
&& isset($_COOKIE['coel_login'])
&& ($utilisateur = $this->chargerUtilisateur($_COOKIE['coel_login'], $_COOKIE['coel_mot_de_passe']))) {
$this->setUtilisateur($utilisateur, $_COOKIE['coel_permanence']);
}
}
 
protected function getUtilisateur() {
return (isset($_SESSION['coel_utilisateur']) ? $_SESSION['coel_utilisateur'] : '');
}
 
protected function authentifier() {
if (!isset($_SERVER['PHP_AUTH_USER'])) {
header('WWW-Authenticate: Basic realm="www.tela-botanica.org"');
header('HTTP/1.0 401 Unauthorized');
header('Content-type: text/html; charset=UTF-8');
echo 'Accès interdit';
exit;
} else {
if ($this->verifierAcces()) {
return ;
} else {
header('WWW-Authenticate: Basic realm="www.tela-botanica.org"');
header('HTTP/1.0 401 Unauthorized');
header('Content-type: text/html; charset=UTF-8');
echo 'Accès interdit';
exit ;
}
}
}
 
protected function verifierAcces($id = null, $mdp = null) {
$id = is_null($id) ? $_SERVER['PHP_AUTH_USER'] : $id;
$mdp = is_null($mdp) ? $_SERVER['PHP_AUTH_PW'] : $mdp;
 
$requete = 'SELECT '.$this->config['database_ident']['ann_id'].' AS courriel '.
'FROM '.$this->config['database_ident']['database'].'.'.$this->config['database_ident']['annuaire'].' '.
'WHERE '.$this->config['database_ident']['ann_id'].' = '.$this->bdd->quote($id).' '.
' AND '.$this->config['database_ident']['ann_pwd'].' = '.$this->config['database_ident']['pass_crypt_funct'].'('.$this->bdd->quote($mdp).')' ;
$resultat = $this->bdd->query($requete)->fetch();
 
$identifie = false;
if (isset($resultat['courriel'])) {
$identifie = true;
}
return $identifie;
}
 
protected function creerCookiePersistant($duree = null, $id = null, $mdp = null) {
$id = is_null($id) ? $_SERVER['PHP_AUTH_USER'] : $id;
$mdp = is_null($mdp) ? $_SERVER['PHP_AUTH_PW'] : $mdp;
$duree = (int) is_null($duree) ? time()+3600*24*30 : $duree;
 
$nomCookie = $this->config['database_ident']['nom_cookie_persistant'];
$valeurCookie = md5($mdp).$id;
 
setcookie($nomCookie, $valeurCookie, $duree, '/');
}
 
protected function creerCookieUtilisateur($duree = null, $id = null, $mdp = null) {
$id = is_null($id) ? $_SERVER['PHP_AUTH_USER'] : $id;
$mdp = is_null($mdp) ? $_SERVER['PHP_AUTH_PW'] : $mdp;
$duree = (int) is_null($duree) ? 0 : $duree;
 
$nomCookie = $this->config['database_ident']['nom_cookie_utilisateur'];
$valeurCookie = md5($mdp).$id;
 
setcookie($nomCookie, $valeurCookie, $duree, '/');
}
 
protected function estAutoriseMessagerie($adresse) {
$utilisateurs_messagerie = explode(',', $this->config['messagerie']['utilisateurs_autorises']);
return in_array($adresse, $utilisateurs_messagerie);
}
 
//+----------------------------------------------------------------------------------------------------------------+
// GESTION DES SQUELETTES PHP
 
/**
* Méthode prenant en paramètre un chemin de fichier squelette et un tableau associatif de données,
* en extrait les variables, charge le squelette et retourne le résultat des deux combinés.
*
* @param String $fichier le chemin du fichier du squelette
* @param Array $donnees un tableau associatif contenant les variables a injecter dans le squelette.
*
* @return boolean false si le squelette n'existe pas, sinon la chaine résultat.
*/
public static function traiterSquelettePhp($fichier, Array $donnees = array()) {
$sortie = false;
if (file_exists($fichier)) {
// Extraction des variables du tableau de données
extract($donnees);
// Démarage de la bufferisation de sortie
ob_start();
// Si les tags courts sont activés
if ((bool) @ini_get('short_open_tag') === true) {
// Simple inclusion du squelette
include $fichier;
} else {
// Sinon, remplacement des tags courts par la syntaxe classique avec echo
$html_et_code_php = self::traiterTagsCourts($fichier);
// Pour évaluer du php mélangé dans du html il est nécessaire de fermer la balise php ouverte par eval
$html_et_code_php = '?>'.$html_et_code_php;
// Interprétation du html et du php dans le buffer
echo eval($html_et_code_php);
}
// Récupèration du contenu du buffer
$sortie = ob_get_contents();
// Suppression du buffer
@ob_end_clean();
} else {
$msg = "Le fichier du squelette '$fichier' n'existe pas.";
trigger_error($msg, E_USER_WARNING);
}
// Retourne le contenu
return $sortie;
}
 
/**
* Fonction chargeant le contenu du squelette et remplaçant les tags court php (<?= ...) par un tag long avec echo.
*
* @param String $chemin_squelette le chemin du fichier du squelette
*
* @return string le contenu du fichier du squelette php avec les tags courts remplacés.
*/
private static function traiterTagsCourts($chemin_squelette) {
$contenu = file_get_contents($chemin_squelette);
// Remplacement de tags courts par un tag long avec echo
$contenu = str_replace('<?=', '<?php echo ', $contenu);
// Ajout systématique d'un point virgule avant la fermeture php
$contenu = preg_replace("/;*\s*\?>/", "; ?>", $contenu);
return $contenu;
}
}
?>
/tags/v1.2-autel/jrest/bibliotheque/GoogleAnalyticsAPI.php
New file
0,0 → 1,294
<?php
 
if(isset($_GET['source'])) {
highlight_file(__FILE__);
die;
}
 
/*
*
* This script is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General public License for more details.
*
* This copyright notice MUST APPEAR in all copies of the script!
*
* @author CERDAN Yohann <cerdanyohann@yahoo.fr>
* @copyright (c) 2009 CERDAN Yohann, All rights reserved
* @ version 12:38 04/08/2009
*/
 
class GoogleAnalyticsAPI
{
/** Google account login (email) **/
private $login;
/** Google account password **/
private $password;
/** Google analytics website ID (avalaible on your google analytics account url) **/
private $ids;
/** The login token to the google analytics service **/
private $loginToken;
/** The XML response send by the service **/
private $response;
/** Begin date of the displaying datas **/
private $date_begin;
/** End date of the displaying datas **/
private $date_end;
/** Sort the results **/
private $sort;
/** The param to sort (metrics or dimensions) **/
private $sort_param;
/**
* Class constructor
*
* @param string $login the login (email)
* @param string $password the password
* @param string $ids the IDs of the website (find it in the google analytics gui)
* @param string $date_begin the begin date
* @param string $date_end the end date
*
* @return void
*/
public function __construct($login,$password,$ids,$date_begin,$date_end = null)
{
$this->login = $login;
$this->password = $password;
$this->ids = $ids;
$this->date_begin = $date_begin;
if (!$date_end) {
$this->date_end = $date_begin;
} else {
$this->date_end = $date_end;
}
$this->sort = "-";
$this->sort_param = "metrics";
// Authentication
$this->login();
}
/**
* Set the result's sort by metrics
*
* @param boolean $sort asc or desc sort
*
* @return void
*/
public function setSortByMetrics ($sort)
{
if ($sort==true) {
$this->sort = "";
} else {
$this->sort = "-";
}
$this->sort_param = 'metrics';
}
/**
* Set the result's sort by dimensions
*
* @param boolean $sort asc or desc sort
*
* @return void
*/
public function setSortByDimensions ($sort)
{
if ($sort==true) {
$this->sort = "";
} else {
$this->sort = "-";
}
$this->sort_param = 'dimensions';
}
/**
* Set the IDs of the website
*
* @param string $ids the IDs of the website (find it in the google analytics gui)
*
* @return void
*/
public function setIds($ids)
{
$this->ids = $ids;
}
/**
* Set the date of the export
*
* @param string $date_begin the begin date
* @param string $date_end the end date
*
* @return void
*/
public function setDate ($date_begin,$date_end = null)
{
$this->date_begin = $date_begin;
if (!$date_end) {
$this->date_end = $date_begin;
} else {
$this->date_end = $date_end;
}
}
/**
* Login to the google server
* See : http://google-data-api.blogspot.com/2008/05/clientlogin-with-php-curl.html
*
* @return void
*/
private function login()
{
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://www.google.com/accounts/ClientLogin");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
$data = array('accountType' => 'GOOGLE',
'Email' => $this->login,
'Passwd' => $this->password,
'source'=>'php_curl_analytics',
'service'=>'analytics');
 
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_POST, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
 
$hasil = curl_exec($ch);
curl_close($ch);
// Get the login token
// SID=DQA...oUE
// LSID=DQA...bbo
// Auth=DQA...Sxq
if (preg_match('/Auth=(.*)$/',$hasil,$matches)>0) {
$this->loginToken = $matches[1];
} else {
trigger_error('Authentication problem',E_USER_WARNING);
return null;
}
}
/**
* Get URL content using cURL.
*
* @param string $url the url
*
* @return string the html code
*/
function getContent ($url)
{
if (!extension_loaded('curl')) {
throw new Exception('curl extension is not available');
}
$ch = curl_init($url);
$header[] = 'Authorization: GoogleLogin auth=' . $this->loginToken;
 
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HEADER, false);
$this->response = curl_exec($ch);
$infos = curl_getinfo($ch);
curl_close($ch);
return $infos['http_code'];
}
/**
* Get the google analytics datas by dimensions and metrics
* See : http://code.google.com/intl/fr/apis/analytics/docs/gdata/gdataReferenceDimensionsMetrics.html
*
* @param string $metrics the metrics
* @param string $dimensions the dimensions
*
* @return array
*/
public function getDimensionByMetric($metrics, $dimensions)
{
$url = "https://www.google.com/analytics/feeds/data?ids=ga:" . $this->ids . "&metrics=ga:" . $metrics . "&dimensions=ga:" . $dimensions . "&start-date=" . $this->date_begin . "&end-date=" . $this->date_end ."&sort=" . $this->sort . "ga:";
if ($this->sort_param=='metrics') { // sort by metrics
$url .= $metrics;
}
if ($this->sort_param=='dimensions') { // sort by dimensions
$url .= $dimensions;
}
 
if($this->getContent($url) == 200) {
$XML_object = simplexml_load_string($this->response);
$labels_array = array();
$datas_array = array();
foreach($XML_object->entry as $m) {
$dxp = $m->children('http://schemas.google.com/analytics/2009');
$metric_att = $dxp->metric->attributes();
$dimension_att = $dxp->dimension->attributes();
$labels_array []= $dimension_att['value'] . ' (' . $metric_att['value'] . ')';
$datas_array []= (string)$metric_att['value'];
}
return array('labels' => $labels_array, 'datas' => $datas_array);
} else {
return null;
}
}
/**
* Get the google analytics datas by metrics
* See : http://code.google.com/intl/fr/apis/analytics/docs/gdata/gdataReferenceDimensionsMetrics.html
*
* @param string $metrics the metrics
* @param string $uri the url of the website page (ex : /myurl/)
*
* @return array
*/
public function getMetric($metric,$uri=null)
{
$url = "https://www.google.com/analytics/feeds/data?ids=ga:" . $this->ids . "&metrics=ga:" . $metric . "&start-date=" . $this->date_begin . "&end-date=" . $this->date_end;
 
if ($uri) {
$url .= "&dimensions=ga:pagePath&filters=ga:pagePath%3D%3D" . $uri;
}
if($this->getContent($url) == 200) {
$XML_object = simplexml_load_string($this->response);
$dxp = $XML_object->entry->children('http://schemas.google.com/analytics/2009');
if (@count($dxp)>0) {
$metric_att = $dxp->metric->attributes();
}
return $metric_att['value'] ? (string)$metric_att['value'] : 0;
} else {
return null;
}
}
}
 
?>
/tags/v1.2-autel/jrest/bibliotheque/Log.php
New file
0,0 → 1,195
<?php
//declare(encoding='UTF-8');
/**
* Classe permettant de logger des messages dans les fichier situés dans le dossier de log
*
* PHP Version 5
*
* @category PHP
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/framework/
*/
 
class Log {
 
/**
* Tableau associatif stockant les descripteurs de fichiers
*/
private static $fichiersLog = array();
 
/**
* Chemin de base du dossier log de l'application
*/
private static $cheminLogs = '';
 
/**
* Booleen indiquant si l'on peut correctement écrire dans les fichiers de logs
*/
private static $droitLogger = true;
 
/**
* Zone horaire (pour éviter des avertissements dans les dates)
*/
private static $timeZone = '';
 
/**
* Taille maximum d'un fichier de log avant que celui ne soit archivé (en octets)
*/
private static $tailleMax = 10000;
 
/**
* séparateur de chemin
*/
private static $sd = DIRECTORY_SEPARATOR;
 
/**
* Extension des fichiers de log
*/
private static $ext = '.log';
 
/**
* La classe registre se contient elle-même, (pour le pattern singleton)
*/
private static $log;
 
/**
* Constructeur par défaut, privé, car on accède à la classe par le getInstance
*/
private function __construct() {
 
self::$sd = $sd;
// gestion de la timezone pour éviter des erreurs
if(function_exists("date_default_timezone_set") and function_exists("date_default_timezone_get")) {
date_default_timezone_set(self::$timeZone);
}
 
if(!is_dir(self::$cheminLogs) || !is_writable(self::$cheminLogs)) {
self::desactiverEcriture();
}
}
 
public static function setCheminLog($nouveauCheminLogs) {
self::$cheminLogs = $nouveauCheminLogs;
}
 
public static function getCheminLog() {
return self::$cheminLogs;
}
 
public static function setTimeZone($NouvelleTimeZone) {
self::$timeZone = $NouvelleTimeZone;
}
 
public static function setTailleMax($nouvelleTailleMax) {
self::$tailleMax = $nouvelleTailleMax;
}
 
/**
* Fonction qui renvoie l'instance de classe en assurant son unicité, c'est l'unique méthode qui doit être
* utilisée pour récupérer l'objet Registre
* @return Log le gestionnaire de log en cours
*/
public static function getInstance() {
if (self::$log instanceof Log) {
return self::$log;
}
self::$log = new Log();
return self::$log;
}
 
/**
* Ajoute une entrée au log spécifié par le paramètre $nomFichier
* @param string $nomFichier le nom du fichier dans lequel écrire
*/
public static function ajouterEntree($nomFichier,$entree,$mode='a+') {
if(self::$droitLogger) {
$date = "\n"."\n".date('d m Y H:i')."\n" ;
 
// si le fichier est déjà dans le tableau et qu'on peut y écrire
if(self::verifierOuvrirFichier($nomFichier,$mode)) {
// on y écrit le message de log
fwrite(self::$fichiersLog[$nomFichier],$date.$entree);
// on vérifie si le fichier ne dépasse pas la taille maximale
self::verifierTailleFichierOuArchiver($nomFichier);
} else {
// sinon on interdit l'écriture
self::desactiverEcriture($nomFichier);
}
}
}
 
/**
* Vide un fichier log indiqué
* @param string $nomFichier le nom du fichier à vider
*/
public static function viderLog($nomFichier) {
ajouterEntree($nomFichier,'','w');
}
 
/**
* Vérifie la présence d'un fichier dans le tableau, ses droits d'écriture,
* l'ouvre si nécessaire
* @param string $nomFichier le nom du fichier dont on doit vérifier la présence
* @return boolean true si le fichier est ouvert ou maintenant accessible, false sinon
*/
public static function verifierOuvrirFichier($nomFichier,$mode) {
// le fichier est il déjà ouvert ?
if(in_array($nomFichier,self::$fichiersLog)) {
// si oui peut on y écrire ?
if(is_writable(self::$cheminLogs.$nomFichier.self::$ext)) {
// si oui on renvoie le descripteur
return true;
}
return false;
} else {
// sinon on l'ouvre
$fp = @fopen(self::$cheminLogs.$nomFichier.self::$ext,$mode);
// si l'ouverture a réussi et si le fichier a les droits d'écriture
if($fp && is_writable(self::$cheminLogs.$nomFichier.self::$ext)) {
// si oui on renvoie le descripteur qu'on ajoute au tableau
self::$fichiersLog[$nomFichier] = $fp;
return true;
}
return false;
}
}
 
/**
* Vérifie la taille d'un fichier donné et si celle ci est trop importante
* archive le fichier de log
* @param string $nomFichier nom du fichier à vérifier
*/
private static function verifierTailleFichierOuArchiver($nomFichier) {
if(filesize(self::$cheminLogs.$nomFichier.self::$ext) > self::$tailleMax) {
rename(self::$cheminLogs.$nomFichier.self::$ext,self::$cheminLogs.$nomFichier.date('d_m_Y_H:i').self::$ext);
self::ajouterEntree($nomFichier,'');
}
}
 
/**
* Désactive l'écriture du log et envoie un message au gestionnaire d'erreurs
* @param string $nomFichier le nom du fichier qui a causé l'erreur
*/
private static function desactiverEcriture($nomFichier = '') {
self::$droitLogger = false;
if($nomFichier != '') {
$fichierDossier = 'fichier '.$nomFichier ;
} else {
$fichierDossier = 'dossier des logs';
}
}
 
/**
* destructeur de classe, ferme les descripteurs ouverts
*/
public function __destruct() {
foreach(self::$fichiersLog as $nomFichier => $fp) {
fclose($fp);
}
}
}
?>
/tags/v1.2-autel/jrest/JRest.php
New file
0,0 → 1,307
<?php
// In : utf8 url_encoded (get et post)
// Out : utf8
 
// TODO : gerer les retours : dans ce controleur : code retour et envoi ...
class JRest {
 
/** Parsed configuration file */
private $config;
 
/** The HTTP request method used. */
private $method = 'GET';
 
/** The HTTP request data sent (if any). */
private $requestData = NULL;
 
/** Array of strings to convert into the HTTP response. */
private $output = array();
 
/** Nom resource. */
private $resource = NULL;
 
/** Identifiant unique resource. */
private $uid = NULL;
 
/**
* Constructor. Parses the configuration file "JRest.ini", grabs any request data sent, records the HTTP
* request method used and parses the request URL to find out the requested resource
* @param str iniFile Configuration file to use
*/
public function JRest($iniFile = 'jrest.ini.php') {
$this->config = parse_ini_file($iniFile, TRUE);
if (isset($_SERVER['REQUEST_URI']) && isset($_SERVER['REQUEST_METHOD']) && isset($_SERVER['QUERY_STRING'])) {
if (isset($_SERVER['CONTENT_LENGTH']) && $_SERVER['CONTENT_LENGTH'] > 0) {
$this->requestData = '';
$httpContent = fopen('php://input', 'r');
while ($data = fread($httpContent, 1024)) {
$this->requestData .= $data;
}
fclose($httpContent);
}
if (strlen($_SERVER['QUERY_STRING']) == 0) {
$len = strlen($_SERVER['REQUEST_URI']);
} else {
$len = -(strlen($_SERVER['QUERY_STRING']) + 1);
}
 
$urlString = '';
if (substr_count($_SERVER['REQUEST_URI'], $this->config['settings']['baseURL']) > 0) {
$urlString = substr($_SERVER['REQUEST_URI'], strlen($this->config['settings']['baseURL']), $len);
} else if (substr_count($_SERVER['REQUEST_URI'], $this->config['settings']['baseAlternativeURL']) > 0) {
$urlString = substr($_SERVER['REQUEST_URI'], strlen($this->config['settings']['baseAlternativeURL']), $len);
}
$urlParts = explode('/', $urlString);
 
if (isset($urlParts[0])) $this->resource = $urlParts[0];
if (count($urlParts) > 1 && $urlParts[1] != '') {
array_shift($urlParts);
foreach ($urlParts as $uid) {
if ($uid != '') {
$this->uid[] = urldecode($uid);
}
}
}
 
$this->method = $_SERVER['REQUEST_METHOD'];
} else {
trigger_error('I require the server variables REQUEST_URI, REQUEST_METHOD and QUERY_STRING to work.', E_USER_ERROR);
}
}
 
/**
* Execute the request.
*/
function exec() {
switch ($this->method) {
case 'GET':
$this->get();
break;
case 'POST':
$this->post();
break;
case 'DELETE':
$this->delete();
break;
case 'PUT':
$this->add();
break;
}
}
 
/**
* Execute a GET request. A GET request fetches a list of resource when no resource name is given, a list of element
* when a resource name is given, or a resource element when a resource and resource unique identifier are given. It does not change the
* database contents.
*/
private function get() {
if ($this->resource) {
$resource_file = 'services/'.ucfirst($this->resource).'.php';
$resource_class = ucfirst($this->resource);
if (file_exists($resource_file)) {
include_once $resource_file;
if (class_exists($resource_class)) {
$service = new $resource_class($this->config);
if ($this->uid) { // get a resource element
if (method_exists($service, 'getElement')) {
$service->getElement($this->uid);
}
} elseif (method_exists($service, 'getRessource')) { // get all elements of a ressource
$service->getRessource();
}
}
}
} else { // get resources
// include set.jrest.php, instanticiation et appel
}
}
 
private function post() {
$pairs = array();
// Récupération des paramètres passés dans le contenu de la requête HTTP (= POST)
if ($this->requestData) {
$pairs = $this->parseRequestData();
}
 
// Ajout des informations concernant l'upload de fichier passées dans la variable $_FILE
if(isset($_FILES)) {
foreach ($_FILES as $v) {
$pairs[$v['name']] = $v;
}
 
// Ne pas effacer cette ligne ! Elle est indispensable pour les services du Carnet en ligne
// qui n'utilisent que le tableau pairs dans les posts
$pairs = array_merge($pairs, $_POST);
}
 
// gestion du contenu du post
if(isset($_POST))
{
// Safari ne sait pas envoyer des DELETE avec gwt...
// Nous utilisons le parametre "action" passé dans le POST qui doit contenir DELETE pour lancer la supression
if ($pairs['action'] == 'DELETE') {
$this->delete();
return;
}
 
if (count($pairs) != 0) {
if ($this->uid) { // get a resource element
$resource_file = 'services/'.ucfirst($this->resource).'.php';
$resource_class = ucfirst($this->resource);
if (file_exists($resource_file)) {
include_once $resource_file;
if (class_exists($resource_class)) {
$service = new $resource_class($this->config);
if (method_exists($service,'updateElement')) { // Update element
// TODO : a voir le retour ...
if ($service->updateElement($this->uid, $pairs)) {
$this->created();
}
}
}
}
} else { // get all elements of a ressource
$this->add($pairs);
}
} else {
$this->lengthRequired();
}
}
}
 
private function delete() {
$resource_file = 'services/'.ucfirst($this->resource).'.php';
$resource_class = ucfirst($this->resource);
if (file_exists($resource_file)) {
include_once $resource_file;
if (class_exists($resource_class)) {
$service = new $resource_class($this->config);
if ($this->uid) { // get a resource element
if (method_exists($service, 'deleteElement')) { // Delete element
if ($service->deleteElement($this->uid)) {
$this->noContent();
}
}
}
}
}
}
 
private function add($pairs = null) {
if (is_null($pairs)) {
$pairs = array();
// Récupération des paramètres passés dans le contenu de la requête HTTP (= POST)
// FIXME : vérifier que l'on récupère bien les données passées par PUT
if ($this->requestData) {
$pairs = $this->parseRequestData();
}
}
 
if (count($pairs) != 0) {
$resource_file = 'services/'.ucfirst($this->resource).'.php';
$resource_class = ucfirst($this->resource);
if (file_exists($resource_file)) {
include_once $resource_file;
if (class_exists($resource_class)) {
$service = new $resource_class($this->config);
if (method_exists($service,'createElement')) { // Create a new element
if ($service->createElement($pairs)) {
$this->created();
}
}
}
}
} else {
$this->lengthRequired();
}
}
 
/**
* Parse the HTTP request data.
* @return str[] Array of name value pairs
*/
private function parseRequestData() {
$values = array();
$pairs = explode('&', $this->requestData);
foreach ($pairs as $pair) {
$parts = explode('=', $pair);
if (isset($parts[0]) && isset($parts[1])) {
$parts[1] = rtrim(urldecode($parts[1]));
$values[$parts[0]] = $parts[1];
}
}
return $values;
}
 
/**
* Send a HTTP 201 response header.
*/
private function created($url = FALSE) {
header('HTTP/1.0 201 Created');
if ($url) {
header('Location: '.$url);
}
}
 
/**
* Send a HTTP 204 response header.
*/
private function noContent() {
header('HTTP/1.0 204 No Content');
}
 
/**
* Send a HTTP 400 response header.
*/
private function badRequest() {
header('HTTP/1.0 400 Bad Request');
}
 
/**
* Send a HTTP 401 response header.
*/
private function unauthorized($realm = 'JRest') {
if (!isset($_SERVER['PHP_AUTH_USER']) || !isset($_SERVER['PHP_AUTH_PW'])) {
header('WWW-Authenticate: Basic realm="'.$realm.'"');
}
header('HTTP/1.0 401 Unauthorized');
}
 
/**
* Send a HTTP 404 response header.
*/
private function notFound() {
header('HTTP/1.0 404 Not Found');
}
 
/**
* Send a HTTP 405 response header.
*/
private function methodNotAllowed($allowed = 'GET, HEAD') {
header('HTTP/1.0 405 Method Not Allowed');
header('Allow: '.$allowed);
}
 
/**
* Send a HTTP 406 response header.
*/
private function notAcceptable() {
header('HTTP/1.0 406 Not Acceptable');
echo join(', ', array_keys($this->config['renderers']));
}
 
/**
* Send a HTTP 411 response header.
*/
private function lengthRequired() {
header('HTTP/1.0 411 Length Required');
}
 
/**
* Send a HTTP 500 response header.
*/
private function internalServerError() {
header('HTTP/1.0 500 Internal Server Error');
}
}
?>
/tags/v1.2-autel/jrest/index.php
New file
0,0 → 1,31
<?php
/**
* La fonction __autoload() charge dynamiquement les classes trouvées dans le code.
*
* Cette fonction est appelée par php5 quand il trouve une instanciation de classe dans le code.
*
*@param string le nom de la classe appelée.
*@return void le fichier contenant la classe doit être inclu par la fonction.
*/
function __autoloadJRest($classe)
{
if (class_exists($classe)) {
return null;
}
 
$chemins = array('', 'services/', 'bibliotheque/');
foreach ($chemins as $chemin) {
$chemin = $chemin.$classe.'.php';
if (file_exists($chemin)) {
require_once $chemin;
}
}
}
 
spl_autoload_register('__autoloadJRest');
 
require_once('../initialisation.php');
 
$jRest = new JRest();
$jRest->exec();
?>
/tags/v1.2-autel/jrest/jrest.ini.defaut.php
New file
0,0 → 1,48
;<?/*
[settings]
baseURL = "/client/annuaire_nouveau/actuelle/jrest/"
; URL de base relative alternative de JREST (pour les raccourcis par exemple)
baseAlternativeURL = "/service:annuaire:"
 
; Default
[appli]
phptype = mysql
username =
password =
hostspec = localhost
database = tb_v4
 
; Infos pour Google Analytics
[google]
email_google = accueil@tela-botanica.org
password_google = ""
id_site_google = 16474
 
; Identification
[database_ident]
phptype = mysql
username =
password =
hostspec = localhost
database = tb_v4
annuaire = annuaire_tela
ann_id = U_MAIL
ann_pwd = U_PASSWD
pass_crypt_funct = md5
nom_cookie_persistant="pap-annuaire_tela-memo"
nom_cookie_utilisateur="pap-annuaire_tela-utilisateur"
 
;MESSAGERIE
[messagerie]
utilisateurs_autorises = identiplante@tela-botanica.org,annuaire@tela-botanica.org
 
; LOGS
[log]
cheminlog = "/tmp"
timezone = "Europe/Paris"
taillemax = 100000
 
; ADMIN
[jrest_admin]
admin = aurelien@tela-botanica.org,david.delon@clapas.net,jpm@tela-botanica.org,marie@tela-botanica.org
;*/?>
/tags/v1.2-autel/jrest/services/Utilisateur.php
New file
0,0 → 1,302
<?php
// declare(encoding='UTF-8');
/**
* Service retournant les prénoms et nom d'un utilisateur en fonction de son courriel.
* UNe liste de courriel peut être passé dans la ressource.
* Exemple :
* /utilisateur/Prenom-nom-par-courriel/jpm@tela-botanica.org,aurelien@tela-botanica.org
*
* @category php 5.2
* @package Annuaire::Services
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class Utilisateur extends JRestService {
 
private $donnees = null;
private $idAnnuaire = null;
private $utilisateurId = null;
private $metadonneeModele = null;
private $annuaireModele = null;
private $messagerieModele = null;
 
/*+----------------------------------------------------------------------------------------------------+*/
// GET : consultation
 
public function getElement($ressources){
$this->ressources = $ressources;
$this->idAnnuaire = Config::get('annuaire_defaut');
$infos = null;
 
if (isset($this->ressources[0])) {
$methode_demande = array_shift($this->ressources);
$methode = $this->traiterNomMethodeGet($methode_demande);
if (method_exists($this, $methode)) {
$infos = $this->$methode();
} else {
$this->messages[] = "Ce type de ressource '$methode_demande' n'est pas disponible pour la requete GET.";
}
} else {
$this->messages[] = "Le premier paramêtre du chemin du service doit correspondre au type de ressource demandée.";
}
 
if (!is_null($infos)) {
$this->envoyerJson($infos);
} else {
$info = 'Un problème est survenu : '.print_r($this->messages, true);
$this->envoyerTxt($info);
}
}
 
/**
* Permet d'obtenir les prénoms et noms des courriels des utilisateurs indiqués dans la ressource.
* RESSOURCE : /utilisateur/prenom-nom-par-courriel/[courriel,courriel,...]
* PARAMÊTRES : aucun
* RÉPONSE : Tableau possédant un courriel de la ressource en clé et en valeur :
* - id : identifiant numérique de l'utilisateur
* - prenom : prénom
* - nom : nom de famille.
*/
public function getPrenomNomParCourriel() {
$courriels = explode(',', $this->ressources[0]);
$infos = $this->getAnnuaire()->obtenirPrenomNomParCourriel($this->idAnnuaire, $courriels);
$infous_courriel_minuscule = array();
foreach ($infos as $courriel => $utilisateur) {
$courriel = strtolower($courriel);
$infous_courriel_minuscule[$courriel] = $utilisateur;
}
return $infos;
}
 
/**
* Permet d'obtenir les identités des utilisateurs indiqués dans la ressource.
* RESSOURCE : /utilisateur/identite-par-courriel/[courriel,courriel,...]
* PARAMÊTRES : aucun
* RÉPONSE : Tableau possédant un courriel de la ressource en clé et en valeur :
* - id : identifiant numérique de l'utilisateur
* - pseudoUtilise : indique si on doit utiliser le pseudo à la place de Prénom NOM
* - pseudo : pseudo de l'utilisateur.
* - prenom : prénom
* - nom : nom de famille.
*/
public function getIdentiteParCourriel() {
$infos_utilisateurs = array();
$utilisateurs = $this->getPrenomNomParCourriel();
foreach ($utilisateurs as $courriel => $utilisateur) {
$id = $utilisateur['id'];
$utilisateur['pseudo'] = $this->obtenirPseudo($id);
$utilisateur['pseudoUtilise'] = $this->obtenirPseudoUtilise($id);
$utilisateur['intitule'] = $this->formaterIntitule($utilisateur);
$infos_utilisateurs[$courriel] = $utilisateur;
}
return $infos_utilisateurs;
}
 
private function getAnnuaire() {
if (!isset($this->annuaireModele)) {
$this->annuaireModele = new AnnuaireModele();
}
return $this->annuaireModele;
}
 
private function getMeta() {
if (!isset($this->metadonneeModele)) {
$this->metadonneeModele = new MetadonneeModele();
}
return $this->metadonneeModele;
}
 
private function obtenirPseudo($id_utilisateur) {
$pseudo = '';
$id_champ_pseudo = $this->getMeta()->renvoyerIdChampMetadonneeParAbreviation($this->idAnnuaire, 'pseudo');
if ($this->getMeta()->valeurExiste($id_champ_pseudo, $id_utilisateur)) {
$pseudo = $this->getMeta()->obtenirValeurMetadonnee($id_champ_pseudo, $id_utilisateur);
}
return $pseudo;
}
 
private function obtenirPseudoUtilise($id_utilisateur) {
$pseudo_utilise = false;
$id_champ_utilise_pseudo = $this->getMeta()->renvoyerIdChampMetadonneeParAbreviation($this->idAnnuaire, 'utilise_pseudo');
if ($this->getMeta()->valeurExiste($id_champ_utilise_pseudo, $id_utilisateur)) {
$booleen = $this->getMeta()->obtenirValeurMetadonnee($id_champ_utilise_pseudo, $id_utilisateur);
$pseudo_utilise = ($booleen == 0) ? false : true;
}
return $pseudo_utilise;
}
 
private function formaterIntitule($utilisateur) {
$intitule = '';
if ($utilisateur['pseudoUtilise'] && trim($utilisateur['pseudo']) != '') {
$intitule = $utilisateur['pseudo'];
} else {
$intitule = $utilisateur['prenom'].' '.$utilisateur['nom'];
}
return $intitule;
}
 
/*+----------------------------------------------------------------------------------------------------+*/
// POST : mise à jour
 
public function updateElement($ressources, $donnees) {
$this->ressources = $ressources;
$this->donnees = $donnees;
$this->idAnnuaire = Config::get('annuaire_defaut');
 
$infos = null;
if (isset($this->ressources[0])) {
$this->utilisateurId = array_shift($this->ressources);
if (isset($this->ressources[0])) {
$methode_demande = array_shift($this->ressources);
$methode = $this->traiterNomMethodePost($methode_demande);
if (method_exists($this, $methode)) {
$infos = $this->$methode();
} else {
$this->messages[] = "Ce type de ressource '$methode_demande' n'est pas disponible pour la requete POST.";
}
} else {
$this->messages[] = "La seconde ressource du service pour les requêtes POST doit correspondre au type de ressource demandée.";
}
} else {
$this->messages[] = "La première ressource du service pour les requêtes POST doit être l'identifiant de l'utilisateur.";
}
 
if (!is_null($infos)) {
$this->envoyerJson($infos);
} else {
$info = 'Un problème est survenu : '.print_r($this->messages, true);
$this->envoyerTxt($info);
}
}
 
/**
* Permet d'envoyer un message à un utilisateur.
* RESSOURCE : /utilisateur/[id]/message
* POST :
* - sujet : contient le sujet du message à envoyer.
* - message : contient le contenu du message à envoyer.
* - utilisateur_courriel : contient le courriel de l'utilisateur qui envoie le message (Il doit être
* inscrit dans l'annuaire par défaut de Tela Botanica).
* - copies : peut contenir une liste de courriels séparés par des virguels auxquels une copie du
* message sera envoyée.
* - format (optionnel) : text ou html
* RÉPONSE :
* - message : contient le message d'information concernant l'envoie.
*/
private function updateMessage() {
$destinataireId = $this->utilisateurId;//$this->donnees['destinataire_id'];
$sujet = stripslashes($this->donnees['sujet']);
$contenu = stripslashes($this->donnees['message']);
$envoyeur = $this->donnees['utilisateur_courriel'];
$copies = array_key_exists('copies', $this->donnees) ? explode(',', $this->donnees['copies']) : null;
$format = isset($this->donnees['format']) ? $this->donnees['format'] : 'text';
 
$info = null;
if ($this->estAutoriseMessagerie($envoyeur) || $this->getAnnuaire()->utilisateurExisteParMail($this->idAnnuaire, $envoyeur)) {
// il est possible de passer directement un email ou bien un id utilisateur
if(filter_var($destinataireId, FILTER_VALIDATE_EMAIL)) {
$destinataire = $destinataireId;
} else {
$destinataire = $this->getAnnuaire()->obtenirMailParId($this->idAnnuaire, $destinataireId);
}
if ($destinataire) {
if ($format == 'html') {
$envoie = $this->getMessagerie()->envoyerMail($envoyeur, $destinataire, $sujet, $contenu);
} else {
$envoie = $this->getMessagerie()->envoyerMailText($envoyeur, $destinataire, $sujet, $contenu);
}
if ($envoie) {
$info['message'] = "Votre message a bien été envoyé.";
foreach ($copies as $copie) {
$sujet = '[COPIE] '.$sujet;
$contenu = "Message original envoyé par $envoyeur pour $destinataire.\n--\n".$contenu;
$this->getMessagerie()->envoyerMailText($envoyeur, $copie, $sujet, $contenu);
}
} else {
$info['message'] = "Le message n'a pas pu être envoyé.";
}
} else {
$info['message'] = "Aucun courriel ne correspond à l'id du destinataire.";
}
} else {
$info['message'] = "Vous n'êtes pas inscrit à Tela Botanica avec le courriel : $envoyeur.\n".
"Veuillez saisir votre courriel d'inscription ou vous inscrire à Tela Botanica.";
}
return $info;
}
 
private function getMessagerie() {
if (!isset($this->messagerieModele)) {
$this->messagerieModele = new MessageControleur();
}
return $this->messagerieModele;
}
 
/*+----------------------------------------------------------------------------------------------------+*/
// PUT : ajout
 
public function createElement($donnees) {
$this->donnees = $donnees;
$this->idAnnuaire = Config::get('annuaire_defaut');
 
$infos = null;
if (isset($this->donnees['methode'])) {
$methode_demande = $this->donnees['methode'];
$methode = $this->traiterNomMethodePut($methode_demande);
if (method_exists($this, $methode)) {
$infos = $this->$methode();
} else {
$this->messages[] = "Ce type de méthode '$methode_demande' n'est pas disponible pour la requete PUT.";
}
} else {
$this->messages[] = "Ce service n'est pas implémanté.";
}
 
if (!is_null($infos)) {
$this->envoyerJson($infos);
} else {
$info = 'Un problème est survenu : '.print_r($this->messages, true);
$this->envoyerTxt($info);
}
}
 
/**
* Permet d'identifier un utilisateur.
* RESSOURCE : /utilisateur
* POST :
* - methode = 'connexion' : methode doit valoir 'connexion' pour connecter l'utilisateur.
* - courriel : contient le courriel de l'utilisateur .
* - mdp : le mot de passe de l'utilisateur.
* - persistance : true si on veut laisser l'utilisateur connecté au delà de la session sinon false
* RÉPONSE :
* - identifie : indiquer si l'utilisateur a été identifié (true) ou pas (false)
* - message : contient un message d'information complémentaire de l'état.
*/
private function createConnexion() {
$courriel = stripslashes($this->donnees['courriel']);
$mdp = stripslashes($this->donnees['mdp']);
$persistance = (stripslashes($this->donnees['persistance']) == 'true') ? true : false;
 
$infos = null;
$infos['persistance'] = $persistance;
if ($this->verifierAcces($courriel, $mdp)) {
$infos['identifie'] = true;
$infos['message'] = "Bienvenu.";
$dureeCookie = 0;
if ($persistance === true) {
$dureeCookie = time()+3600*24*30;
$this->creerCookiePersistant($dureeCookie, $courriel, $mdp);
}
$this->creerCookieUtilisateur($dureeCookie, $courriel);
$infos['message'] = $_COOKIE;
} else {
$infos['identifie'] = false;
$infos['message'] = "Le courriel ou le mot de passe saisi est incorrect.";
}
return $infos;
}
}
?>
/tags/v1.2-autel/jrest/services/UtilisateurExiste.php
New file
0,0 → 1,27
<?php
// declare(encoding='UTF-8');
/**
* Service vérifiant que l'utilisateur dont le courriel est passé en paramètre existe dans l'annuaire.
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class UtilisateurExiste extends JRestService {
 
public function getElement($uid){
$mail_utilisateur = $uid[0];
$id_annuaire = Config::get('annuaire_defaut');
 
$controleur = new AnnuaireControleur();
$existe = $controleur->UtilisateurExiste($id_annuaire,$mail_utilisateur, true);
 
$this->envoyer($existe);
}
}
?>
/tags/v1.2-autel/jrest/services/NbInscrits.php
New file
0,0 → 1,51
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class NbInscrits extends JRestService {
 
public function getRessource() {
$this->getElement(array());
}
public function getElement($uid){
$id_annuaire = Config::get('annuaire_defaut');
if (isset($uid[0])) {
$id_annuaire = $uid[0];
}
$json = true;
if (isset($uid[1]) && $uid[1] == 'html') {
$json = false;
}
 
$controleur = new AnnuaireControleur();
$valeurs = $controleur->chargerNombreAnnuaireListeInscrits($id_annuaire);
if (!$json) {
$valeurs =
'<html>'."\n".
' </head>'."\n".
' <meta content="text/html; charset='.Config::get('sortie_encodage').'" http-equiv="Content-Type">'."\n".
' </head>'."\n".
' <body>'."\n".
' <div id="contenu">'.$valeurs.'</div>'."\n".
' </body>'."\n".
'</html>';
}
 
$this->envoyer($valeurs, 'text/html', Config::get('sortie_encodage'), $json);
}
}
?>
/tags/v1.2-autel/jrest/services/MiniLienProfil.php
New file
0,0 → 1,46
<?php
// declare(encoding='UTF-8');
/**
* Service renvoyant un lien vers le profil d'un utilisateur sous la forme de son nom'
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class MiniLienProfil extends JRestService {
 
public function getRessource(){
if(!isset($_COOKIE['pap-annuaire_tela-utilisateur']) && isset($_COOKIE['pap-annuaire_tela-memo'])) {
$_COOKIE['pap-annuaire_tela-utilisateur'] = $_COOKIE['pap-annuaire_tela-memo'];
}
 
if (isset($_COOKIE['pap-annuaire_tela-utilisateur'])) {
 
$username = $_COOKIE['pap-annuaire_tela-utilisateur'];
// le cookie de papyrus contient un md5 concaténé à l'email utilisateur
$username = substr($username , 32, strlen($username));
$controleur = new AnnuaireControleur();
$valeurs = $controleur->obtenirInfosUtilisateur('1', $username, true);
$nom_affiche_lien = $valeurs['fullname'];
$tableau_nom_prenom = split(" ", $nom_affiche_lien, 2);
if(strlen($nom_affiche_lien) > 20) {
$nom_affiche_lien = substr($nom_affiche_lien,0,20).'...';
}
$lien = 'Bienvenue <a href="http://www.tela-botanica.org/page:mon_inscription_au_reseau"> '.ucwords(strtolower($nom_affiche_lien)).'</a>';
echo json_encode($lien);
} else {
$lien = '';
echo json_encode($lien);
}
}
}
?>
/tags/v1.2-autel/jrest/services/ModificationsRss.php
New file
0,0 → 1,28
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class ModificationsRss extends JRestService {
 
public function getElement($uid){
$id_annuaire = (isset($uid[0])) ? $uid[0] : Config::get('annuaire_defaut');
$this->authentifier();
 
$controleur = new RSSControleur();
$modifications = $controleur->obtenirDernieresModificationsProfil($id_annuaire);
 
$this->envoyer($modifications, 'text/xml',Config::get('sortie_encodage'), false);
}
}
?>
/tags/v1.2-autel/jrest/services/ExecuteurLien.php
New file
0,0 → 1,46
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class ExecuteurLien extends JRestService {
 
public function getElement($uid){
if (isset($uid[0])) {
$lien_code = $uid[0];
$lien = base64_decode(str_replace('_', '/', $lien_code));
} else {
return;
}
 
if (!isset($uid[1])) {
$retour_ajax = true;
} else {
$adresse_retour = base64_decode(str_replace('_', '/', $uid[1]));
}
 
$requete = file_get_contents($lien);
 
if ($retour_ajax) {
if ($requete) {
$resultat = 'ok';
} else {
$resultat = false;
}
$this->envoyer($resultat);
} else {
header('Location: http://'.$adresse_retour);
exit;
}
}
}
?>
/tags/v1.2-autel/jrest/services/InformationsUtilisateur.php
New file
0,0 → 1,36
<?php
// declare(encoding='UTF-8');
/**
* Service retournant des informations sur l'utilisateur.
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class InformationsUtilisateur extends JRestService {
 
public function getElement($uid){
$mail_utilisateur = $uid[0];
$identificateur = new IdentificationControleur();
$login = $identificateur->obtenirLoginUtilisateurParCookie();
if ($mail_utilisateur != $login) {
return;
}
$id_annuaire = Config::get('annuaire_defaut');
 
$controleur = new AnnuaireControleur();
$valeurs = $controleur->obtenirInfosUtilisateurOpenId($id_annuaire, $mail_utilisateur, true);
 
$this->envoyer($valeurs);
}
}
?>
/tags/v1.2-autel/jrest/services/TelaUtilisateurs.php
New file
0,0 → 1,41
<?php
/**
* Encodage en entrée : utf8
* Encodage en sortie : utf8
*
* @author Grégoire Duché <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $Id$
* @copyright 2009
*/
 
class TelaUtilisateurs extends JRestService {
/**
* Méthode appelée quand aucun paramêtre n'est passée dans l'url et avec une requête de type GET.
*/
public function getRessource() {
$this->getElement(array());
}
public function getElement($params = array()) {
$id_annuaire = Config::get('annuaire_defaut');
if(isset($uid[0])) {
$id_annuaire = $uid[0];
}
 
$controleur = new AnnuaireControleur();
$nb_inscrits = $controleur->chargerNombreAnnuaireListeInscrits($id_annuaire);
$info[] = $nb_inscrits;
 
//TODO externaliser ceci
$en_ligne = file_get_contents('/home/telabotap/www/nb_sessions_active.json');
$info[] = json_decode($en_ligne);
$this->envoyer($info);
}
}
?>
/tags/v1.2-autel/jrest/services/EnvoiMessage.php
New file
0,0 → 1,55
<?php
// declare(encoding='UTF-8');
/**
* Service d'envoie de courriel.
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class EnvoiMessage extends JRestService {
 
public function getElement($uid){
$identificateur = new IdentificationControleur();
$login = $identificateur->obtenirLoginUtilisateurParCookie();
 
$identification = $login;
 
if (!$identification || trim($identification) == '') {
print 'false';
} else {
$id_annuaire = Config::get('annuaire_defaut');
$contenu_message = $_GET['contenu_message'];
$sujet_message = $_GET['sujet_message'];
$destinataire = $_GET['destinataire'];
$redirect = $_GET['redirect'];
 
$messagerie = new MessageControleur();
// Remplacement les identifiants par leurs destinataires
$destinataire_mail = $messagerie->obtenirMailParTableauId($id_annuaire, array($destinataire));
if (empty($destinataire_mail)) {
print 'false';
} else {
$destinataire_mail = $destinataire_mail[0];
 
$retour = $messagerie->envoyerMail($identification, $destinataire_mail, $sujet_message, $contenu_message);
if ($retour) {
if ($redirect != null && $redirect != '') {
header('Location: '.'http://'.$redirect);
exit;
} else {
print 'OK';
}
} else {
print 'false';
}
}
}
}
}
?>
/tags/v1.2-autel/jrest/services/GestionLettreActu.php
New file
0,0 → 1,35
<?php
// declare(encoding='UTF-8');
/**
* Service de gestion de la lettre d'actualité
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class GestionLettreActu extends JRestService {
 
public function getElement($uid){
// TODO : rajouter controle d'accès !
 
$id_utilisateur = $uid[0];
$mail_utilisateur = $uid[1];
 
if (isset($uid[2])) {
$id_annuaire = $uid[2];
} else {
$id_annuaire = Config::get('annuaire_defaut');
}
 
$controleur = new LettreControleur();
$est_abonne = $controleur->estAbonneLettreActualite($id_annuaire,$id_utilisateur);
$changement = $controleur->abonnerDesabonnerLettreActualite($id_annuaire, $id_utilisateur, !$est_abonne);
echo 'OK';
}
}
?>
/tags/v1.2-autel/jrest/services/StatistiquesAnnuaire.php
New file
0,0 → 1,59
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class StatistiquesAnnuaire extends JRestService {
 
public function getElement($uid){
 
if (!isset($uid[0])) {
$id_annuaire = $uid[0];
} else {
$id_annuaire = Config::get('annuaire_defaut');
}
if (isset($uid[1])) {
$type_stat = $uid[1];
} else {
$type_stat = '';
}
$controleur = new StatistiqueControleur();
switch($type_stat) {
case 'annee' :
$annee = isset($uid[2]) ? $uid[2] : null;
$graph = $controleur->obtenirStatistiquesPourAnnee($id_annuaire, $annee);
break;
case 'annees' :
$graph = $controleur->obtenirStatistiquesParAnnees($id_annuaire);
break;
case 'continents' :
$graph = $controleur->obtenirStatistiquesInscritsParContinents($id_annuaire);
break;
case 'europe' :
$graph = $controleur->obtenirStatistiquesInscritsEurope($id_annuaire);
break;
case 'modification' :
$graph = $controleur->obtenirStatistiquesModificationsProfil($id_annuaire);
break;
default:
$graph = $controleur->obtenirStatistiquesParCritere($id_annuaire,$type_stat, '');
}
// Envoi d'une image png
header("Content-type: image/png charset=utf-8\n\n");
imagepng($graph);
}
}
?>
/tags/v1.2-autel/jrest/services/InscritsRss.php
New file
0,0 → 1,32
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class InscritsRss extends JRestService {
 
public function getElement($uid){
$mail_utilisateur = $uid[0];
$admin = (isset($uid[1])) ? $uid[1] : false;
$id_annuaire = Config::get('annuaire_defaut');
if ($admin) {
$this->authentifier();
}
 
$controleur = new RSSControleur();
$inscrits = $controleur->obtenirDerniersInscritsRSS($id_annuaire, $admin);
 
$this->envoyer($inscrits, 'text/xml',Config::get('sortie_encodage'), false);
}
}
?>
/tags/v1.2-autel/jrest/services/IdUtilisateur.php
New file
0,0 → 1,27
<?php
/**
* PHP Version 5
*
* @category PHP
* @package annuaire
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2010 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/annuaire/
*/
 
Class IdUtilisateur extends JRestService {
 
public function getElement($uid){
 
$mail_utilisateur = $uid[0];
$id_annuaire = Config::get('annuaire_defaut');
 
$controleur = new AnnuaireControleur();
$id = $controleur->ObtenirIdParMail($id_annuaire,$mail_utilisateur);
 
$this->envoyer($id);
}
}
?>
/tags/v1.2-autel/jrest/services/Gestion.php
New file
0,0 → 1,54
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class Gestion extends JRestService {
 
public function getElement($uid){
$id_utilisateur = $uid[0];
$mail_utilisateur = $uid[1];
 
if (isset($uid[2])) {
$id_annuaire = $uid[2];
} else {
$id_annuaire = Config::get('annuaire_defaut');
}
 
$controleur = new LettreControleur();
$est_abonne = $controleur->estAbonneLettreActualite($id_annuaire, $id_utilisateur);
 
$resume['titre'] = 'Lettre d\'actualit&eacute;';
 
if ($est_abonne == '1') {
$message = "Vous &ecirc;tes abonn&eacute; &agrave; la lettre d'actualit&eacute;";
$intitule_lien = 'Se desinscrire';
} else {
$message = "Vous n'&ecirc;tes pas abonn&eacute; &agrave; la lettre d'actualit&eacute;";
$intitule_lien = "S'inscrire";
}
$base_url_application = $controleur->getUrlBaseComplete();
$cible_lien_desinscrire = $base_url_application.'/jrest/GestionLettreActu/'.$id_utilisateur.DS.$mail_utilisateur.DS.$id_annuaire;
$cible_lien = $base_url_application.'/jrest/GestionLettreActu/'.$id_utilisateur.DS.$mail_utilisateur.DS.$id_annuaire;
$resume_item = array(
'element' => $message,
'intitule_lien' => $intitule_lien,
'lien_desinscrire' => $cible_lien_desinscrire,
'lien' => $cible_lien);
$resume['elements'][] = $resume_item;
 
$this->envoyer($resume);
}
}
?>
/tags/v1.2-autel/jrest/services/TestLoginMdp.php
New file
0,0 → 1,36
<?php
// declare(encoding='UTF-8');
/**
* Service
*
* @category php 5.2
* @package Annuaire::Services
* @author Aurélien PERONNET <aurelien@tela-botanica.org>
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @copyright Copyright (c) 2010, Tela Botanica (accueil@tela-botanica.org)
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
* @version $Id$
*/
class TestLoginMdp extends JRestService {
 
public function getElement($uid){
if (!isset($uid[0]) || $uid[0] == '' || !isset($uid[1]) || $uid[1] == '') {
$this->envoyer(false);
return;
}
 
$mail_utilisateur = $uid[0];
$pass = $uid[1];
 
// TODO vérifier que le mot de passe est crypté !
 
$id_annuaire = Config::get('annuaire_defaut');
 
$controleur = new AnnuaireControleur();
$id_match_pass = $controleur->comparerIdentifiantMotDePasse($id_annuaire,$mail_utilisateur, $pass, true, true);
 
$this->envoyer($id_match_pass);
}
}
?>
/tags/v1.2-autel/jrest/robots.txt
New file
0,0 → 1,2
User-agent: *
Disallow: /
Property changes:
Added: svn:eol-style
+native
\ No newline at end of property
/tags/v1.2-autel/jrest/.
New file
Property changes:
Added: svn:ignore
+jrest.ini.php