PageRenderTime 71ms CodeModel.GetById 28ms RepoModel.GetById 0ms app.codeStats 2ms

/fortic-php/lib/php/forticFunctions.php

https://bitbucket.org/forticpdm/fortic
PHP | 6741 lines | 4955 code | 426 blank | 1360 comment | 1013 complexity | 6a6b0c1e47c92f4016271135e094691a MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause

Large files files are truncated, but you can click here to view the full file

  1. <?php
  2. if(!defined("PHP_LIBRARY_FORTICFUNCTIONS")){define("PHP_LIBRARY_FORTICFUNCTIONS",1);
  3. ///////////////////////////////////////////////////////////////////////////////////////
  4. // nom: forticFunctions.php
  5. // auteur: Youri Reddy-Girard
  6. // Modifs: Daniel Cédilotte -- changeUTF16
  7. // date: 20/10/2002
  8. // desc: Librairie de fonctions de FORtIC
  9. //
  10. // modifié: Sylvie Caron Ajout du type de lieu - réf: demande #31 (améliorations 2005-2006)
  11. // modifié: R. Franche : mettre "0 dans lt_id dans la fonction addUpdateLieu
  12. // modifié: Sylvie Caron Ajout du lieu dans la liste des animateurs - réf: demande #37 (améliorations 2006-2007)
  13. // Fonctions ajoutées: formatNameLieu
  14. // Fonctions modifiées: getSQLStmtReqLieuAdminlieu, getSQLStmtReqSessionAnimateur
  15. // modifié: S. Caron : réf: demande #63 Liste Janvier 2008 Séparer l'affichage du code de session et de l'atelier + ajout petit icône pour le tri de colonne
  16. // Fonctions ajoutées: formatSessionCode et formatSessionDescription
  17. //
  18. // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $
  19. // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $
  20. // 2007/08/22 R. Franche : correction fonction getSQLStmtInsLieuAdmin, il manquait le return
  21. // 2008/03/25 R. Franche : lors du login : chercher lieu d'après son numéro OU sa description
  22. // pour éviter la création de lieu en double
  23. // 2008/04/25 R. Franche : correction fonction getSQLStmtReqLieuFromNoOuDescr : ajout addslash pour nom de lieu avec quote
  24. ///////////////////////////////////////////////////////////////////////////////////////
  25. ///////////////////////////////////////////////////////////////////////////////////////
  26. // ajoutUsagerLDAP($sArrayLDAP, $sUsrLDAPCode)
  27. // Ajoute l'usager dans Fortic en provenance de LDAP
  28. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  29. // $sArrayLDAP: tableau des informations de LDAP
  30. // $sUsrLDAPCode: code de l'usager LDAP
  31. // &$nUsrID: retour de l'ID de l'usager Fortic
  32. // OUT: aucun
  33. ///////////////////////////////////////////////////////////////////////////////////////
  34. function ajouterUsagerLDAP($conn, $sArrayLDAP, $sUsrLDAPCode, &$nUsrID)
  35. {
  36. // importation des données (LDAP -> USAGER)
  37. // on ouvre la transaction
  38. $result = pg_query($conn, "BEGIN;");
  39. if (!$result){ bugFromPG($conn); }
  40. //Traitement du lieu LDAP vs Fortic
  41. addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);
  42. //insertion de la fiche du nouvel usager
  43. $result = pg_query($conn, getSQLStmtInsUsager($sUsrLDAPCode, changeUTF16($sArrayLDAP[0]),
  44. changeUTF16($sArrayLDAP[1]), $nLieuID));
  45. if (!$result){ bugFromPG($conn); }
  46. //retrouver la fiche qu'on vient de créer
  47. $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerLAST(), &$nUsrID);
  48. //update de la fiche
  49. $result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID, changeUTF16($sArrayLDAP[0]),
  50. changeUTF16($sArrayLDAP[1]),$sArrayLDAP[2], $sArrayLDAP[5],
  51. changeUTF16($sArrayLDAP[6]), "t", $nLieuID, "t"));
  52. if (!$result){ bugFromPG($conn); }
  53. // insertion du type d'usager
  54. $result = pg_query($conn, getSQLStmtInsUsagerUsrType($nUsrID, 1));
  55. if (!$result){ bugFromPG($conn); }
  56. // on ferme la transaction
  57. $result = pg_query($conn, "COMMIT;");
  58. if (!$result){ bugFromPG($conn); }
  59. }
  60. ///////////////////////////////////////////////////////////////////////////////////////
  61. // addUpdateLieu($conn, , $nolieuLDAP, $lieuDesc, &$nLieuID)
  62. // Ajoute ou met à jour un lieu en provenance de d'un usager LDAP
  63. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  64. // $nolieuLDAP : numéro du lieu en provenance de LDAP */
  65. // $lieuDesc : Description du lieu
  66. // $nLieuID : numéro du lieu dans la bd Fortic
  67. // OUT: aucun
  68. ///////////////////////////////////////////////////////////////////////////////////////
  69. function addUpdateLieu($conn, $nolieuLDAP, $lieuDesc, &$nLieuID){
  70. // Aller chercher dans Fortic le lieu de l'usager LDAP
  71. // 2008/03 : chercher le lieu d'après non numéro OU sa description pour éviter le création de doubles
  72. $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuFromNoOuDescr($nolieuLDAP, $lieuDesc),
  73. &$Li_id, &$Li_lieu, &$Li_no, &$Li_adresse,
  74. &$Li_trajet, &$Li_trajetURL, &$Li_telephone,
  75. &$Li_valide, &$Li_dateUpdate, &$Li_dateCreation);
  76. // Si on ne trouve pas le lieu, on le crée
  77. if($bFicheFound != true) {
  78. // Si la description du lieu est vide, on met Lieu avec son numéro
  79. if(isset($lieuDesc) == false || $lieuDesc == "") {
  80. $lieuDesc = "Lieu_".$nolieuLDAP;
  81. }
  82. // Insertion minimum
  83. $result = pg_query($conn, getSQLStmtInsLieu($lieuDesc));
  84. if (!$result){ bugFromPG($conn); }
  85. // Aller chercher la clée de la nouvelle entrée
  86. $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuLAST(), &$nLieuID);
  87. // Compléter les informations du lieu
  88. $result = pg_query($conn, getSQLStmtUpdLieu($nLieuID, $lieuDesc,
  89. $nolieuLDAP, "", "", "", "",
  90. "t","t","0"));
  91. if (!$result){ bugFromPG($conn); }
  92. } else {
  93. // Affecter l'ID du lieu à la variable
  94. $nLieuID = $Li_id;
  95. }
  96. }
  97. ///////////////////////////////////////////////////////////////////////////////////////
  98. // addUpdateUsagerFromLDAP($conn, $codeUsager)
  99. // Ajoute ou met à jour l'usager dans Fortic en provenance de LDAP
  100. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  101. // $codeUsager : code de l'usager à ajouter
  102. // OUT: aucun
  103. ///////////////////////////////////////////////////////////////////////////////////////
  104. function addUpdateUsagerFromLDAP($conn, $codeUsager)
  105. {
  106. global $ldap_var;
  107. // Connexion au serveur LDAP
  108. $conLDAP = ldap_connect($ldap_var[db][host], $ldap_var[db][port]);
  109. if(!$conLDAP) { //Connexion au serveur LDAP non-réussi, on quitteM
  110. bugFromLDAP($conLDAP);
  111. } else {
  112. //Si options LDAP on les appliquent
  113. if ( count($ldap_var["ldap_options"]) > 0) {
  114. OptionConnexion_LDAP($conLDAP);
  115. }
  116. }
  117. // Filtre pour rechercher seulement le code d'usager
  118. $filtre ="(&(".$ldap_var[db][searchKey]."=".$codeUsager.")".$filtre.$ldap_var[db][filter].")";
  119. //Recherche l'info complete de l'usager dans la base ldap
  120. $codeRetour = Recherche_LDAP($conLDAP,$filtre, &$sArrayRechLdap);
  121. //Vérifie le code de retour pour savoir si l'usager existe dans l'annuaire
  122. if ($codeRetour >= 0) {
  123. $sArrayLDAP = array(trim($sArrayRechLdap[0][0]), // Nom
  124. trim($sArrayRechLdap[0][1]), //Prénom
  125. trim($sArrayRechLdap[0][2]), //Email
  126. trim($sArrayRechLdap[0][3]), //lieuID
  127. trim($sArrayRechLdap[0][4]), //lieuDescr
  128. trim($sArrayRechLdap[0][5]), //Téléphone
  129. trim($sArrayRechLdap[0][6])); //Fonction
  130. //vérifie si l'usager existe déjà dans la base Fortic sinon on l'ajoute
  131. $bUserFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerFromLogin($codeUsager),
  132. &$nUsrID, &$sLDAP);
  133. if ($bUserFound){ // l'usager existe déjà dans FORTIC, met à jour
  134. //Traitement du lieu LDAP vs Fortic
  135. addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);
  136. // Mise à jour de l'usager
  137. $result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID,
  138. changeUTF16($sArrayLDAP[0]),
  139. changeUTF16($sArrayLDAP[1]),
  140. $sArrayLDAP[2], $sArrayLDAP[5],
  141. changeUTF16($sArrayLDAP[6]), "t",
  142. $nLieuID, "t"));
  143. } else { //Nouvel usager on l'ajoute
  144. ajouterUsagerLDAP($conn, $sArrayLDAP, $codeUsager, &$nUsrID);
  145. }
  146. }
  147. }
  148. ///////////////////////////////////////////////////////////////////////////////////////
  149. // bugFromLdap($conn)
  150. // méthode appellée losrqu'on a un problème avec l'exécution d'une requête ou à établir
  151. // la connexion avec le serveur LDAP.
  152. ///////////////////////////////////////////////////////////////////////////////////////
  153. function bugFromLDAP($conn){
  154. echo _("Probleme avec la connexion LDAP");
  155. //echo pg_last_error($conn);
  156. //on quitte tous les script (pas de niasage)
  157. exit;
  158. }
  159. ///////////////////////////////////////////////////////////////////////////////////////
  160. // fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage,
  161. // &$arrnUsrLogin, &$arrUsrNom, &$arrUsrPrenom,
  162. // &$arrUsrLieuID, &$arrUsrLieu, &$arrUsrFonction)
  163. // remplit les tableaux de variables reçus en paramètre avec les valeurs contenus dans un
  164. // Array de SESSION "UsagerLieuLDAP"(provenant d'une requête LDAP)
  165. // De plus ce type de requête tient compte de la notion des pages. On peut donc
  166. // se positionner sur la Xe page de résultat directement
  167. // ATTENTION : Cette fonction est très spécifique et remplit toujours le même
  168. // nombre de tableau et dans un ordre très spécifique.
  169. // IN:
  170. // $pg: quelle page on veut se positionner
  171. // $pgSize: la grandeur des page (nb d'enregistrement par page)
  172. // $nbRecordTotal: nb d'entrée dans le tableau de SESSION
  173. // $arrUsrLogin: 1er tableau à remplir
  174. // $arrUsrNom: 2e tableau à remplir
  175. // $arr...: Xe tableau à remplir
  176. // OUT: -1: erreur lors de l'exécution de la requête
  177. // (int >= 0): nb de rangées résultantes de la requête
  178. ///////////////////////////////////////////////////////////////////////////////////////
  179. function fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage, &$arrnUsrLogin,
  180. &$arrUsrNom, &$arrUsrPrenom,&$arrUsrLieuID, &$arrUsrLieu,
  181. &$arrUsrFonction){
  182. $nbPage = ceil($nbRecordTotal/$pgSize);
  183. if ($nbRecordTotal>0){
  184. $offset = ($pg-1)*$pgSize;
  185. $limit = $offset + $pgSize;
  186. $nbRow = min($nbRecordTotal,$limit)- $offset;
  187. for($iRow=0; $iRow<$nbRow; $iRow++,$offset++){
  188. $arrnUsrLogin[$iRow] = $_SESSION["UsagerLieuLDAP"][5][$offset];
  189. $arrUsrNom[$iRow] = $_SESSION["UsagerLieuLDAP"][0][$offset];
  190. $arrUsrPrenom[$iRow] = $_SESSION["UsagerLieuLDAP"][1][$offset];
  191. $arrUsrLieuID[$iRow] = $_SESSION["UsagerLieuLDAP"][2][$offset];
  192. $arrUsrLieu[$iRow] = $_SESSION["UsagerLieuLDAP"][3][$offset];
  193. $arrUsrFonction[$iRow] = $_SESSION["UsagerLieuLDAP"][4][$offset];
  194. }
  195. return ($nbRow);
  196. }
  197. else{
  198. return (0);
  199. }
  200. }
  201. ///////////////////////////////////////////////////////////////////////////////////////
  202. // fillUsrFromLDAPServer($login, $mdp, &$bLoginValide, &$sArrayLDAP)
  203. // remplit le usr_id de l'usager en fonction de ce qu'on trouvé dans ldap qui avait
  204. // le même login et mot de passe que celui fournit en paramètre
  205. // IN: $login: nom d'usager
  206. // $mdp: mot de passe
  207. // &$bLoginValide : si on a de quoi de valide sur ldap, on met true ici
  208. // &$sArrayLDAP : informations extraites du serveur LDAP
  209. // OUT: 1: user retrouvé dans ldap
  210. // 0: user non retrouvé dans ldap
  211. ///////////////////////////////////////////////////////////////////////////////////////
  212. function fillUsrFromLDAPServer( $login, $mdp, &$bLoginValide, &$sArrayLDAP ){
  213. global $ldap_var;
  214. $OkLDAP = 0;
  215. $bLoginValide = false;
  216. // Connexion au serveur LDAP
  217. $conLDAP = ldap_connect( $ldap_var[ 'db' ][ 'host' ], $ldap_var[ 'db' ][ 'port' ] );
  218. //Connexion au serveur LDAP. Si non-réussi, on quitte
  219. if( $conLDAP !== false ) {
  220. //Si options LDAP on les appliquent
  221. if ( count($ldap_var["ldap_options"]) > 0) {
  222. OptionConnexion_LDAP($conLDAP);
  223. }
  224. // Filtre pour rechercher seulement le code d'usager
  225. $filtre = "(&(" . $ldap_var[ "db" ][ "searchKey" ] . "=" . $login. ")" . $ldap_var[ "db" ][ "filter" ] . ")";
  226. //Recherche l'usager dans la base ldap
  227. $codeRetour = Recherche_LDAP( $conLDAP, $filtre, &$sArrayRechLdap );
  228. $sArrayRechLdap = $sArrayRechLdap[ 0 ];
  229. //Vérifie le code de retour pour savoir si l'usager existe dans l'annuaire
  230. if( $codeRetour >= 0 ) {
  231. $OkLDAP = 1;
  232. if( $codeRetour > 0 ) {
  233. //Récuppère le dn pour permettre de faire le nouveau bind
  234. $dn = $sArrayRechLdap[ 7 ];
  235. //Si pas de mot de passe fournit on en génère un bidon pour être certain de ne pas faire un bind anonyme
  236. if( $mdp == "" ){
  237. $mdp = crypt( microtime() );
  238. }
  239. // Si l'authentification a réussie, retourne les infos de l'usager ainsi qu'un code de retour valide
  240. if( @ldap_bind( $conLDAP, $dn, $mdp ) ){
  241. //if( ldap_compare( $conLDAP, $dn, "userpassword", $mdp ) ){
  242. $sArrayLDAP = array( trim( $sArrayRechLdap[ 0 ] ), trim( $sArrayRechLdap[ 1 ] ), trim( $sArrayRechLdap[ 2 ] ),
  243. trim( $sArrayRechLdap[ 3 ] ), trim( $sArrayRechLdap[ 4 ] ), trim( $sArrayRechLdap[ 5 ] ), trim( $sArrayRechLdap[ 6 ] ) );
  244. $bLoginValide = true;
  245. }
  246. }
  247. }
  248. ldap_unbind( $conLDAP );
  249. }
  250. return $OkLDAP;
  251. }
  252. ///////////////////////////////////////////////////////////////////////////////////////
  253. // OptionConnexion_LDAP
  254. // Affecte les options de connexion à l'annaire LDAP s'il y a lieu
  255. // IN: $conLDAP :Connexion au serveur ldap
  256. // OUT: -----
  257. ///////////////////////////////////////////////////////////////////////////////////////
  258. function OptionConnexion_LDAP( $conLDAP){
  259. global $ldap_var;
  260. for( $i=0; is_array($ldap_var["ldap_options"]) && $i < count($ldap_var["ldap_options"]); $i++ ) {
  261. if( isset( $ldap_var["ldap_options"][$i] ) && strpos( $ldap_var["ldap_options"][$i], ";" ) ) {
  262. $param = explode(";",$ldap_var["ldap_options"][$i]);
  263. ldap_set_option($conLDAP, constant($param[0]) ,$param[1]);
  264. }
  265. }
  266. }
  267. ///////////////////////////////////////////////////////////////////////////////////////
  268. // Recherche_LDAP
  269. // Recherche des informations selon le filtre spécifié
  270. // IN: $conLDAP :Connexion au serveur ldap
  271. // $filtre : filtre de recherche
  272. // &$sArrayLDAP : informations extraites du serveur LDAP
  273. // OUT: nb: nb. user retrouvé dans ldap
  274. // 0: user non retrouvé dans ldap
  275. // -1: connexion impossible
  276. ///////////////////////////////////////////////////////////////////////////////////////
  277. function Recherche_LDAP( $conLDAP, $filtre, $sArrayLDAP ){
  278. global $ldap_var;
  279. $codeRetour = 0;
  280. // La connexion au serveur LDAP est établit on fait un premier bind
  281. if( isset( $ldap_var[ 'db' ][ 'bind_dn' ] ) ) {
  282. //Si aucun code de bind n'est défini on fait un alors un bind anonyme
  283. $bindLDAP = ldap_bind( $conLDAP, $ldap_var[ 'db' ][ 'bind_dn' ], $ldap_var[ 'db' ][ 'bind_pwd' ] );
  284. } else {
  285. // Sinon on fait une connexion avec un usager ayant les droits nécessaires dans l'annuaire
  286. $bindLDAP = ldap_bind( $conLDAP );
  287. }
  288. // Bind au serveur LDAP non-réussi, on quitte
  289. if( !$bindLDAP ) {
  290. $codeRetour = -1;
  291. } else {
  292. // Liste des variables à retourner lors du search
  293. $restrictions = array( $ldap_var[ 'info' ][ 'nom' ], $ldap_var[ 'info' ][ 'prenom' ], $ldap_var[ 'info' ][ 'email' ],
  294. $ldap_var[ 'info' ][ 'lieuID' ], $ldap_var[ 'info' ][ 'lieuDescr' ], $ldap_var[ 'info' ][ 'telephone' ],
  295. $ldap_var[ 'info' ][ 'fonction' ], $ldap_var[ 'db' ][ 'searchKey' ] );
  296. // Cherche le dn de l'usager et met les enregistrements dans un tableau pour le traitement
  297. $arrayRecherche = ldap_search( $conLDAP, $ldap_var[ 'db' ][ 'searchBase' ], $filtre, $restrictions );
  298. $info = ldap_get_entries($conLDAP, $arrayRecherche);
  299. $codeRetour = count( $info ) - 1;
  300. // Retourne toutes les informations de l'usager selon l'annuaire
  301. for( $i = 0; is_array($info) && $i < $codeRetour; $i++) {
  302. $entree = $info[ $i ];
  303. //Correction si l'usager n'a pas de numéro de téléphone dans ldap
  304. if ( !isset( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) ||
  305. !is_array( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) ){
  306. $entree[ $ldap_var[ 'info' ][ 'telephone' ] ] = array( "" );
  307. }
  308. $sArrayLDAP[ $i ] = array( $entree[ $ldap_var[ 'info' ][ 'nom' ] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'prenom' ] ][ 0 ],
  309. $entree[ $ldap_var[ 'info' ][ 'email'] ][ 0 ], strtolower( $entree[ $ldap_var[ 'info' ]['lieuID' ] ][ 0 ] ),
  310. $entree[ $ldap_var[ 'info' ][ 'lieuDescr'] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'telephone'] ][ 0 ],
  311. $entree[ $ldap_var[ 'info' ][ 'fonction'] ][ 0 ], $entree[ 'dn' ],
  312. strtolower( $entree[ $ldap_var[ 'db' ][ 'searchKey' ] ][ 0 ] ) );
  313. }
  314. }
  315. return $codeRetour;
  316. }
  317. ///////////////////////////////////////////////////////////////////////////////////////
  318. // Recherche_LDAP_Import
  319. // Recherche des informations selon le filtre spécifié
  320. // IN: $conLDAP :Connexion au serveur ldap
  321. // $filtre : filtre de recherche
  322. // &$sArrayLDAP : informations extraites du serveur LDAP
  323. // OUT: nb: nb. user retrouvé dans ldap
  324. // 0: user non retrouvé dans ldap
  325. // -1: connexion impossible
  326. ///////////////////////////////////////////////////////////////////////////////////////
  327. function Recherche_LDAP_Import($conLDAP, $filtre, $sArrayLDAP){
  328. global $ldap_var;
  329. $codeRetour = 0;
  330. //La connexion au serveur LDAP est établit on fait un premier bind
  331. //Si aucun code de bind n'est défini on fait un alors un bind anonyme
  332. //sinon on fait une connexion avec un usager ayant lesdroits nécessaires dans l'annuaire'
  333. if(isset($ldap_var[db][bind_dn])) //Le LDAP n'est pas anonyme
  334. {
  335. $bindLDAP = ldap_bind($conLDAP, $ldap_var[db][bind_dn],$ldap_var[db][bind_pwd]);
  336. }
  337. else //La recherche anonyme est permise
  338. {
  339. $bindLDAP = ldap_bind($conLDAP);
  340. }
  341. if(!$bindLDAP) //Bind au serveur LDAP non-réussi, on quitte
  342. {
  343. ldap_unbind($conLDAP); //Déconnexion
  344. $codeRetour = -1;
  345. return $codeRetour; //Arrêt COMPLET de l'application (-1)
  346. }
  347. //Liste des variables à retourner lors du search
  348. $restrictions = array($ldap_var[info][nom],
  349. $ldap_var[info][prenom],
  350. $ldap_var[info][email],
  351. $ldap_var[info][lieuID],
  352. $ldap_var[info][lieuDescr],
  353. $ldap_var[info][telephone],
  354. $ldap_var[info][fonction],
  355. $ldap_var[db][searchKey]);
  356. // Aller chercher le dn de l'usager
  357. $arrayRecherche = ldap_search($conLDAP,$ldap_var[db][searchBase],
  358. $filtre, $restrictions);
  359. // Mettre les enregistrements dans un tableau pour le traitement
  360. $info = ldap_get_entries($conLDAP, $arrayRecherche);
  361. $codeRetour = count($info) - 1;
  362. for( $i = 0; is_array($info) && $i < (count($info)-1); $i++){
  363. $arrayNom[$i] = changeUTF16($info[$i][$ldap_var[info][nom]][0]);
  364. $arrayPrenom[$i] = changeUTF16($info[$i][$ldap_var[info][prenom]][0]);
  365. $arrayLieuID[$i] = $info[$i][$ldap_var[info][lieuID]][0];
  366. $arrayLieuDescr[$i] = changeUTF16($info[$i][$ldap_var[info][lieuDescr]][0]);
  367. $arrayFonction[$i] = changeUTF16($info[$i][$ldap_var[info][fonction]][0]);
  368. $arrayKey[$i] = $info[$i][$ldap_var[db][searchKey]][0];
  369. }
  370. $sArrayLDAP[0] = $arrayNom;
  371. $sArrayLDAP[1] = $arrayPrenom;
  372. $sArrayLDAP[2] = $arrayLieuID;
  373. $sArrayLDAP[3] = $arrayLieuDescr;
  374. $sArrayLDAP[4] = $arrayFonction;
  375. $sArrayLDAP[5] = $arrayKey;
  376. return $codeRetour;
  377. }
  378. ///////////////////////////////////////////////////////////////////////////////////////
  379. // Retourne la requete SQL necessaire pour faire un SELECT LDAP
  380. ///////////////////////////////////////////////////////////////////////////////////////
  381. function getSQLStmtReqLieuxLDAP($mot, $motlnk, $adminlieu_id, $tech_id, $valide, $indx){
  382. $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_valide";
  383. $SQLStmt.=" FROM lieu";
  384. $SQLStmt.=" WHERE li_id = li_id";
  385. $SQLStmt.=" AND li_ldap ='t'";
  386. if ($mot!=""){
  387. if ($motlnk!="and" && $motlnk!="or"){
  388. $motlnk="and"; //valeur par defaut : securite
  389. }
  390. $arrMot=getArrayFromStringMot($mot);
  391. $SQLStmt.=" AND (";
  392. for ($i=0; $i<count($arrMot); $i++){
  393. $SQLStmt.="(li_lieu ILIKE '%".fixPGQuote($arrMot[$i])."%'";
  394. $SQLStmt.=" OR li_adresse ILIKE '%".fixPGQuote($arrMot[$i])."%')";
  395. if ($i<count($arrMot)-1){
  396. $SQLStmt.=" ".$motlnk." "; //OR ou AND
  397. }
  398. }
  399. $SQLStmt.=")";
  400. }
  401. if (is_numeric($adminlieu_id)){
  402. $SQLStmt.=" AND li_id IN (";
  403. $SQLStmt.=" SELECT li_id";
  404. $SQLStmt.=" FROM lieuadmin";
  405. $SQLStmt.=" WHERE usr_id=".$adminlieu_id;
  406. $SQLStmt.=")";
  407. }
  408. if (is_numeric($tech_id)){
  409. $SQLStmt.=" AND li_id IN (";
  410. $SQLStmt.=" SELECT li_id";
  411. $SQLStmt.=" FROM lieusupport";
  412. $SQLStmt.=" WHERE usr_id=".$tech_id;
  413. $SQLStmt.=")";
  414. }
  415. if ($valide!=""){
  416. if (!strcasecmp($valide,"t")){
  417. $SQLStmt.=" AND li_valide='t'";
  418. }
  419. else{
  420. $SQLStmt.=" AND li_valide='f'";
  421. }
  422. }
  423. if ($indx!=""){
  424. if ($indx=="lieua"){
  425. $SQLStmt.=" ORDER BY li_lieu ASC";
  426. }
  427. elseif ($indx=="lieud"){
  428. $SQLStmt.=" ORDER BY li_lieu DESC";
  429. }
  430. elseif ($indx=="adressea"){
  431. $SQLStmt.=" ORDER BY li_adresse ASC";
  432. }
  433. elseif ($indx=="adressed"){
  434. $SQLStmt.=" ORDER BY li_adresse DESC";
  435. }
  436. elseif ($indx=="trajeta"){
  437. $SQLStmt.=" ORDER BY li_trajet ASC";
  438. }
  439. elseif ($indx=="trajetd"){
  440. $SQLStmt.=" ORDER BY li_trajet DESC";
  441. }
  442. elseif ($indx=="lieunoa"){
  443. $SQLStmt.=" ORDER BY li_no ASC";
  444. }
  445. elseif ($indx=="lieunod"){
  446. $SQLStmt.=" ORDER BY li_no DESC";
  447. }
  448. else
  449. {
  450. $SQLStmt.=" ORDER BY li_lieu ASC"; // ordre alphabetique de nom par defaut
  451. }
  452. }
  453. return $SQLStmt;
  454. }
  455. ///////////////////////////////////////////////////////////////////////////////////////
  456. // Retourne le filtre necessaire pour faire la recherche LDAP par lieu
  457. ///////////////////////////////////////////////////////////////////////////////////////
  458. function getFiltreUsagersLdap($mot, $li_no){
  459. global $ldap_var;
  460. $filtre.="(&";
  461. if ($mot!=""){
  462. if ($motlnk!="and" && $motlnk!="or"){
  463. $motlnk="and"; //valeur par defaut : securite
  464. }
  465. $arrMot=getArrayFromStringMot($mot);
  466. for ($i=0; $i<count($arrMot); $i++){
  467. $rech = verifMot($mot);
  468. if($rech !="" ){
  469. $filtre.="(".$ldap_var[info][nom]."=".$rech."*)";
  470. }
  471. }
  472. }
  473. //Lieu recherché
  474. if ($li_no !=""){
  475. $filtre.="(".$ldap_var[info][lieuID]."=".$li_no.")";
  476. }
  477. //Filtre suplémentaire spécial.
  478. $filtre .= $ldap_var[db][filter];
  479. $filtre .=")";
  480. return $filtre;
  481. }
  482. ///////////////////////////////////////////////////////////////////////////////////////
  483. // verifMot($input)
  484. // Enlève les caractères *? de la chaine
  485. // IN: $input: string qu'on veut vérifier
  486. // OUT: string épurée
  487. ///////////////////////////////////////////////////////////////////////////////////////
  488. function verifMot($input){
  489. $result = strtr($input,"*?","//");
  490. $result = trim($result);
  491. return ($result);
  492. }
  493. ///////////////////////////////////////////////////////////////////////////////////////
  494. // TriArrayLDAP($cle)
  495. // Tri le Array de SESSION "UsagerLieuLDAP"(provenant d'une requête LDAP)
  496. // IN: $cle: Cle de tri
  497. // OUT: Array de SESSION trié
  498. // True cle valide
  499. ///////////////////////////////////////////////////////////////////////////////////////
  500. function TriArray($cle){
  501. //Extrait la partie ordre de tri
  502. $typeTri = substr($cle,-1);
  503. //Ajuste l'ordre pour un tri descendant ou ascendant par défaut
  504. if($typeTri == "d" || $typeTri == "D"){
  505. $ordre = "SORT_DESC";
  506. }
  507. else {
  508. $ordre = "SORT_ASC";
  509. }
  510. //Extrait la partie du mot qui indique la cle de tri
  511. $cleTri = substr($cle,0, -1);
  512. //Ajuste les clés pour un tri par fonction
  513. if($cleTri == "type") {
  514. $cle1 = 4; //Fonction
  515. $cle2 = 0; //Nom
  516. $cle3 = 1; //Prenom
  517. $cle4 = 2; //LieuID
  518. }
  519. else if ($cleTri == "lieu") {
  520. $cle1 = 2; //LieuID
  521. $cle2 = 0; //Nom
  522. $cle3 = 1; //Prenom
  523. $cle4 = 4; //Fonction
  524. }
  525. else { //Tri par défaut (Nom, Prénom, LieuID, Fonction)
  526. $cle1 = 0; //Nom
  527. $cle2 = 1; //Prenom
  528. $cle3 = 2; //LieuID
  529. $cle4 = 4; //Fonction
  530. }
  531. //Tri du tableau complet
  532. if($typeTri == "d" || $typeTri == "D"){
  533. array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_DESC,
  534. $_SESSION["UsagerLieuLDAP"][$cle2], SORT_DESC,
  535. $_SESSION["UsagerLieuLDAP"][$cle3], SORT_DESC,
  536. $_SESSION["UsagerLieuLDAP"][$cle4], SORT_DESC,
  537. $_SESSION["UsagerLieuLDAP"][3],
  538. $_SESSION["UsagerLieuLDAP"][5]);
  539. }
  540. else{
  541. array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_ASC,
  542. $_SESSION["UsagerLieuLDAP"][$cle2], SORT_ASC,
  543. $_SESSION["UsagerLieuLDAP"][$cle3], SORT_ASC,
  544. $_SESSION["UsagerLieuLDAP"][$cle4], SORT_ASC,
  545. $_SESSION["UsagerLieuLDAP"][3],
  546. $_SESSION["UsagerLieuLDAP"][5]);
  547. }
  548. return (true);
  549. }
  550. ///////////////////////////////////////////////////////////////////////////////////////
  551. // connextToPG($conn)
  552. // établit la connexion avec le serveur Postgresql
  553. ///////////////////////////////////////////////////////////////////////////////////////
  554. function connectToPG( $conn_str ){
  555. if( !$conn = pg_connect( $conn_str ) ) { bugFromPG( $conn ); };
  556. return $conn;
  557. }
  558. ///////////////////////////////////////////////////////////////////////////////////////
  559. // bugFromPG($conn)
  560. // méthode appellée losrqu'on a un problème avec l'exécution d'une requête ou à établir
  561. // la connexion avec le serveur Postgresql.
  562. ///////////////////////////////////////////////////////////////////////////////////////
  563. function bugFromPG($conn){
  564. echo _("Probleme avec la BD PostgreSQL");
  565. echo pg_last_error($conn);
  566. //on quitte tous les script (pas de niasage)
  567. exit;
  568. }
  569. ///////////////////////////////////////////////////////////////////////////////////////
  570. // changeUTF16($chaine)
  571. // méthode appellée pour convertir les lignes LDap d'UTF-8 à UTF-16
  572. //
  573. // IN: $chaine
  574. // OUT: retourne la chaine UTF-8 ou ISO-8859-1, convertie en UTF-16
  575. ///////////////////////////////////////////////////////////////////////////////////////
  576. function changeUTF16( $chaine ){
  577. return mb_convert_encoding( $chaine, "ISO-8859-1","UTF-8" )."\n" ;
  578. }
  579. ///////////////////////////////////////////////////////////////////////////////////////
  580. // Met un space HTML lorsqu'il n'y aucune valeur a afficher
  581. ///////////////////////////////////////////////////////////////////////////////////////
  582. function convNoDataToHTMLSpace($value){
  583. if (($value=="") || (!isset($value))){
  584. return("&nbsp;");
  585. }
  586. else{
  587. return($value);
  588. }
  589. }
  590. ///////////////////////////////////////////////////////////////////////////////////////
  591. // fillArrFromDBStd($conn, $sqlstmt, $arrVal0 = NULL, $arrVal1 = NULL, ...)
  592. // remplit les tableaux de variables reçu en paramètre avec la valeur des
  593. // rangées retournées par la requête sql fournie en paramètre
  594. // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
  595. // que l'odre des champs dans la requête
  596. // [SUPPORTE 40 tableaux]
  597. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  598. // $sqlstmt: requête SQL à exécuter
  599. // $arrVal1: 1er tableau à remplir
  600. // $arrVal2: 2e tableau à remplir
  601. // $arrValX: Xe tableau à remplir
  602. // OUT: -1: erreur lors de l'exécution de la requête
  603. // (int): nb de rangées résultantes de la requête
  604. ///////////////////////////////////////////////////////////////////////////////////////
  605. function fillArrFromDBStd($conn, $sqlstmt, $arrVal0 = NULL, $arrVal1 = NULL, $arrVal2 = NULL, $arrVal3 = NULL, $arrVal4 = NULL, $arrVal5 = NULL, $arrVal6 = NULL, $arrVal7 = NULL, $arrVal8 = NULL, $arrVal9 = NULL, $arrVal10 = NULL, $arrVal11 = NULL, $arrVal12 = NULL, $arrVal13 = NULL, $arrVal14 = NULL, $arrVal15 = NULL, $arrVal16 = NULL, $arrVal17 = NULL, $arrVal18 = NULL, $arrVal19 = NULL, $arrVal20 = NULL, $arrVal21 = NULL, $arrVal22 = NULL, $arrVal23 = NULL, $arrVal24 = NULL, $arrVal25 = NULL, $arrVal26 = NULL, $arrVal27 = NULL, $arrVal28 = NULL, $arrVal29 = NULL, $arrVal30 = NULL, $arrVal31 = NULL, $arrVal32 = NULL, $arrVal33 = NULL, $arrVal34 = NULL, $arrVal35 = NULL, $arrVal36 = NULL, $arrVal37 = NULL, $arrVal38 = NULL, $arrVal39 = NULL){
  606. $nbRow = -1;
  607. // tableau dynamique
  608. $nbArray = func_num_args() - 2;
  609. for( $i = 0; $i < $nbArray; $i++ ){
  610. $name = "arrVal" . $i;
  611. $args[ $i ] =& $$name;
  612. // S'assure que ce qui sera retourné sera au moins un tableau vide
  613. if( is_null( $args[ $i ] ) ){
  614. $args[ $i ] = array();
  615. }
  616. }
  617. // bd time
  618. $result = pg_query( $conn, $sqlstmt );
  619. if( $result > 0 ){
  620. $nbRow = pg_num_rows( $result );
  621. $nbLoop = min( $nbArray, pg_num_fields( $result ) );
  622. for( $iRow = 0; $iRow < $nbRow; $iRow++ ){
  623. for( $iCol = 0; $iCol < $nbLoop; $iCol++ ){
  624. $args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );
  625. }
  626. }
  627. pg_free_result( $result );
  628. }
  629. return $nbRow;
  630. }
  631. ///////////////////////////////////////////////////////////////////////////////////////
  632. // fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $arrVal0 = NULL, $arrVal1 = NULL, ...)
  633. // remplit les tableaux de variables reçus en paramètre avec la valeur des
  634. // rangées retournées par la requête sql fournie en paramètre. De plus
  635. // ce type de requête tient compte de la notion des pages. On peut donc
  636. // se positionner sur la Xe page de résultat directement
  637. // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
  638. // que l'odre des champs dans la requête
  639. // [SUPPORTE 40 tableaux]
  640. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  641. // $sqlstmt: requête SQL à exécuter
  642. // $page_no: quelle page on veut se positionner
  643. // $pgSize: la grandeur des page (nb d'enregistrement par page)
  644. // $page_size: nb de page résultant de la requête
  645. // $nbRecordTotal: nb d'enregistrement résultant de la requête
  646. // $arrVal1: 1er tableau à remplir
  647. // $arrVal2: 2e tableau à remplir
  648. // $arrValX: Xe tableau à remplir
  649. // OUT: -1: erreur lors de l'exécution de la requête
  650. // (int >= 0): nb de rangées résultantes de la requête
  651. ///////////////////////////////////////////////////////////////////////////////////////
  652. function fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $arrVal0 = NULL, $arrVal1 = NULL, $arrVal2 = NULL,
  653. $arrVal3 = NULL, $arrVal4 = NULL, $arrVal5 = NULL, $arrVal6 = NULL, $arrVal7 = NULL, $arrVal8 = NULL, $arrVal9 = NULL, $arrVal10 = NULL,
  654. $arrVal11 = NULL, $arrVal12 = NULL, $arrVal13 = NULL, $arrVal14 = NULL, $arrVal15 = NULL, $arrVal16 = NULL, $arrVal17 = NULL,
  655. $arrVal18 = NULL, $arrVal19 = NULL, $arrVal20 = NULL, $arrVal21 = NULL, $arrVal22 = NULL, $arrVal23 = NULL, $arrVal24 = NULL,
  656. $arrVal25 = NULL, $arrVal26 = NULL, $arrVal27 = NULL, $arrVal28 = NULL, $arrVal29 = NULL, $arrVal30 = NULL, $arrVal31 = NULL,
  657. $arrVal32 = NULL, $arrVal33 = NULL, $arrVal34 = NULL, $arrVal35 = NULL, $arrVal36 = NULL, $arrVal37 = NULL, $arrVal38 = NULL, $arrVal39 = NULL){
  658. $retour = -1;
  659. // Création d'un tableau dynamique de pointeurs vers les tableaux de valeurs reçues
  660. $nbArray = func_num_args()-2;
  661. for( $i = 0; $i < $nbArray; $i++ ){
  662. $name = "arrVal" . $i;
  663. $args[ $i ] = &$$name;
  664. }
  665. // Fait la requête en ôtant tout ce qui suit "ORDER BY"
  666. if( $result = pg_query( $conn, eregi_replace( " ORDER BY .*" , "", $sqlstmt ) ) ){
  667. $retour = 0;
  668. $nbRecordTotal = pg_num_rows( $result );
  669. if( $nbRecordTotal > 0 ){
  670. $nbPage = ceil( $nbRecordTotal / $page_size );
  671. $limit = $page_size;
  672. if (isset($page_no) )
  673. $offset = ( $page_no - 1 ) * $page_size;
  674. else
  675. $offset = 0;
  676. // on refait la requête avec des nouveaux paramètres
  677. $result = pg_query( $conn, $sqlstmt . " LIMIT " . $limit . " OFFSET " . $offset );
  678. $nbRow = pg_num_rows($result);
  679. $nbCol = min( $nbArray, pg_num_fields( $result ) );
  680. for( $iRow = 0; $iRow < $nbRow; $iRow++ ){
  681. for( $iCol=0; $iCol < $nbCol; $iCol++ ){
  682. $args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );
  683. }
  684. }
  685. pg_free_result( $result ); // Libère la mémoire inutilisée
  686. $retour = $nbRow;
  687. }
  688. }
  689. return $retour;
  690. }
  691. ///////////////////////////////////////////////////////////////////////////////////////
  692. // fillVarFromDBStd($conn, $sqlstmt, &$val1, &$val2, &$val3)
  693. // remplit les variables reçues en paramètre avec la valeur de la première
  694. // rangée du résultat de la requête (arrangez vous pour que la requête
  695. // sql n'ait qu'une seule rangée de résultat)
  696. // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
  697. // que l'odre des champs dans la requête
  698. // [SUPPORTE 40 variables]
  699. // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
  700. // $sqlstmt: requête SQL à exécuter
  701. // $val1: 1ere variable à remplir
  702. // $val2: 2e variable à remplir
  703. // $valX: Xe variable à remplir
  704. ///////////////////////////////////////////////////////////////////////////////////////
  705. function fillVarFromDBStd($conn, $sqlstmt, $val0 = NULL, $val1 = NULL, $val2 = NULL, $val3 = NULL, $val4 = NULL, $val5 = NULL, $val6 = NULL, $val7 = NULL, $val8 = NULL, $val9 = NULL, $val10 = NULL, $val11 = NULL, $val12 = NULL, $val13 = NULL, $val14 = NULL, $val15 = NULL, $val16 = NULL, $val17 = NULL, $val18 = NULL, $val19 = NULL, $val20 = NULL, $val21 = NULL, $val22 = NULL, $val23 = NULL, $val24 = NULL, $val25 = NULL, $val26 = NULL, $val27 = NULL, $val28 = NULL, $val29 = NULL, $val30 = NULL, $val31 = NULL, $val32 = NULL, $val33 = NULL, $val34 = NULL, $val35 = NULL, $val36 = NULL, $val37 = NULL, $val38 = NULL, $val39 = NULL){
  706. // tableau dynamique
  707. $nbVariable = func_num_args()-2;
  708. for ($i=0; $i<$nbVariable; $i++){
  709. $name = "val" . $i;
  710. $args[$i]=&$$name;
  711. }
  712. //echo "fillVarFromDBStd: " . $sqlstmt . "<br>";
  713. $result = pg_query($conn, $sqlstmt);
  714. if (!$result){ bugFromPG($conn); }
  715. if($result>0){
  716. $nbRow=pg_num_rows($result);
  717. $nbLoop=min($nbVariable,pg_num_fields($result));
  718. if($nbRow==1){
  719. for($iCol=0; $iCol<$nbLoop; $iCol++){
  720. $args[$iCol]=pg_result($result, 0, $iCol);
  721. }
  722. pg_free_result($result);
  723. return(true);
  724. }
  725. pg_free_result($result);
  726. }
  727. return(false);
  728. }
  729. ///////////////////////////////////////////////////////////////////////////////////////
  730. // fixPGQuote($input)
  731. // fixe les quote pour que la requête demeure sécuritaire dans postgres..
  732. // IN: $input: string qu'on veut sécuriser
  733. // OUT: string sécurisé
  734. ///////////////////////////////////////////////////////////////////////////////////////
  735. function fixPGQuote($input){
  736. // Peut être remplacé par 'pg_escape_string' mais doit être utilisé avec une connexion à Postgres 7.2
  737. return (addslashes($input));
  738. }
  739. ///////////////////////////////////////////////////////////////////////////////////////
  740. // getWordStemRegExp()
  741. // Retourne une expression reguliere qui permet de reconnaitre le debut d'un mot
  742. // a l'interieur d'une chaine quelconque.
  743. // OUT: expression reguliere
  744. ///////////////////////////////////////////////////////////////////////////////////////
  745. function getWordStemRegExp(){
  746. // Tout caractere pouvant se trouver au debut d'un mot.
  747. return( "[ -.,?!:;([\']" );
  748. }
  749. ///////////////////////////////////////////////////////////////////////////////////////
  750. // accentInsensitiveLike()
  751. // Retourne une chaine pouvant remplacer une expression LIKE ou ILIKE afin
  752. // d'effectuer un "pattern matching".
  753. // Les expressions régulières sont beaucoup plus rapides que LIKE ou ILIKE
  754. // IN: $field_name Nom du champ
  755. // $field_value Valeur du champ
  756. // $case_insensitive true si l'on veut que la comparaison ne tienne pas compte
  757. // de la casse
  758. // OUT: clause SQL
  759. ///////////////////////////////////////////////////////////////////////////////////////
  760. function accentInsensitiveLike($field_name, $field_value, $case_insensitive = true) {
  761. $regexp_op = ( $case_insensitive == true ) ? "~*" : "~";
  762. // Fait une recherche avec une expression régulière qui cherche la valeur qui commence un champ ou qui se situe après un charactère qui ne fait pas alphanumérique
  763. return "( " . $field_name . " " . $regexp_op . " E'^" . $field_value . "|[^\w]" . $field_value . "' )";
  764. }
  765. ///////////////////////////////////////////////////////////////////////////////////////
  766. // flushCourriel()
  767. // Envoit tous les courriels qui devraient etre envoyes
  768. ///////////////////////////////////////////////////////////////////////////////////////
  769. function flushCourriel(){
  770. //echo "Les courriels n'ont pas été flushés par le fichier 'forticFunctions.php'.";
  771. }
  772. ///////////////////////////////////////////////////////////////////////////////////////
  773. // formatCR($sTemp)
  774. // formate la sortie de manière à remplacer les CR par des <br> (les ENTERS)
  775. // IN: $sTemp: string à afficher
  776. // OUT: (string) le résultat du string une fois formaté
  777. ///////////////////////////////////////////////////////////////////////////////////////
  778. function formatCR($sTemp){
  779. return (str_replace("\r","<br/>",$sTemp));
  780. }
  781. ///////////////////////////////////////////////////////////////////////////////////////
  782. // Set le format d'affichage pour les dates.
  783. ///////////////////////////////////////////////////////////////////////////////////////
  784. function formatDate($dTemp, $format){
  785. if ( (isDate($dTemp)) || (isTimeStamp($dTemp)) ){
  786. return date($format,strtotime($dTemp));
  787. }
  788. else{
  789. return $dTemp;
  790. }
  791. }
  792. ///////////////////////////////////////////////////////////////////////////////////////
  793. // Set le format d'affichage pour les dates.
  794. ///////////////////////////////////////////////////////////////////////////////////////
  795. function formatDateInterval($dTemp1, $dTemp2, $style, $dateFormat, $timeFormat){
  796. if ($style=="date"){
  797. if ( ((isDate($dTemp1))||(isTimeStamp($dTemp1))) && ((isDate($dTemp2))||(isTimeStamp($dTemp2))) ){
  798. $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
  799. $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
  800. if ($sDateTemp1 != $sDateTemp2){
  801. $output = $sDateTemp1." "._("au")." ".$sDateTemp2;
  802. }
  803. else{
  804. $output = $sDateTemp1;
  805. }
  806. }
  807. elseif( (isDate($dTemp1))||(isTimeStamp($dTemp1)) ){
  808. $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
  809. $output = $sDateTemp1." "._("au")." "._("n/a");
  810. }
  811. elseif( (isDate($dTemp2))||(isTimeStamp($dTemp2)) ){
  812. $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
  813. $output = _("n/a")." "._("au")." ".$sDateTemp2;
  814. }
  815. else{
  816. $output = _("dates indeterminees");
  817. }
  818. }
  819. elseif ($style=="time"){
  820. if ( (isTimeStamp($dTemp1)) && (isTimeStamp($dTemp2)) ){
  821. $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
  822. $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
  823. $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));
  824. $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));
  825. if ($sDateTemp1 == $sDateTemp2){
  826. $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2;
  827. }
  828. else{
  829. $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2." (".$sDateTemp1.")";
  830. }
  831. }
  832. elseif( (isTimeStamp($dTemp1))||(isTimeStamp($dTemp1)) ){
  833. $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
  834. $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));
  835. $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." "._("n/a");
  836. }
  837. elseif( (isTimeStamp($dTemp2))||(isTimeStamp($dTemp2)) ){
  838. $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
  839. $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));
  840. $output = _("n/a")." "._("a")." ".$sDateTemp2." ".$sTimeTemp2;
  841. }
  842. else{
  843. $output = _("moment indetermine");
  844. }
  845. }
  846. return $output;
  847. }
  848. ///////////////////////////////////////////////////////////////////////////////////////
  849. // function formatDateLimite($dTemp, $dTempDisplay, $classOK="", $classNOT="", $classHOPE="")
  850. // affiche la datelimite en couleur
  851. ///////////////////////////////////////////////////////////////////////////////////////
  852. function formatDateLimite( $dTemp, $format, $classOK = "", $classNOT = "", $classHOPE = "" ){
  853. $output = "";
  854. $class = "";
  855. if( isDate( $dTemp ) ){
  856. $today = strtotime( date( "Y-m-d" ) );
  857. $limite = strtotime( $dTemp );
  858. // Si la date limite n'est pas arrivé ou qu'elle est aujourd'hui et qu'on ne reçoit pas de classe HOPE
  859. if( ( $today < $limite || ( $today == $limite && $classHOPE == "" ) ) && $classOK != "" ){
  860. $class = $classOK;
  861. // Si la date limite est dépassée
  862. } elseif( $today > $limite && $classNOT != "" ){
  863. $class = $classNOT;
  864. // Si la date limite est aujourd'hui
  865. } elseif( $today == $limite && $classHOPE != "" ){
  866. $class = $classHOPE;
  867. }
  868. $output = formatDate( $dTemp, $format );
  869. if( $class != "" ){
  870. $output = "<span class='" . $class . "'>" . $output . "</span>";
  871. }
  872. }
  873. return $output;
  874. }
  875. ///////////////////////////////////////////////////////////////////////////////////////
  876. // function formatGabaritSub($sInput, $class=NULL)
  877. // formate la sortie pour qu'on puisse voir si c'est un sous-gabarit
  878. // IN: $sInput: t ou f : designant si system
  879. // OUT: (string) ce qu'on affiche sur la page
  880. ///////////////////////////////////////////////////////////////////////////////////////
  881. function formatGabaritSub($sInput, $class=NULL){
  882. $state1=_("sous-gabarit");
  883. $state2=_("gabarit");
  884. if ($sInput=="t"){
  885. if ($class!=""){
  886. $output="<span class=\"".$class."\">".$state1."</span>";
  887. }
  888. else{
  889. $output=$state1;
  890. }
  891. }
  892. else{
  893. if ($class!=""){
  894. $output="<span class=\"".$class."\">".$state2."</span>";
  895. }
  896. else{
  897. $output=$state2;
  898. }
  899. }
  900. return $output;
  901. }
  902. ///////////////////////////////////////////////////////////////////////////////////////
  903. // function formatGabaritSystem($sInput, $class=NULL)
  904. // formate la sortie pour qu'on puisse voir si c'est un gabarit system
  905. // IN: $sInput: t ou f : designant si system
  906. // OUT: (string) ce qu'on affiche sur la page
  907. ///////////////////////////////////////////////////////////////////////////////////////
  908. function formatGabaritSystem($sInput, $class=NULL){
  909. $state="("._("Systeme").")";
  910. if ($sInput=="t"){
  911. if ($class!=""){
  912. $output="<span class=\"".$class."\">".$state."</span>";
  913. }
  914. else{
  915. $output=$state;
  916. }
  917. }
  918. return $output;
  919. }
  920. ///////////////////////////////////////////////////////////////////////////////////////
  921. // formatHTML($sTemp)
  922. // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de
  923. // mot réservé propore au html.
  924. // IN: $sTemp: string à afficher
  925. // OUT: (string) le résultat du string une fois formaté
  926. ///////////////////////////////////////////////////////////////////////////////////////
  927. function formatHTML($sTemp){
  928. return (htmlentities($sTemp));
  929. }
  930. ///////////////////////////////////////////////////////////////////////////////////////
  931. // formatJS($sTemp)
  932. // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de
  933. // mot réservé propore au html.
  934. // IN: $sTemp: string à afficher
  935. // OUT: (string) le résultat du string une fois formaté
  936. ///////////////////////////////////////////////////////////////////////////////////////
  937. function formatJS($sTemp){
  938. return (addslashes($sTemp));
  939. }
  940. ///////////////////////////////////////////////////////////////////////////////////////
  941. // Set le format d'affichage d'un nom.
  942. ///////////////////////////////////////////////////////////////////////////////////////
  943. function formatName($sNom, $sPrenom){
  944. if (($sNom!="") && ($sPrenom!="")){
  945. return (strtoupper($sNom).", ".$sPrenom);
  946. }
  947. elseif ($sNom!=""){
  948. return (strtoupper($sNom));
  949. }
  950. elseif ($sPrenom!=""){
  951. return ($sPrenom);
  952. }
  953. else{
  954. return ( _("sans nom") );
  955. }
  956. }
  957. //S.C. 2007-03-28 demande #37 Ajout de la fonction formatNameLieu
  958. ///////////////////////////////////////////////////////////////////////////////////////
  959. // Set le format d'affichage d'un nom et le # lieu de travail
  960. ///////////////////////////////////////////////////////////////////////////////////////
  961. function formatNameLieu($sNom, $sPrenom, $sLieu){
  962. if (($sNom!="") && ($sPrenom!="") && ($sLieu!="")){
  963. return (strtoupper($sNom).", ".$sPrenom." (".$sLieu.")");
  964. }
  965. if (($sNom!="") && ($sPrenom!="")){
  966. return (strtoupper($sNom).", ".$sPrenom);
  967. }
  968. elseif ($sNom!=""){
  969. return (strtoupper($sNom));
  970. }
  971. elseif ($sPrenom!=""){
  972. return ($sPrenom);
  973. }
  974. elseif ($sLieu!=""){
  975. return ($sLieu);
  976. }
  977. else{
  978. return ( _("vide") );
  979. }
  980. }
  981. ///////////////////////////////////////////////////////////////////////////////////////
  982. // function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL)
  983. // formate le nombre d'inscription. Losrque c'est plein, ou pas plein, on a la possibilité
  984. // de changer le style sheet (couleur ou autres)
  985. // IN: $nbIns nombre de personne actuellement inscrit
  986. // $nbMax nombre maximal de personne
  987. // $classOK class si le nombre de personne permet l'inscription encore
  988. // $classNOT class si la session est pleine
  989. // OUT: (string) le résultat du string une fois formaté
  990. ///////////////////////////////////////////////////////////////////////////////////////
  991. function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL){
  992. unset($output);
  993. if (is_numeric($nbIns) && is_numeric($nbMax)){
  994. if ($nbIns < $nbMax){
  995. $class = $classOK;
  996. }
  997. else{
  998. $class = $classNOT;
  999. }
  1000. //output
  1001. if ($class!=""){
  1002. $output = "<span class=\"".$class."\">".$nbIns."/".$nbMax."</span>";
  1003. }
  1004. else{
  1005. $output = $nbIns."/".$nbMax;
  1006. }
  1007. }
  1008. return $output;
  1009. }
  1010. ///////////////////////////////////////////////////////////////////////////////////////
  1011. // formatNote($sNote $class)
  1012. // Set le format d'affichage pour les notes de sessions
  1013. // IN: $sNote note à écrire
  1014. // $class est-ce qu'il y a une classe auquel on veux lier (CSS)
  1015. // OUT: (string) affichage du code avec l'atelier et le projet
  1016. ///////////////////////////////////////////////////////////////////////////////////////
  1017. function formatNote( $sNote, $class = "" ){
  1018. if ( $sNote != "" ){
  1019. $sNote = "(" . $sNote . ")";
  1020. if ( $class != "" ){
  1021. $sNote = "<span class='" . $class . "'>" . $sNote . "</span>";
  1022. }
  1023. }
  1024. return $sNote;
  1025. }
  1026. ///////////////////////////////////////////////////////////////////////////////////////
  1027. // formatParamString($sParam, $sParamValeur)
  1028. // Set le format les parametre SQL et leurs valeurs
  1029. // IN: $sParam: string contenant les parametres SQL separes par des virgules
  1030. // $sParameValeur: string contenant les valeurs des parametres SQL separees par des virgules
  1031. // OUT: (string) une bel…

Large files files are truncated, but you can click here to view the full file