/trunk/widget/modules/cartodepartement/CartoDepartement.php |
---|
New file |
0,0 → 1,128 |
<?php |
class CartoDepartement extends WidgetCommun { |
const SERVICE_CARTO_NOM = 'cartoDepartement'; |
const SERVICE_CARTO_ACTION_DEFAUT = 'cartoDepartement'; |
private $carte = ''; |
private $departement = ''; |
/** |
* Methode appelee par defaut pour executer ce widget |
*/ |
public function executer() { |
$retour = null; |
// recuperer les parametres de l'URL |
$this->extraireParametres(); |
// verifier la disponibilite des services et ressources demandees |
$methode = $this->traiterNomMethodeExecuter($this->carte); |
if (method_exists($this, $methode)) { |
$retour = $this->$methode(); |
} else { |
$this->messages[] = "Ce type de service '$methode' n'est pas disponible."; |
} |
if (is_null($retour)) { |
$info = 'Un problème est survenu : '.print_r($this->messages, true); |
$this->envoyer($info); |
} else { |
$squelette = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'squelettes' . DIRECTORY_SEPARATOR |
. $retour['squelette'] . '.tpl.html'; |
$html = $this->traiterSquelettePhp($squelette, $retour['donnees']); |
$this->envoyer($html); |
} |
} |
public function extraireParametres() { |
extract($this->parametres); |
$this->carte = (isset($carte) ? $carte : self::SERVICE_CARTO_ACTION_DEFAUT); |
$this->departement = (isset($dept) ? $dept : '*'); |
} |
/** |
* Carte par défaut |
*/ |
public function executerCartoDepartement() { |
$widget = null; |
// Création des infos du widget |
$widget['donnees']['url_base'] = sprintf($this->config['chemins']['baseURLAbsoluDyn'], ''); |
$widget['donnees']['url_web_service'] = sprintf($this->config['chemins']['baseURLServicesTpl'], ''); |
$widget['donnees']['url_page_fiche'] = $this->config['carto']["urlPageFiche"]; |
$widget['donnees']['departement'] = $this->departement; |
$widget['squelette'] = 'carto_departement'; |
return $widget; |
} |
private function contruireUrlService() { |
// Création url données json |
$url = sprintf($this->config['chemins']['baseURLServicesTpl'], ''); |
if ($action) { |
$url .= "/$action"; |
$parametres_retenus = array(); |
$parametres_a_tester = array('dept'); |
foreach ($parametres_a_tester as $param) { |
if (isset($this->$param) && $this->$param != '*') { |
$parametres_retenus[$param] = $this->$param; |
} |
} |
if (count($parametres_retenus) > 0) { |
$parametres_url = array(); |
foreach ($parametres_retenus as $cle => $valeur) { |
$parametres_url[] = $cle.'='.$valeur; |
} |
$url .= '?'.implode('&', $parametres_url); |
} |
} |
return $url; |
} |
private function obtenirUrlsLimitesCommunales() { |
$urls = null; |
if (isset($this->departement)) { |
// si on veut afficher les limites départementales on va compter et chercher les noms de fichiers |
$fichiersKml = $this->chercherFichierKml(); |
if (count($fichiersKml) > 0) { |
foreach ($fichiersKml as $kml => $dossier){ |
$url_limites_communales = sprintf($this->config['carto']['limitesCommunaleUrlTpl'], $dossier, $kml); |
$urls[] = $url_limites_communales; |
} |
} |
} |
$urls = json_encode($urls); |
return $urls; |
} |
private function chercherFichierKml(){ |
$fichiers = array(); |
$chemins = explode(',', $this->config['carto']['communesKmzChemin']); |
$departements = explode(',', $this->departement);// plrs code de départements peuvent être demandés séparés par des virgules |
$departements_trouves = array(); |
foreach ($chemins as $dossier_chemin) { |
if ($dossier_ressource = opendir($dossier_chemin)) { |
while ($element = readdir($dossier_ressource)) { |
if ($element != '.' && $element != '..') { |
foreach ($departements as $departement) { |
$nom_dossier = basename($dossier_chemin); |
if (!isset($departements_trouves[$departement]) || $departements_trouves[$departement] == $nom_dossier) { |
$dept_protege = preg_quote($departement); |
if (!is_dir($dossier_chemin.'/'.$element) && preg_match("/^$dept_protege(?:_[0-9]+|)\.kml$/", $element)) { |
$fichiers[$element] = $nom_dossier; |
$departements_trouves[$departement] = $nom_dossier; |
} |
} |
} |
} |
} |
closedir($dossier_ressource); |
} |
} |
return $fichiers; |
} |
} |
?> |
/trunk/widget/modules/cartodepartement/config.defaut.ini |
---|
New file |
0,0 → 1,3 |
[carto] |
urlPageFiche = "http://www.tela-botanica.org/page:herbiers_carto" |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/widget/modules/cartodepartement/squelettes/scripts/carto.js |
---|
New file |
0,0 → 1,241 |
var map = null, |
optionsCoucheOSM = { |
attribution: 'Map data © <a href="http://openstreetmap.org">OpenStreetMap</a> contributors,' |
+ ' <a href="http://creativecommons.org/licenses/by-sa/2.0/">CC-BY-SA</a>', |
maxZoom: 18 |
}, |
optionsCoucheGoogle = { |
attribution: 'Map data ©'+new Date().getFullYear()+' <a href="http://maps.google.com">Google</a>', |
maxZoom: 18 |
}, |
coucheOSM = new L.TileLayer("http://a.tile.openstreetmap.org/{z}/{x}/{y}.png", |
optionsCoucheOSM), |
coucheSatellite = new L.TileLayer("http://mt1.google.com/vt/lyrs=y@218131653&hl=fr&src=app&x={x}&y={y}&z={z}", |
optionsCoucheGoogle), |
optionsCarte = { |
center : new L.LatLng(46, 2), |
zoom : 6, |
layers : [coucheSatellite] |
}; |
var xmlHttpRequest = null, |
nombreCollections = 0, |
collections = new Array(), |
structures = new Array(), |
coucheStructures = new L.FeatureGroup(), |
infoBulle = null, |
chargementEnCours = false; |
$(document).ready(function() { |
initialiserWidget(); |
}); |
$(window).resize(function() { |
dimensionnerCarte(); |
}); |
function initialiserWidget() { |
dimensionnerCarte(); |
initialiserCarte(); |
initialiserPanneauControle(); |
obtenirNombreCollections(); |
chargerStructures(); |
} |
function dimensionnerCarte() { |
$("#map").width($(window).width()); |
$("#map").height($(window).height()); |
} |
function initialiserCarte() { |
map = L.map('map', optionsCarte); |
coucheSatellite.addTo(map); |
coucheStructures.addTo(map); |
map.on('zoomend', function() { |
// controle sur le niveau de zoom uniquement a la fin du placement des structures sur la carte |
if (chargementEnCours) { |
chargementEnCours = false; |
verifierZoom(); |
} |
}); |
} |
function initialiserPanneauControle() { |
var baseMaps = { |
"Plan" : coucheOSM, |
"Satellite" : coucheSatellite |
}; |
var overlayMaps = { |
"Structures" : coucheStructures |
}; |
L.control.layers(baseMaps, overlayMaps).addTo(map); |
} |
function obtenirNombreCollections() { |
if (departement != '2A' && departement != '2B' && departement != '*' && |
(departement.match(/^\d+$/) == null || parseInt(departement) == 0)) { |
alert("La valeur saisie pour le parametre departement (dept) est incorrecte. "+ |
"Est attendue uniquement un nombre entier positif non nul"); |
} else { |
var url = urlWebService+"CoelRecherche/Nombre/*/*/*/*/*/*/"+departement+"/*/*/"; |
xmlHttpRequest = $.getJSON(url).complete(function() { |
recupererValeurNombreCollections(); |
}); |
} |
} |
function recupererValeurNombreCollections() { |
var texte = xmlHttpRequest.responseText; |
if (!estStatutRequeteOK()) { |
alert(texte); |
} else { |
nombreCollections = parseInt(eval("(function(){return " + texte + ";})()")); |
} |
} |
function chargerStructures() { |
if (requeteEnCours()) { |
window.setTimeout('chargerStructures()', 400); |
} else { |
chargementEnCours = true; |
var url = urlWebService+"CoelRecherche/ParDefaut/*/*/*/*/*/*/"+departement+"/*/*/?limit="+nombreCollections; |
xmlHttpRequest = $.getJSON(url).complete(function() { |
traiterLocalisationsJSON(); |
}); |
} |
} |
function requeteEnCours() { |
return (xmlHttpRequest != null && xmlHttpRequest.readyState != 4); |
} |
function estStatutRequeteOK() { |
return ((xmlHttpRequest.status == 200 || xmlHttpRequest.status == 304) |
|| xmlHttpRequest.status == 0); |
} |
function traiterLocalisationsJSON() { |
var texte = xmlHttpRequest.responseText; |
if (!estStatutRequeteOK()) { |
alert(texte); |
} else { |
collections = eval("(function(){return " + texte + ";})()"); |
ordonnerCollectionsParStructures(); |
chargerLocalisations(); |
} |
} |
function ordonnerCollectionsParStructures() { |
for (var index = 0; index < collections.length; index ++) { |
var indexStructure = 0; |
while (indexStructure < structures.length && structures[indexStructure].id != collections[index].cs_id_structure) { |
indexStructure ++; |
} |
if (indexStructure == structures.length) { |
var structure = { |
"id" : collections[index].cs_id_structure, |
"nom" : collections[index].cs_nom, |
"ville" : collections[index].cs_ville, |
"code_postal" : collections[index].cs_code_postal, |
"longitude" : collections[index].cs_longitude, |
"latitude" : collections[index].cs_latitude, |
"collections" : new Array() |
}; |
structures.push(structure); |
} |
var collection = { |
"id" : collections[index].cc_id_collection, |
"nom" : collections[index].cc_nom |
}; |
structures[indexStructure].collections.push(collection); |
} |
} |
function chargerLocalisations() { |
var nombreStructuresAffichees = 0; |
for (var index = 0; index < structures.length; index ++) { |
if ((structures[index].longitude != null && structures[index].longitude != "") |
&& (structures[index].latitude != null && structures[index].latitude != "")) { |
var existeMarqueur = rechercherExistenceMarqueur(structures[index].longitude, structures[index].latitude); |
if (!existeMarqueur) { |
creerMarqueur(structures[index]); |
nombreStructuresAffichees ++; |
} |
} |
} |
if (nombreStructuresAffichees > 0) { |
map.fitBounds(coucheStructures.getBounds()); |
} |
} |
function rechercherExistenceMarqueur(longitude, latitude) { |
var existeMarqueur = false; |
coucheStructures.eachLayer(function(layer) { |
if (layer.getLatLng().lat == latitude && layer.getLatLng().lng == longitude) { |
existeMarqueur = true; |
} |
}); |
return existeMarqueur; |
} |
function creerMarqueur(structure) { |
var latlng = new L.LatLng(structure.latitude, structure.longitude); |
var marqueur = new L.Marker(latlng, { |
title : structure.nom |
}); |
marqueur.on('click', surClickMarqueur); |
coucheStructures.addLayer(marqueur); |
} |
function surClickMarqueur(event) { |
var latlng = event.target.getLatLng(); |
var collections = new Array(); |
var structure = null; |
for (var index = 0; index < structures.length; index ++) { |
if (structures[index].latitude == latlng.lat && structures[index].longitude == latlng.lng) { |
collections = collections.concat(structures[index].collections); |
if (structure == null) { |
structure = structures[index]; |
} |
} |
} |
afficherCollections(structure, collections); |
} |
function afficherCollections(structure, collections) { |
masquerInfoBulle(); |
infoBulle = new L.Popup({maxWidth : 0.25*$(window).width(), maxHeight : 0.35*$(window).height()}); |
var latlng = new L.LatLng(structure.latitude, structure.longitude); |
infoBulle.setLatLng(latlng); |
infoBulle.openOn(map); |
remplirContenuPopup(structure, collections); |
$("a").css("color", "#598000"); |
map.setView(latlng, map.getZoom()); |
} |
function masquerInfoBulle() { |
if (infoBulle != null && map.hasLayer(infoBulle)) { |
map.removeLayer(infoBulle); |
} |
infoBulle = null; |
} |
function remplirContenuPopup(structure, collections) { |
$("#structure").empty(); |
var structureAjout = { |
"id" : structure.id, |
"nom" : structure.nom, |
"ville" : structure.ville, |
"code_postal" : structure.code_postal, |
"collections" : collections |
}; |
$("#tpl-structure").tmpl(structureAjout).appendTo($("#structure")); |
infoBulle.setContent($("#structure").html()); |
} |
function verifierZoom() { |
if(map.getZoom() > 13) { |
map.setZoom(13); |
} |
} |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/widget/modules/cartodepartement/squelettes/css/carto.css |
---|
New file |
0,0 → 1,34 |
@CHARSET "UTF-8"; |
body { |
margin: 0px; |
padding: 0px; |
} |
#map { |
position: relative; |
} |
ul { |
padding-left: 10px; |
margin-top: 5px; |
margin-bottom: 5px; |
} |
ul li { |
background: url("../images/petitCarreContour.jpg") no-repeat scroll 10px 6px transparent; |
line-height: 18px; |
list-style: none outside none; |
padding-left: 25px; |
} |
a { |
text-decoration : none; |
border-bottom: 1px dotted #95AE5D; |
color: #598000; |
margin: 0; |
} |
.popup-simple-text { |
font-size: 1.15em; |
} |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/widget/modules/cartodepartement/squelettes/carto_departement.tpl.html |
---|
New file |
0,0 → 1,61 |
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"> |
<html xmlns="http://www.w3.org/1999/xhtml"> |
<head> |
<meta http-equiv="content-type" content="text/html; charset=UTF-8"/> |
<meta http-equiv="Content-style-type" content="text/css" /> |
<meta http-equiv="Content-script-type" content="text/javascript" /> |
<meta http-equiv="Content-language" content="fr" /> |
<title>Localisation des collections d'herbiers</title> |
<link rel="icon" type="image/png" href="http://www.tela-botanica.org/sites/commun/generique/images/favicones/tela_botanica.png" /> |
<link rel="shortcut icon" type="image/x-icon" href="http://www.tela-botanica.org/sites/commun/generique/images/favicones/tela_botanica.ico" /> |
<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.5/leaflet.css" /> |
<!--[if lte IE 8]> |
<link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.5/leaflet.ie.css" /> |
<![endif]--> |
<link rel="stylesheet" href="<?=$url_base?>modules/cartodepartement/squelettes/css/carto.css" /> |
<script type="text/javascript" src="http://cdn.leafletjs.com/leaflet-0.5/leaflet.js"></script> |
<script type="text/javascript" src="http://maps.google.com/maps/api/js?v=3.5&sensor=true&language=fr&region=FR"></script> |
<script type="text/javascript" src="http://www.tela-botanica.org/commun/jquery/1.6.2/jquery-1.6.2.min.js"></script> |
<script type="text/javascript" src="http://www.tela-botanica.org/commun/jquery/jquery-ui/1.8.15/js/jquery-ui-1.8.15.custom.min.js"></script> |
<script type="text/javascript" src="http://ajax.aspnetcdn.com/ajax/jquery.templates/beta1/jquery.tmpl.min.js"></script> |
<script type="text/javascript" src="<?=$url_base?>modules/cartodepartement/squelettes/scripts/carto.js"></script> |
<script type="text/javascript"> |
//<![CDATA[ |
var departement = '<?= $departement ?>'; |
var urlWebService = '<?= $url_web_service ?>'; |
//]]> |
</script> |
</head> |
<body> |
<div id="map"></div> |
<!-- Squelette du contenu de la popup --> |
<script id="tpl-structure" type="text/x-jquery-tmpl"> |
<div id="description-structure"> |
<h3 align="center"> |
<a href="<?=$url_page_fiche?>?module=FicheStructure&id=${id}">${nom}</a> |
</h3> |
<div class="popup-simple-text">Situé dans ${ville} (${code_postal})</div> |
<hr /> |
<div id="collections"> |
{{if collections.length > 0}} |
<div class="popup-simple-text">Collections présentes :</div> |
<ul> |
{{each(index, collection) collections}} |
<li> |
<a href="<?=$url_page_fiche?>?module=FicheCollection&id=${collection.id}">${collection.nom}</a> |
</li> |
{{/each}} |
</ul> |
{{else}} |
<div class="popup-simple-text">Aucune Collection d'herbiers recensée à ce jour</div> |
{{/if}} |
</div> |
</div> |
</script> |
<div id="structure" style="display:none"></div> |
</body> |
</html> |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/widget/modules/cartodepartement/squelettes/images/petitCarreContour.jpg |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = image/jpeg |
/trunk/widget/modules/cartodepartement/squelettes/images/petitCarreContour.jpg |
---|
New file |
Property changes: |
Added: svn:mime-type |
+image/jpeg |
\ No newline at end of property |
/trunk/widget/modules/cartodepartement/config.ini |
---|
New file |
0,0 → 1,3 |
[carto] |
urlPageFiche = "http://www.tela-botanica.org/page:herbiers_carto" |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/widget/Widget.php |
---|
New file |
0,0 → 1,160 |
<?php |
// In : utf8 url_encoded (get et post) |
// Out : utf8 |
/** |
* La classe Widget analyser l'url et chage le widget correspondant. |
* Format d'url : |
* /widget/nom_du_widget?parametres1=ma_valeur1¶metre2=ma_valeur2 |
* Les widget sont dans des dossiers en minuscule correspondant au nom de la classe du widget. |
* Exemple : /widget/carto avec la classe Carto.php dans le dossier carto. |
* |
* |
* @author jpm |
* |
*/ |
class Widget { |
/** Les paramètres de configuration extrait du fichier .ini */ |
private static $config; |
/** Le nom du widget demandé. */ |
private $widget = null; |
/** Les chemins où l'autoload doit chercher des classes. */ |
private static $autoload_chemins = array(); |
/** Les paramètres de l'url $_GET nettoyés. */ |
private $parametres = null; |
/** |
* Constructeur. |
* Parse le fichier de configuraion "widget.ini" et parse l'url à la recherche du widget demandé. |
* @param str iniFile Configuration file to use |
*/ |
public function __construct($fichier_ini = 'widget.ini.php') { |
// Chargement de la configuration |
self::$config = parse_ini_file($fichier_ini, TRUE); |
// Paramêtres de config dynamiques |
self::$config['chemins']['baseURLAbsoluDyn'] = 'http://'.$_SERVER['SERVER_NAME'].self::$config['chemins']['baseURL'].'%s'; |
// Gestion de la mémoire maximum allouée aux services |
ini_set('memory_limit', self::$config['parametres']['limiteMemoire']); |
// Réglages de PHP |
setlocale(LC_ALL, self::$config['parametres']['locale']); |
date_default_timezone_set(self::$config['parametres']['fuseauHoraire']); |
// Gestion des erreurs |
error_reporting(self::$config['parametres']['erreurNiveau']); |
if (isset($_SERVER['REQUEST_URI']) && isset($_SERVER['QUERY_STRING'])) { |
$url_morceaux = $this->parserUrl(); |
if (isset($url_morceaux[0])) { |
$this->widget = $url_morceaux[0]; |
self::$config['chemins']['widgetCourantDossier'] = self::$config['chemins']['widgetsDossier'].strtolower($this->widget).DIRECTORY_SEPARATOR; |
$this->chargerWidgetConfig(); |
} |
// Chargement des chemins pour l'autoload |
$this->chargerCheminAutoload(); |
// Enregistrement de la méthode gérant l'autoload des classes |
spl_autoload_register(array('Widget', 'chargerClasse')); |
// Nettoyage du $_GET (sécurité) |
$this->collecterParametres(); |
} else { |
$e = 'Les widget nécessite les variables serveurs suivantes pour fonctionner : REQUEST_URI et QUERY_STRING.'; |
trigger_error($e, E_USER_ERROR); |
} |
} |
private function parserUrl() { |
if (strlen($_SERVER['QUERY_STRING']) == 0) { |
$len = strlen($_SERVER['REQUEST_URI']); |
} else { |
$len = -(strlen($_SERVER['QUERY_STRING']) + 1); |
} |
$url = substr($_SERVER['REQUEST_URI'], strlen(self::$config['chemins']['baseURL']), $len); |
$url_morceaux = explode('/', $url); |
return $url_morceaux; |
} |
private function collecterParametres() { |
if (isset($_GET) && $_GET != '') { |
$this->nettoyerGet(); |
$this->parametres = $_GET; |
} |
} |
private function nettoyerGet() { |
foreach ($_GET as $cle => $valeur) { |
$verifier = array('NULL', "\n", "\r", "\\", '"', "\x00", "\x1a", ';'); |
$_GET[$cle] = strip_tags(str_replace($verifier, '', $valeur)); |
} |
} |
private function chargerCheminAutoload() { |
$chemins_communs = explode(';', self::$config['chemins']['autoload']); |
$chemins_communs = array_map('trim', $chemins_communs); |
array_unshift($chemins_communs, ''); |
$chemins_widget = array(); |
if (isset(self::$config[$this->widget]['autoload'])) { |
$chemins_widget = explode(';', self::$config[$this->widget]['autoload']); |
foreach ($chemins_widget as $cle => $chemin) { |
$chemins_widget[$cle] = self::$config['chemins']['widgetCourantDossier'].trim($chemin); |
} |
} |
self::$autoload_chemins = array_merge($chemins_communs, $chemins_widget); |
} |
/** |
* La méthode chargerClasse() 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. |
*/ |
public static function chargerClasse($classe) { |
if (class_exists($classe)) { |
return null; |
} |
foreach (self::$autoload_chemins as $chemin) { |
$chemin = $chemin.$classe.'.php'; |
if (file_exists($chemin)) { |
require_once $chemin; |
} |
} |
} |
/** |
* Execute le widget. |
*/ |
function executer() { |
if (!is_null($this->widget)) { |
$classe_widget = ucfirst($this->widget); |
$fichier_widget = self::$config['chemins']['widgetCourantDossier'].$classe_widget.'.php'; |
if (file_exists($fichier_widget)) { |
include_once $fichier_widget; |
if (class_exists($classe_widget)) { |
$widget = new $classe_widget(self::$config, $this->parametres); |
$widget->executer(); |
} |
} |
} |
} |
/** |
* Charge le fichier de config spécifique du wiget et fusionne la config avec celle partagés par l'ensemble des widgets. |
*/ |
private function chargerWidgetConfig() { |
$widget_config_ini_fichier = self::$config['chemins']['widgetCourantDossier'].'config.ini'; |
if (file_exists($widget_config_ini_fichier)) { |
$widget_config = parse_ini_file($widget_config_ini_fichier, TRUE); |
self::$config = array_merge(self::$config, $widget_config); |
} |
} |
} |
?> |
/trunk/widget/.htaccess |
---|
New file |
0,0 → 1,13 |
<files *.ini> |
order deny,allow |
deny from all |
</files> |
#AddHandler x-httpd-php5 .php |
AddDefaultCharset UTF-8 |
RewriteEngine On |
# Redirections générale vers le fichier principal de Widget. |
RewriteCond %{REQUEST_FILENAME} !-d |
RewriteCond %{REQUEST_FILENAME} !-f |
RewriteRule ^.*$ index.php/ |
/trunk/widget/bibliotheque/WidgetCommun.php |
---|
New file |
0,0 → 1,431 |
<?php |
abstract class WidgetCommun { |
protected $config = null; |
protected $parametres = null; |
protected $messages = array(); |
protected $debug = array(); |
public function __construct($config, $parametres) { |
$this->config = $config; |
$this->parserFichierIni($config['chemins']['widgetCourantDossier'].'config.ini'); |
$this->parametres = $parametres; |
} |
/** |
* Parse le fichier ini donné en paramètre |
* @param string $fichier_ini nom du fichier ini à parser |
* @return boolean true si le fichier ini a été trouvé. |
*/ |
private function parserFichierIni($fichier_ini) { |
$retour = false; |
if (file_exists($fichier_ini)) { |
$ini = parse_ini_file($fichier_ini, true); |
$this->fusionner($ini); |
$retour = true; |
} |
return $retour; |
} |
/** |
* fusionne un tableau de paramètres avec le tableau de config global |
* @param array $ini le tableau à fusionner |
*/ |
private function fusionner(array $ini) { |
$this->config = array_merge($this->config, $ini); |
} |
protected function traiterNomMethodeExecuter($nom) { |
$methode = 'executer'; |
$methode .= str_replace(' ', '', ucwords(str_replace('-', ' ', strtolower($nom)))); |
return $methode; |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// GESTION des CLASSES CHARGÉES à la DEMANDE |
protected function getDao() { |
if (! isset($this->dao)) { |
$this->dao = new Dao(); |
} |
return $this->dao; |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// GESTION DE MÉTHODES COMMUNES ENTRE LES SERVICES |
protected function getUrlImage($id, $format = 'L') { |
$url_tpl = $this->config['chemins']['celImgUrlTpl']; |
$id = sprintf('%09s', $id).$format; |
$url = sprintf($url_tpl, $id); |
return $url; |
} |
protected function encoderMotCle($mot_cle) { |
return md5(mb_strtolower($mot_cle)); |
} |
private function protegerMotsCles($mots_cles, $type) { |
$separateur = ($type == self::TYPE_IMG) ? ',' : ';' ; |
$mots_cles_a_proteger = explode($separateur,rtrim(trim($mots_cles), $separateur)); |
foreach ($mots_cles_a_proteger as $mot) { |
$mots_cles_proteges[] = $this->bdd->quote($mot); |
} |
$mots_cles = implode(',', $mots_cles_proteges); |
return $mots_cles; |
} |
protected function tronquerCourriel($courriel) { |
$courriel = preg_replace('/[^@]+$/i', '...', $courriel); |
return $courriel; |
} |
protected function nettoyerTableau($tableau) { |
foreach ($tableau as $cle => $valeur) { |
if (is_array($valeur)) { |
$valeur = $this->nettoyerTableau($valeur); |
} else { |
$valeur = $this->nettoyerTexte($valeur); |
} |
$tableau[$cle] = $valeur; |
} |
return $tableau; |
} |
protected function nettoyerTexte($txt) { |
$txt = preg_replace('/&(?!([a-z]+|#[0-9]+|#x[0-9][a-f]+);)/i', '&', $txt); |
$txt = preg_replace('/^(?:000null|null)$/i', '', $txt); |
return $txt; |
} |
protected function etreVide($valeur) { |
$vide = false; |
if ($valeur == '' || $valeur == 'null'|| $valeur == '000null' || $valeur == '0') { |
$vide = true; |
} |
return $vide; |
} |
protected function formaterDate($date_heure_mysql, $format = '%A %d %B %Y à %H:%M') { |
$date_formatee = ''; |
if (!$this->etreVide($date_heure_mysql)) { |
$timestamp = $this->convertirDateHeureMysqlEnTimestamp($date_heure_mysql); |
$date_formatee = strftime($format, $timestamp); |
} |
return $date_formatee; |
} |
protected function convertirDateHeureMysqlEnTimestamp($date_heure_mysql){ |
$val = explode(' ', $date_heure_mysql); |
$date = explode('-', $val[0]); |
$heure = explode(':', $val[1]); |
return mktime((int) $heure[0], (int) $heure[1], (int) $heure[2], (int) $date[1], (int) $date[2], (int) $date[0]); |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// GESTION DE L'IDENTIFICATION et des UTILISATEURS |
protected function getAuthIdentifiant() { |
$id = (isset($_SERVER['PHP_AUTH_USER'])) ? $_SERVER['PHP_AUTH_USER'] : null; |
return $id; |
} |
protected function getAuthMotDePasse() { |
$mdp = (isset($_SERVER['PHP_AUTH_PW'])) ? $_SERVER['PHP_AUTH_PW'] : null; |
return $mdp; |
} |
protected function authentifierAdmin() { |
$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
$message_echec = "Accès limité aux administrateurs du CEL.\n". |
"Votre tentative d'identification a échoué.\n". |
"Actualiser la page pour essayer à nouveau si vous êtes bien inscrit comme administrateur."; |
return $this->authentifier($message_accueil, $message_echec, 'Admin'); |
} |
protected function authentifierUtilisateur() { |
$message_accueil = "Veuillez vous identifier avec votre compte Tela Botanica."; |
$message_echec = "Accès limité aux utilisateur du CEL.\n". |
"Inscrivez vous http://www.tela-botanica.org/page:inscription pour le devenir.\n". |
"Votre tentative d'identification a échoué.\n". |
"Actualiser la page pour essayer à nouveau si vous êtes déjà inscrit ou contacter 'accueil@tela-botanica.org'."; |
return $this->authentifier($message_accueil, $message_echec, 'Utilisateur'); |
} |
private function authentifier($message_accueil, $message_echec, $type) { |
$id = $this->getAuthIdentifiant(); |
if (!isset($id)) { |
$this->envoyerAuth($message_accueil, $message_echec); |
} else { |
if ($type == 'Utilisateur' && $this->getAuthMotDePasse() == 'debug') { |
$autorisation = true; |
} else { |
$methodeAutorisation = "etre{$type}Autorise"; |
$autorisation = $this->$methodeAutorisation(); |
} |
if ($autorisation == false) { |
$this->envoyerAuth($message_accueil, $message_echec); |
} |
} |
return true; |
} |
protected function etreUtilisateurAutorise() { |
$identifiant = $this->getAuthIdentifiant(); |
$mdp = md5($this->getAuthMotDePasse()); |
$url = sprintf($this->config['authentification']['serviceUrlTpl'], $identifiant, $mdp); |
$json = $this->getDao()->consulter($url); |
$existe = json_decode($json); |
$autorisation = (isset($existe) && $existe) ? true :false; |
return $autorisation; |
} |
protected function etreAdminAutorise($identifiant) { |
$identifiant = $this->getAuthIdentifiant(); |
$autorisation = ($this->etreUtilisateurAutorise() && $this->etreAdminCel($identifiant)) ? true : false; |
return $autorisation; |
} |
protected function etreAdminCel($courriel) { |
$admins = $this->config['authentification']['administrateurs']; |
$courriels_autorises = explode(',', $admins); |
$autorisation = (in_array($courriel, $courriels_autorises)) ? true : false ; |
return $autorisation; |
} |
/** |
* Prend en paramêtre un tableau de courriels et retourne après avoir intérogé un service we de l'annuaire |
* une tableau avec en clé le courriel et en valeur, un tableau associatif : |
* - nom : le nom de l'utilisateur |
* - prenom : le prénom de l'utilisateur. |
* @param array $courriels un tableau de courriels pour lesquels il faut recherche le prénom et nom. |
*/ |
protected function recupererUtilisateursNomPrenom(Array $courriels) { |
// Récupération des données au format Json |
$service = "utilisateur/prenom-nom-par-courriel/".implode(',', $courriels); |
$url = sprintf($this->config['chemins']['baseURLServicesAnnuaireTpl'], $service); |
$json = $this->getDao()->consulter($url); |
return (array) json_decode($json); |
} |
protected function recupererUtilisateursIdentite(Array $courriels) { |
// Récupération des données au format Json |
$service = "utilisateur/identite-par-courriel/".implode(',', $courriels); |
$url = sprintf($this->config['chemins']['baseURLServicesAnnuaireTpl'], $service); |
$json = $this->getDao()->consulter($url); |
$utilisateurs = json_decode($json); |
foreach ($courriels as $courriel) { |
$info = array('id' => null, 'intitule' => ''); |
if (isset($utilisateurs->$courriel)) { |
$info['intitule'] = $utilisateurs->$courriel->intitule; |
$info['id'] = $utilisateurs->$courriel->id; |
} else { |
$info['intitule'] = $this->tronquerCourriel($courriel); |
} |
$noms[$courriel] = $info; |
} |
return $noms; |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// GESTION de l'ENVOIE au NAVIGATEUR |
protected function envoyerJsonp($donnees = null, $encodage = 'utf-8') { |
$contenu = $_GET['callback'].'('.json_encode($donnees).');'; |
$this->envoyer($contenu, 'text/html', $encodage); |
} |
protected function envoyer($donnees = null, $mime = 'text/html', $encodage = 'utf-8') { |
// 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'; |
$sortie = '<html>'. |
'<head><title>Messages</title></head>'. |
'<body><pre>'.implode("\n", $this->messages).'</pre><body>'. |
'</html>'; |
} else { |
$sortie = $donnees; |
if (is_null($donnees)) { |
$sortie = 'OK'; |
} |
} |
// Gestion de l'envoie du déboguage |
$this->envoyerDebogage(); |
// Envoie sur la sortie standard |
$this->envoyerContenu($encodage, $mime, $sortie); |
} |
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_r($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 DES SQUELETTES (PHP, TXT...) |
/** |
* Méthode prenant en paramètre un tableau associatif, les clés seront recherchées dans le texte pour être |
* remplacer par la valeur. Dans le texte, les clés devront être entre accolades : {} |
* |
* @param String $txt le texte où chercher les motifs. |
* @param Array $donnees un tableau associatif contenant les motifs à remplacer. |
* |
* @return String le texte avec les motifs remplacer par les valeurs du tableau. |
*/ |
protected static function traiterSqueletteTxt($txt, Array $donnees = array()) { |
$motifs = array(); |
$valeurs = array(); |
foreach ($donnees as $cle => $valeur) { |
if (strpos($cle, '{') === false && strpos($cle, '}') === false) { |
$motifs = '{'.$cle.'}'; |
$valeurs = $valeur; |
} |
} |
$txt = str_replace($motifs, $valeurs, $txt); |
return $txt; |
} |
/** |
* 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. |
*/ |
protected 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; |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// UTILITAIRES |
/** |
* Permet de trier un tableau multi-dimenssionnel en gardant l'ordre des clés. |
* |
* @param Array $array le tableau à trier |
* @param Array $cols tableau indiquant en clé la colonne à trier et en valeur l'ordre avec SORT_ASC ou SORT_DESC |
* @author cagret at gmail dot com |
* @see http://fr.php.net/manual/fr/function.array-multisort.php Post du 21-Jun-2009 12:38 |
*/ |
public static function trierTableauMd($array, $cols) { |
$colarr = array(); |
foreach ($cols as $col => $order) { |
$colarr[$col] = array(); |
foreach ($array as $k => $row) { |
$colarr[$col]['_'.$k] = strtolower(self::supprimerAccents($row[$col])); |
} |
} |
$params = array(); |
foreach ($cols as $col => $order) { |
$params[] =& $colarr[$col]; |
$params = array_merge($params, (array)$order); |
} |
call_user_func_array('array_multisort', $params); |
$ret = array(); |
$keys = array(); |
$first = true; |
foreach ($colarr as $col => $arr) { |
foreach ($arr as $k => $v) { |
if ($first) { |
$keys[$k] = substr($k,1); |
} |
$k = $keys[$k]; |
if (!isset($ret[$k])) { |
$ret[$k] = $array[$k]; |
} |
$ret[$k][$col] = $array[$k][$col]; |
} |
$first = false; |
} |
return $ret; |
} |
private static function supprimerAccents($str, $charset='utf-8') |
{ |
$str = htmlentities($str, ENT_NOQUOTES, $charset); |
$str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str); |
$str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); // pour les ligatures e.g. 'œ' |
$str = preg_replace('#&[^;]+;#', '', $str); // supprime les autres caractères |
return $str; |
} |
} |
?> |
/trunk/widget/bibliotheque/Dao.php |
---|
New file |
0,0 → 1,155 |
<?php |
// declare(encoding='UTF-8'); |
/** |
* Classe modèle spécifique à l'application, donc d'accés au données, elle ne devrait pas être appelée de l'extérieur. |
* |
* @category php5 |
* @package Widget |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @copyright 2010 Tela-Botanica |
* @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 SVN: $Id$ |
*/ |
class Dao { |
const HTTP_URL_REQUETE_SEPARATEUR = '&'; |
const HTTP_URL_REQUETE_CLE_VALEUR_SEPARATEUR = '='; |
private $http_methodes = array('GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'OPTIONS', 'CONNECT', 'TRACE'); |
protected $parametres = null; |
private $url = null; |
private $reponse_entetes = null; |
//+----------------------------------------------------------------------------------------------------------------+ |
// ACCESSEURS |
public function getReponseEntetes($cle) { |
return $this->reponse_entetes; |
} |
public function getParametre($cle) { |
$valeur = (isset($this->parametres[$cle])) ? $this->parametres[$cle] : null; |
return $valeur; |
} |
public function ajouterParametre($cle, $valeur) { |
$this->parametres[$cle] = $valeur; |
} |
public function supprimerParametre($cle) { |
unset($this->parametres[$cle]); |
} |
public function nettoyerParametres() { |
$this->parametres = null; |
} |
//+----------------------------------------------------------------------------------------------------------------+ |
// MÉTHODES |
public function consulter($url) { |
$retour = $this->envoyerRequete($url, 'GET'); |
return $retour; |
} |
public function ajouter($url, Array $donnees) { |
$retour = $this->envoyerRequete($url, 'PUT', $donnees); |
return $retour; |
} |
public function modifier($url, Array $donnees) { |
$retour = $this->envoyerRequete($url, 'POST', $donnees); |
return $retour; |
} |
public function supprimer($url) { |
$retour = $this->envoyerRequete($url, 'DELETE'); |
return $retour; |
} |
public function envoyerRequete($url, $mode, Array $donnees = array()) { |
$this->url = $url; |
$contenu = false; |
if (! in_array($mode, $this->http_methodes)) { |
$e = "Le mode de requête '$mode' n'est pas accepté!"; |
trigger_error($e, E_USER_WARNING); |
} else { |
if ($mode == 'GET') { |
$this->traiterUrlParametres(); |
} |
$contexte = stream_context_create(array( |
'http' => array( |
'method' => $mode, |
'header' => "Content-type: application/x-www-form-urlencoded\r\n", |
'content' => http_build_query($donnees, null, self::HTTP_URL_REQUETE_SEPARATEUR)))); |
$flux = @fopen($this->url, 'r', false, $contexte); |
if (!$flux) { |
$this->reponse_entetes = $http_response_header; |
$e = "L'ouverture de l'url '{$this->url}' par la méthode HTTP '$mode' a échoué!"; |
trigger_error($e, E_USER_WARNING); |
} else { |
// Informations sur les en-têtes et métadonnées du flux |
$this->reponse_entetes = stream_get_meta_data($flux); |
// Contenu actuel de $url |
$contenu = stream_get_contents($flux); |
fclose($flux); |
} |
$this->traiterEntete(); |
} |
$this->reinitialiser(); |
return $contenu; |
} |
private function traiterUrlParametres() { |
$parametres = array(); |
if (count($this->parametres) > 0) { |
foreach ($this->parametres as $cle => $valeur) { |
$cle = rawurlencode($cle); |
$valeur = rawurlencode($valeur); |
$parametres[] = $cle.self::HTTP_URL_REQUETE_CLE_VALEUR_SEPARATEUR.$valeur; |
} |
$url_parametres = implode(self::HTTP_URL_REQUETE_SEPARATEUR, $parametres); |
$this->url = $this->url.'?'.$url_parametres; |
} |
} |
private function traiterEntete() { |
$infos = $this->analyserEntete(); |
$this->traiterEnteteDebogage($infos); |
} |
private function analyserEntete() { |
$entetes = $this->reponse_entetes; |
$infos = array('date' => null, 'uri' => $this->url, 'debogages' => null); |
if (isset($entetes['wrapper_data'])) { |
$entetes = $entetes['wrapper_data']; |
} |
foreach ($entetes as $entete) { |
if (preg_match('/^X_REST_DEBOGAGE_MESSAGES: (.+)$/', $entete, $match)) { |
$infos['debogages'] = json_decode($match[1]); |
} |
if (preg_match('/^Date: .+ ([012][0-9]:[012345][0-9]:[012345][0-9]) .*$/', $entete, $match)) { |
$infos['date'] = $match[1]; |
} |
} |
return $infos; |
} |
private function traiterEnteteDebogage($entetes_analyses) { |
if (isset($entetes['debogages'])) { |
$date = $entetes['date']; |
$uri = $entetes['uri']; |
$debogages = $entetes['debogages']; |
foreach ($debogages as $debogage) { |
$e = "DEBOGAGE : $date - $uri :\n$debogage"; |
trigger_error($e, E_USER_NOTICE); |
} |
} |
} |
private function reinitialiser() { |
$this->nettoyerParametres(); |
} |
} |
/trunk/widget/index.php |
---|
New file |
0,0 → 1,5 |
<?php |
require 'Widget.php'; |
$widget = new Widget(); |
$widget->executer(); |
?> |
/trunk/widget/widget.ini.defaut.php |
---|
New file |
0,0 → 1,47 |
;<?/* |
[parametres] |
;Memoire maxi pour les services : 128Mo = 134217728 ; 256Mo = 268435456 ; 512Mo = 536870912 ; 1Go = 1073741824 |
limiteMemoire = "512M" |
; Niveau d'erreur PHP |
erreurNiveau = 30719 ; E_ALL = 30719 |
; Séparateur d'url en entrée |
argSeparatorInput = "&" |
; Indication de la locale (setLocale(LC_ALL, ?)) pour les classes appelées par Widget.php |
locale = "fr_FR.UTF-8" |
; Indication du fuseau horraire par défaut date_default_timezone_set(?)pour les classes appelées par Widget.php |
fuseauHoraire = "Europe/Paris" |
[chemins] |
; Chemins à utiliser dans la méthode autoload des widgets |
autoload = "bibliotheque/" |
; Dossier contenant les widgets |
widgetsDossier = "modules/" |
; Dossier contenant le widget demandé construit dynamiquement dans le fichier Widget.php |
widgetCourantDossier = "" |
; Dossier contenant les fichiers des bibliothèques tierces |
bibliothequeDossier = "bibliotheque/" |
; Base de l'url servant à appeler les widgets |
baseURL = "/widget:cel:" |
; URL de base absolue des Widgets du CEL construit dynamiquement dans le fichier WidgetCommun.php |
baseURLAbsoluDyn = "" |
; URL des services web du CEL sous forme de template à utiliser avec sprintf |
baseURLServicesCelTpl = "http://www.tela-botanica.org/service:cel:%s" |
; URL des services web du CEL sous forme de template à utiliser avec sprintf |
baseURLServicesAnnuaireTpl = "http://www.tela-botanica.org/service:annuaire:%s" |
; Squelette d'Url permettant d'afficher une image du CEL (remplace %s par l'id de l'image sans underscore) |
celImgUrlTpl = "http://www.tela-botanica.org/appli:cel-img:%s.jpg" |
; Squelette d'URL pour les services web d'eFlore. |
baseURLServicesEfloreTpl = "http://www.tela-botanica.org/service:eflore:%s/%s/%s" |
; Dossier de stockage temporaire des images (ATTENTION : mettre le slash à la fin) |
imagesTempDossier = "/home/telabotap/www/eflore/cel/cache/images/" |
; Squelette d'URL pour les images temporaires sotckées sur le serveur |
imagesTempUrlTpl = "http://www.tela-botanica.org/eflore/cel/cache/images/%s" |
; Url du service fournissant des infos sur les noms à partir d'un num tax |
infosTaxonUrl = "http://www.tela-botanica.org/service:eflore:0.1/bdtfx/noms/%s" |
; Url du service wiki fournissant les pages d'aide |
aideWikiniUrl = 'http://www.tela-botanica.org/wikini/eflore/api/rest/0.5/pages/{page}?txt.format=text/html'; |
[authentification] |
serviceUrlTpl = "http://www.tela-botanica.org/service:annuaire:TestLoginMdp/%s/%s" |
administrateurs = aurelien@tela-botanica.org,david.delon@clapas.net,jpm@tela-botanica.org,marie@tela-botanica.org |
;*/?> |
/trunk/widget/widget.ini.php |
---|
New file |
0,0 → 1,47 |
;<?/* |
[parametres] |
;Memoire maxi pour les services : 128Mo = 134217728 ; 256Mo = 268435456 ; 512Mo = 536870912 ; 1Go = 1073741824 |
limiteMemoire = "512M" |
; Niveau d'erreur PHP |
erreurNiveau = 30719 ; E_ALL = 30719 |
; Séparateur d'url en entrée |
argSeparatorInput = "&" |
; Indication de la locale (setLocale(LC_ALL, ?)) pour les classes appelées par Widget.php |
locale = "fr_FR.UTF-8" |
; Indication du fuseau horraire par défaut date_default_timezone_set(?)pour les classes appelées par Widget.php |
fuseauHoraire = "Europe/Paris" |
[chemins] |
; Chemins à utiliser dans la méthode autoload des widgets |
autoload = "bibliotheque/" |
; Dossier contenant les widgets |
widgetsDossier = "/home/alex/web/coel/widget/modules/" |
; Dossier contenant le widget demandé construit dynamiquement dans le fichier Widget.php |
widgetCourantDossier = "" |
; Dossier contenant les fichiers des bibliothèques tierces |
bibliothequeDossier = "bibliotheque/" |
; Base de l'url servant à appeler les widgets |
baseURL = "/coel/widget/" |
; URL de base absolue des Widgets du CEL construit dynamiquement dans le fichier WidgetCommun.php |
baseURLAbsoluDyn = "http://localhost/coel/widget/" |
; URL des services web sous forme de template à utiliser avec sprintf |
baseURLServicesTpl = "http://localhost/coel/jrest/" |
; URL des services web du CEL sous forme de template à utiliser avec sprintf |
baseURLServicesAnnuaireTpl = "http://www.tela-botanica.org/service:annuaire:%s" |
; Squelette d'Url permettant d'afficher une image du CEL (remplace %s par l'id de l'image sans underscore) |
celImgUrlTpl = "http://www.tela-botanica.org/appli:cel-img:%s.jpg" |
; Squelette d'URL pour les services web d'eFlore. |
baseURLServicesEfloreTpl = "http://www.tela-botanica.org/service:eflore:%s/%s/%s" |
; Dossier de stockage temporaire des images (ATTENTION : mettre le slash à la fin) |
imagesTempDossier = "/home/telabotap/www/eflore/cel/cache/images/" |
; Squelette d'URL pour les images temporaires sotckées sur le serveur |
imagesTempUrlTpl = "http://www.tela-botanica.org/eflore/cel/cache/images/%s" |
; Url du service fournissant des infos sur les noms à partir d'un num tax |
infosTaxonUrl = "http://www.tela-botanica.org/service:eflore:0.1/bdtfx/noms/%s" |
; Url du service wiki fournissant les pages d'aide |
aideWikiniUrl = 'http://www.tela-botanica.org/wikini/eflore/api/rest/0.5/pages/{page}?txt.format=text/html'; |
[authentification] |
serviceUrlTpl = "http://www.tela-botanica.org/service:annuaire:TestLoginMdp/%s/%s" |
administrateurs = aurelien@tela-botanica.org,david.delon@clapas.net,jpm@tela-botanica.org,marie@tela-botanica.org |
;*/?> |
/trunk/jrest/services/CoelRecherche.php |
---|
52,7 → 52,7 |
// Construction de la requête |
$requete = (($this->distinct) ? 'SELECT DISTINCT' : 'SELECT').' cs_id_structure, cs_ville, cs_nom, '. |
' cc_id_collection, cc_nom '. |
'cs_code_postal, cs_latitude, cs_longitude, cc_id_collection, cc_nom '. |
$this->construireFromEtWhere($p). |
'ORDER BY '.((!is_null($this->orderby)) ? $this->orderby : 'cs_ville ASC, cs_nom ASC, cc_nom ASC').' '. |
"LIMIT $this->start, $this->limit "; |
/trunk/scripts/framework.php |
---|
New file |
0,0 → 1,6 |
<?php |
// Inclusion du Framework |
// Renomer ce fichier en "framework.php" |
// Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
require_once '/home/alex/web/framework/Framework.php'; |
?> |
/trunk/scripts/modules/communes/communes.ini |
---|
New file |
0,0 → 1,5 |
[tables] |
bdd_nom_coel = "test" |
table_structures_coel = "coel_structure" |
bdd_nom_floradata = "tb_cel" |
table_communes = "cel_zones_geo" |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/scripts/modules/communes/Communes.php |
---|
New file |
0,0 → 1,252 |
<?php |
/** |
* Exemple lancement: |
* /opt/lampp/bin/php -d memory_limit=3500M cli.php communes -a majCoordonnees |
*/ |
class Communes extends Script { |
private $bdd = null; |
private $structures = array(); |
private $communes = array(); |
private $nonTrouvees = array(); |
public function __construct($script_nom, $parametres) { |
parent::__construct($script_nom, $parametres); |
$this->bdd = new Bdd(); |
} |
public function executer() { |
try { |
$this->initialiserScript(); |
$cmd = $this->getParametre('a'); |
switch ($cmd) { |
case "majCoordonnees" : |
$this->mettreAJourCoordonneesCommunes(); break; |
default : |
$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd)); |
} |
} catch (Exception $erreur) { |
$this->traiterErreur($erreur->getMessage()); |
} |
} |
private function initialiserScript() { |
$fichierIni = $this->getScriptChemin().'communes.ini'; |
if (file_exists($fichierIni)) { |
Config::charger($fichierIni); |
} else { |
$erreur = "Veuillez configurer le projet en créant le fichier 'communes.ini' ". |
"dans le dossier du module de script du projet à partir du fichier 'config.defaut.ini'."; |
throw new Exception($erreur); |
} |
} |
private function mettreAJourCoordonneesCommunes() { |
$this->recupererStructures(); |
$departements = $this->determinerDepartementsStructures(); |
$this->recupererCommunes($departements); |
$this->chercherCoordonneesVillesStructures(); |
$this->mettreAJourDonneesStructures(); |
$this->afficherResultatScript(); |
} |
private function recupererStructures() { |
$this->bdd->requeter("USE ".Config::get("bdd_nom_coel")); |
$requete = |
"SELECT cs_id_structure, cs_nom, cs_code_postal, cs_ville ". |
"FROM ".Config::get("table_structures_coel")." ". |
"WHERE (cs_latitude IS NULL OR cs_latitude='0' OR Length(Trim(cs_latitude)) = 0) ". |
"AND (cs_longitude IS NULL OR cs_longitude='0' OR Length(Trim(cs_longitude)) = 0) ". |
"AND cs_ce_truk_pays='2654' ORDER BY cs_ville;"; |
$this->structures = $this->bdd->recupererTous($requete); |
} |
private function determinerDepartementsStructures() { |
$departements = array(); |
foreach ($this->structures as $index => $structure) { |
$codeDepartement = ''; |
if (strlen($structure['cs_code_postal']) == 5) { |
if (substr($structure['cs_code_postal'], 0, 2) > "95") { |
$codeDepartement = substr($structure['cs_code_postal'], 0, 3); |
} else { |
$codeDepartement = substr($structure['cs_code_postal'], 0, 2); |
} |
} |
$this->structures[$index]['departement'] = $codeDepartement; |
if (strlen($codeDepartement) > 0 && !in_array($codeDepartement, $departements)) { |
$departements[] = $codeDepartement; |
} |
} |
return $departements; |
} |
private function recupererCommunes($departements) { |
foreach ($departements as $index => $codeDepartement) { |
$departements[$index] = "'$codeDepartement'"; |
} |
$listeDepartements = implode(',', $departements); |
$this->bdd->requeter("USE ".Config::get("bdd_nom_floradata")); |
$requete = "SELECT code, nom, wgs84_latitude, wgs84_longitude FROM ".Config::get("table_communes")." ". |
"ORDER BY code;"; |
$communes = $this->bdd->recupererTous($requete); |
// reorganiser le tableau en series des tableaux contenant les communes par departement |
$communes[0]['recherche'] = self::transformerChainePourRecherche($communes[0]['nom']); |
$communesDepartement = array($communes[0]); |
$numeroDepartement = substr($communes[0]['code'], 0, 2) > '95' ? substr($communes[0]['code'], 0, 3) |
: substr($communes[0]['code'], 0, 2); |
for ($index = 1; $index < count($communes); $index ++) { |
$numeroDept = substr($communes[$index]['code'],0,2) > '95' ? substr($communes[$index]['code'],0,3) |
: substr($communes[$index]['code'],0,2); |
if ($numeroDept != $numeroDepartement) { |
$this->communes[$numeroDepartement] = $communesDepartement; |
$communesDepartement = array(); |
$numeroDepartement = $numeroDept; |
} |
$communes[$index]['recherche'] = self::transformerChainePourRecherche($communes[$index]['nom']); |
$communesDepartement[] = $communes[$index]; |
} |
$this->communes[$numeroDepartement] = $communesDepartement; |
} |
private static function transformerChainePourRecherche($chaine, $charset='utf-8') { |
$str = htmlentities($chaine, ENT_NOQUOTES, $charset); |
$str = preg_replace('#&([A-za-z])(?:acute|cedil|circ|grave|orn|ring|slash|th|tilde|uml);#', '\1', $str); |
$str = preg_replace('#&([A-za-z]{2})(?:lig);#', '\1', $str); |
$str = preg_replace('#&[^;]+;#', '', $str); |
for ($position = 0; $position < strlen($str); $position ++) { |
if ($str[$position] == "," || $str[$position] == "-" || $str[$position] == "'") { |
$str[$position] = " "; |
} |
} |
return strtolower($str); |
} |
private function chercherCoordonneesVillesStructures() { |
foreach ($this->structures as $index => $structure) { |
if (strlen(trim($structure['cs_ville'])) > 0) { |
if (strlen(trim($structure['departement'])) > 0) { |
$this->structures[$index] = $this->retrouverCoordonneesDansDepartement($structure); |
} else { |
$this->structures[$index] = $this->retrouverCoordonneesDansListeCommunes($structure); |
} |
} else { |
$this->nonTrouvees[] = $structure; |
} |
} |
} |
private function retrouverCoordonneesDansDepartement($structure) { |
$villeRecherche = self::transformerChainePourRecherche(($structure['cs_ville'])); |
$communeTrouvee = null; |
// comparaison dans un premier temps si les deux chaines de caracteres sont identiques |
// dans un second temps on applique la recherche de sous chaines identiques |
foreach ($this->communes[$structure['departement']] as $commune) { |
if ($commune['recherche'] == $villeRecherche) { |
$communeTrouvee = $commune; |
break; |
} |
} |
if (is_null($communeTrouvee)) { |
foreach ($this->communes[$structure['departement']] as $commune) { |
if (strstr($commune['recherche'], $villeRecherche) !== false) { |
$communeTrouvee = $commune; |
break; |
} else if (strstr($villeRecherche, $commune['recherche']) !== false) { |
$communeTrouvee = $commune; |
break; |
} |
} |
} |
if (!is_null($communeTrouvee)) { |
$structure['cs_ville'] = $communeTrouvee['nom']; |
$structure['latitude'] = $communeTrouvee['wgs84_latitude']; |
$structure['longitude'] = $communeTrouvee['wgs84_longitude']; |
} else { |
$this->nonTrouvees[] = $structure; |
} |
return $structure; |
} |
private function retrouverCoordonneesDansListeCommunes($structure) { |
$villeRecherche = self::transformerChainePourRecherche(($structure['cs_ville'])); |
$communeTrouvee = null; |
$codeDepartement = ""; |
// meme comportement que la methode precedente, mais la recherche est etendue a toutes les communes |
// si une commune est trouvee, on lui attribuera le code departement au code postal par defaut |
foreach ($this->communes as $departement => $communes) { |
foreach ($communes as $commune) { |
if ($commune['recherche'] == $villeRecherche) { |
$communeTrouvee = $commune; |
$codeDepartement = $departement; |
break; |
} |
} |
if (is_null($communeTrouvee)) { |
foreach ($communes as $commune) { |
if (strstr($commune['recherche'], $villeRecherche) !== false) { |
$communeTrouvee = $commune; |
$codeDepartement = $departement; |
break; |
} else if (strstr($villeRecherche, $commune['recherche']) !== false) { |
$communeTrouvee = $commune; |
$codeDepartement = $departement; |
break; |
} |
} |
} |
} |
if (!is_null($communeTrouvee)) { |
$structure['cs_ville'] = $communeTrouvee['nom']; |
$structure['latitude'] = $communeTrouvee['wgs84_latitude']; |
$structure['longitude'] = $communeTrouvee['wgs84_longitude']; |
$structure['cs_code_postal'] = $codeDepartement; |
} else { |
$this->nonTrouvees[] = $structure; |
} |
return $structure; |
} |
private function mettreAJourDonneesStructures() { |
$this->bdd->requeter("USE ".Config::get("bdd_nom_coel")); |
$updates = array(); |
// pour faire une seule requete de mise a jour, on va pas utiliser l'ordre UPDATE qui n'accepte |
// qu'une seule condition, mais l'ordre INSERT en rajoutant a la fin ON DUPLICATE KEY UPDATE |
// avec les correspondances au niveau des codes postaux et villes |
foreach ($this->structures as $structure) { |
if (isset($structure['latitude']) && isset($structure['longitude'])) { |
$updates[] = "({$structure['cs_id_structure']},'{$structure['cs_code_postal']}',". |
$this->bdd->proteger($structure['cs_ville']).",'{$structure['latitude']}',". |
"'{$structure['longitude']}')"; |
} |
} |
$sql = "INSERT INTO ".Config::get("table_structures_coel")." (cs_id_structure, cs_code_postal, ". |
"cs_ville, cs_latitude, cs_longitude) VALUES ".implode(",", $updates)." ". |
"ON DUPLICATE KEY UPDATE cs_code_postal=VALUES(cs_code_postal), cs_ville=VALUES(cs_ville), ". |
"cs_latitude=VALUES(cs_latitude), cs_longitude=VALUES(cs_longitude);"; |
$this->bdd->requeter($sql); |
} |
private function afficherResultatScript() { |
$nombreUpdates = count($this->structures) - count($this->nonTrouvees); |
$message = "Mise à jour des coordonnées des communes terminée. Les structures qui n'avaient pas de ". |
"coordonnées se sont vues attribuer les coordonnées de la commune dans laquelle elles sont situées.\n\n". |
"Mises à jour effectuées pour $nombreUpdates structures.\n"; |
if (count($this->nonTrouvees) > 0) { |
$message .= "Des problèmes ont été rencontrées pour les structures suivantes : \n"; |
foreach ($this->nonTrouvees as $structure) { |
$message .= " - {$structure['cs_nom']} ({$structure['cs_ville']}, {$structure['cs_code_postal']})\n"; |
} |
$message .= "Veuillez vérifier le nom de la commune saisi ou aller dans la fiche structure ". |
"pour y rajouter les coordonnées longitude/latitude\n"; |
} else { |
$message .= "Vous pourrez toujours par la suite aller dans la fiche structure ". |
"pour affiner la précision les coordonnées longitude/latitude au niveau des locaux.\n"; |
} |
print($message); |
} |
} |
?> |
/trunk/scripts/configurations/config.defaut.ini |
---|
New file |
0,0 → 1,42 |
; Encodage : UTF-8 |
; +------------------------------------------------------------------------------------------------------+ |
; Info sur l'application |
info.nom = Scripts de tests |
; Abréviation de l'application |
info.abr = SCRIPTS |
; Version du Framework nécessaire au fonctionnement de cette application |
info.framework.version = 0.3 |
; Encodage de l'application |
encodage_appli = "UTF-8" |
; Chemin de l'application (pour l'utiliser dans ce fichier) |
chemin_scripts = "php:Framework::getCheminAppli()" |
; +------------------------------------------------------------------------------------------------------+ |
; Débogage |
; Indique si oui ou non on veut afficher le débogage. |
debogage = true |
; Indique si oui ou non on veut lancer le chronométrage |
chronometrage = false |
+------------------------------------------------------------------------------------------------------+ |
; Paramètrage de la base de données. |
; bdd_abstraction : abstraction de la base de données. |
; bdd_protocole : Protocole de la base de données. |
; bdd_serveur : Nom du serveur de bases de données. |
; bdd_utilisateur : Nom de l'utilisateur de la base de données. |
; bdd_mot_de_passe : Mot de passe de l'utilisateur de la base de données. |
; bdd_nom : Nom de la base de données principale. |
; bdd_encodage : Encodage de la base de données principale. Normalement le même que l'application mais au format base de |
; données : voir ici : http://dev.mysql.com/doc/refman/5.0/en/charset-charsets.html |
; et là: http://www.postgresql.org/docs/8.1/static/multibyte.html pour les correspondances |
bdd_abstraction = pdo |
bdd_protocole = mysql |
bdd_serveur = localhost |
bdd_utilisateur = "root" |
bdd_mot_de_passe = "" |
bdd_nom = "" |
bdd_encodage = "utf8" |
; Dossier de base contenant les données d'eFlore (Fichiers TSV et SQL) |
dossierDonneesEflore = "/home/telabotap/www/eflore/donnees/" |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/scripts/configurations/config.ini |
---|
New file |
0,0 → 1,42 |
; Encodage : UTF-8 |
; +------------------------------------------------------------------------------------------------------+ |
; Info sur l'application |
info.nom = Scripts de tests |
; Abréviation de l'application |
info.abr = SCRIPTS |
; Version du Framework nécessaire au fonctionnement de cette application |
info.framework.version = 0.3 |
; Encodage de l'application |
encodage_appli = "UTF-8" |
; Chemin de l'application (pour l'utiliser dans ce fichier) |
chemin_scripts = "php:Framework::getCheminAppli()" |
; +------------------------------------------------------------------------------------------------------+ |
; Débogage |
; Indique si oui ou non on veut afficher le débogage. |
debogage = true |
; Indique si oui ou non on veut lancer le chronométrage |
chronometrage = false |
+------------------------------------------------------------------------------------------------------+ |
; Paramètrage de la base de données. |
; bdd_abstraction : abstraction de la base de données. |
; bdd_protocole : Protocole de la base de données. |
; bdd_serveur : Nom du serveur de bases de données. |
; bdd_utilisateur : Nom de l'utilisateur de la base de données. |
; bdd_mot_de_passe : Mot de passe de l'utilisateur de la base de données. |
; bdd_nom : Nom de la base de données principale. |
; bdd_encodage : Encodage de la base de données principale. Normalement le même que l'application mais au format base de |
; données : voir ici : http://dev.mysql.com/doc/refman/5.0/en/charset-charsets.html |
; et là: http://www.postgresql.org/docs/8.1/static/multibyte.html pour les correspondances |
bdd_abstraction = pdo |
bdd_protocole = mysql |
bdd_serveur = localhost |
bdd_utilisateur = "root" |
bdd_mot_de_passe = "ale-87-gal" |
bdd_nom = "" |
bdd_encodage = "utf8" |
; Dossier de base contenant les données d'eFlore (Fichiers TSV et SQL) |
dossierDonneesEflore = "/home/telabotap/www/eflore/donnees/" |
Property changes: |
Added: svn:mime-type |
+text/plain |
\ No newline at end of property |
/trunk/scripts/framework.defaut.php |
---|
New file |
0,0 → 1,6 |
<?php |
// Inclusion du Framework |
// Renomer ce fichier en "framework.php" |
// Indiquer ci-dessous le chemin absolu vers le fichier autoload.inc.php de la bonne version du Framework |
require_once '/home/www/commun/framework/0.3/Framework.php'; |
?> |
/trunk/scripts/cli.php |
---|
New file |
0,0 → 1,37 |
<?php |
// Encodage : UTF-8 |
// +-------------------------------------------------------------------------------------------------------------------+ |
/** |
* Initialise le chargement et l'exécution des scripts |
* |
* Lancer ce fichier en ligne de commande avec : |
* <code>/opt/lampp/bin/php cli.php mon_script -a test</code> |
* |
//Auteur original : |
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
* @author Delphine CAUQUIL <delphine@tela-botanica.org> |
* @copyright Tela-Botanica 1999-2008 |
* @licence GPL v3 & CeCILL v2 |
* @version $Id$ |
*/ |
// +-------------------------------------------------------------------------------------------------------------------+ |
// Le fichier Framework.php du Framework de Tela Botanica doit être appelée avant tout autre chose dans l'application. |
// Sinon, rien ne sera chargé. |
// Chemin du fichier chargeant le framework requis |
$framework = dirname(__FILE__).DIRECTORY_SEPARATOR.'framework.php'; |
if (!file_exists($framework)) { |
$e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework"; |
trigger_error($e, E_USER_ERROR); |
} else { |
// Inclusion du Framework |
require_once $framework; |
// Ajout d'information concernant cette application |
Framework::setCheminAppli(__FILE__);// Obligatoire |
Framework::setInfoAppli(Config::get('info')); |
// Initialisation et lancement du script appelé en ligne de commande |
Cli::executer(); |
} |
?> |