PageRenderTime 54ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/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 
    

  1. <?php

    2. 

  2. if(!defined("PHP_LIBRARY_FORTICFUNCTIONS")){define("PHP_LIBRARY_FORTICFUNCTIONS",1);

    3. 

  3. ///////////////////////////////////////////////////////////////////////////////////////

    4. 

  4. // nom:     forticFunctions.php

    5. 

  5. // auteur:  Youri Reddy-Girard

    6. 

  6. // Modifs:   Daniel C�dilotte                   -- changeUTF16

    7. 

  7. // date:    20/10/2002

    8. 

  8. // desc:    Librairie de fonctions de FORtIC

    9. 

  9. //

    10. 

  10. // modifi�:	Sylvie Caron Ajout du type de lieu - r�f: demande #31 (am�liorations 2005-2006)

    11. 

  11. // modifi�:	R. Franche : mettre "0 dans lt_id dans la fonction addUpdateLieu

    12. 

  12. // modifi�: Sylvie Caron Ajout du lieu dans la liste des animateurs - r�f: demande #37 (am�liorations 2006-2007)

    13. 

  13. //			Fonctions ajout�es: 	formatNameLieu

    14. 

  14. //			Fonctions modifi�es: 	getSQLStmtReqLieuAdminlieu, getSQLStmtReqSessionAnimateur

    15. 

  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. 

  16. //          Fonctions ajout�es:     formatSessionCode et formatSessionDescription

    17. 

  17. //

    18. 

  18. // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $

    19. 

  19. // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $

    20. 

  20. // 2007/08/22 R. Franche : correction fonction getSQLStmtInsLieuAdmin, il manquait le return

    21. 

  21. // 2008/03/25 R. Franche : lors du login : chercher lieu d'apr�s son num�ro OU sa description

    22. 

  22. //											pour �viter la cr�ation de lieu en double

    23. 

  23. // 2008/04/25 R. Franche : correction fonction getSQLStmtReqLieuFromNoOuDescr : ajout addslash pour nom de lieu avec quote

    24. 

  24. ///////////////////////////////////////////////////////////////////////////////////////

    25. 

  25. 

    26. 

  26. ///////////////////////////////////////////////////////////////////////////////////////

    27. 

  27. // ajoutUsagerLDAP($sArrayLDAP, $sUsrLDAPCode)

    28. 

  28. // Ajoute l'usager dans Fortic en provenance de LDAP

    29. 

  29. //  IN:     $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    30. 

  30. //            $sArrayLDAP: tableau des informations de LDAP

    31. 

  31. //            $sUsrLDAPCode: code de l'usager LDAP

    32. 

  32. //            &$nUsrID: retour de l'ID de l'usager Fortic

    33. 

  33. //  OUT:    aucun

    34. 

  34. ///////////////////////////////////////////////////////////////////////////////////////

    35. 

  35.   function ajouterUsagerLDAP($conn, $sArrayLDAP, $sUsrLDAPCode, &$nUsrID)

    36. 

  36. {    

    37. 

  37.     // importation des donn�es (LDAP -> USAGER)

    38. 

  38.     // on ouvre la transaction

    39. 

  39.     $result = pg_query($conn, "BEGIN;");

    40. 

  40.     if (!$result){ bugFromPG($conn); }

    41. 

  41. 

    42. 

  42.     //Traitement du lieu LDAP vs Fortic

    43. 

  43.     addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);

    44. 

  44. 

    45. 

  45.     //insertion de la fiche du nouvel usager

    46. 

  46. 	$result = pg_query($conn, getSQLStmtInsUsager($sUsrLDAPCode, changeUTF16($sArrayLDAP[0]),

    47. 

  47. 			changeUTF16($sArrayLDAP[1]), $nLieuID));

    48. 

  48. 

    49. 

  49.     if (!$result){ bugFromPG($conn); }

    50. 

  50. 

    51. 

  51.     //retrouver la fiche qu'on vient de cr�er

    52. 

  52.     $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerLAST(), &$nUsrID);

    53. 

  53.     

    54. 

  54.     //update de la fiche                          

    55. 

  55. 	$result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID, changeUTF16($sArrayLDAP[0]),

    56. 

  56. 			changeUTF16($sArrayLDAP[1]),$sArrayLDAP[2], $sArrayLDAP[5],

    57. 

  57. 			changeUTF16($sArrayLDAP[6]), "t", $nLieuID, "t"));

    58. 

  58.     if (!$result){ bugFromPG($conn); }

    59. 

  59. 

    60. 

  60.     // insertion du type d'usager

    61. 

  61.     $result = pg_query($conn, getSQLStmtInsUsagerUsrType($nUsrID, 1));

    62. 

  62.     if (!$result){ bugFromPG($conn); }

    63. 

  63. 

    64. 

  64.     // on ferme la transaction

    65. 

  65.     $result = pg_query($conn, "COMMIT;");

    66. 

  66.     if (!$result){ bugFromPG($conn); }

    67. 

  67. }

    68. 

  68. 

    69. 

  69. ///////////////////////////////////////////////////////////////////////////////////////

    70. 

  70. // addUpdateLieu($conn, , $nolieuLDAP, $lieuDesc, &$nLieuID)

    71. 

  71. // Ajoute ou met � jour un lieu en provenance de d'un usager LDAP

    72. 

  72. //  IN:   $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    73. 

  73. //        $nolieuLDAP : num�ro du lieu en provenance de LDAP */

    74. 

  74. //        $lieuDesc : Description du lieu

    75. 

  75. //        $nLieuID : num�ro du lieu dans la bd Fortic

    76. 

  76. //  OUT:  aucun

    77. 

  77. ///////////////////////////////////////////////////////////////////////////////////////

    78. 

  78. function addUpdateLieu($conn, $nolieuLDAP, $lieuDesc, &$nLieuID){

    79. 

  79. 

    80. 

  80.     // Aller chercher dans Fortic le lieu de l'usager LDAP 

    81. 

  81.     //	2008/03 : chercher le lieu d'apr�s non num�ro OU sa description pour �viter le cr�ation de doubles

    82. 

  82.     $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuFromNoOuDescr($nolieuLDAP, $lieuDesc),

    83. 

  83.                                   &$Li_id, &$Li_lieu, &$Li_no, &$Li_adresse,

    84. 

  84.                                   &$Li_trajet, &$Li_trajetURL, &$Li_telephone,

    85. 

  85.                                   &$Li_valide, &$Li_dateUpdate, &$Li_dateCreation);

    86. 

  86.     

    87. 

  87.     // Si on ne trouve pas le lieu, on le cr�e

    88. 

  88.     if($bFicheFound != true) {            

    89. 

  89.         // Si la description du lieu est vide, on met Lieu avec son num�ro

    90. 

  90.         if(isset($lieuDesc) == false || $lieuDesc == "") {

    91. 

  91.             $lieuDesc = "Lieu_".$nolieuLDAP;

    92. 

  92.         }

    93. 

  93.         // Insertion minimum

    94. 

  94.         $result = pg_query($conn, getSQLStmtInsLieu($lieuDesc));

    95. 

  95.         if (!$result){ bugFromPG($conn); }

    96. 

  96.         // Aller chercher la cl�e de la nouvelle entr�e

    97. 

  97.         $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuLAST(), &$nLieuID);

    98. 

  98.         // Compl�ter les informations du lieu

    99. 

  99.         $result = pg_query($conn, getSQLStmtUpdLieu($nLieuID, $lieuDesc,

    100. 

  100.                                                     $nolieuLDAP, "", "", "", "",

    101. 

  101.                                                     "t","t","0"));

    102. 

  102.         if (!$result){ bugFromPG($conn); }

    103. 

  103.     } else {

    104. 

  104.         // Affecter l'ID du lieu � la variable

    105. 

  105.         $nLieuID = $Li_id;

    106. 

  106.     }

    107. 

  107.  }

    108. 

  108. 

    109. 

  109. 

    110. 

  110. 

    111. 

  111. ///////////////////////////////////////////////////////////////////////////////////////

    112. 

  112. // addUpdateUsagerFromLDAP($conn, $codeUsager)

    113. 

  113. // Ajoute ou met � jour l'usager dans Fortic en provenance de LDAP

    114. 

  114. //  IN:     $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    115. 

  115. //          $codeUsager : code de l'usager � ajouter

    116. 

  116. //  OUT:    aucun

    117. 

  117. ///////////////////////////////////////////////////////////////////////////////////////

    118. 

  118. function addUpdateUsagerFromLDAP($conn, $codeUsager)

    119. 

  119. {

    120. 

  120.     global $ldap_var;

    121. 

  121. 

    122. 

  122.      // Connexion au serveur LDAP

    123. 

  123.     $conLDAP = ldap_connect($ldap_var[db][host], $ldap_var[db][port]);

    124. 

  124.     if(!$conLDAP) {       //Connexion au serveur LDAP non-r�ussi, on quitteM

    125. 

  125.         bugFromLDAP($conLDAP);

    126. 

  126.     } else { 	 

    127. 

  127. 		//Si options LDAP on les appliquent

    128. 

  128. 		if ( count($ldap_var["ldap_options"]) > 0) {

    129. 

  129. 			OptionConnexion_LDAP($conLDAP);

    130. 

  130. 		}

    131. 

  131. 	}

    132. 

  132.     // Filtre pour rechercher seulement le code d'usager

    133. 

  133.     $filtre ="(&(".$ldap_var[db][searchKey]."=".$codeUsager.")".$filtre.$ldap_var[db][filter].")";

    134. 

  134.      //Recherche l'info complete de l'usager dans la base ldap

    135. 

  135.      $codeRetour = Recherche_LDAP($conLDAP,$filtre, &$sArrayRechLdap);

    136. 

  136. 

    137. 

  137.     //V�rifie le code de  retour pour savoir si l'usager existe dans l'annuaire

    138. 

  138.     if ($codeRetour >= 0) {

    139. 

  139.     $sArrayLDAP = array(trim($sArrayRechLdap[0][0]),      // Nom

    140. 

  140.                         trim($sArrayRechLdap[0][1]),      //Pr�nom

    141. 

  141.                         trim($sArrayRechLdap[0][2]),      //Email

    142. 

  142.                         trim($sArrayRechLdap[0][3]),      //lieuID

    143. 

  143.                         trim($sArrayRechLdap[0][4]),      //lieuDescr

    144. 

  144.                         trim($sArrayRechLdap[0][5]),      //T�l�phone

    145. 

  145.                         trim($sArrayRechLdap[0][6]));     //Fonction

    146. 

  146. 

    147. 

  147.         //v�rifie si l'usager existe d�j� dans la base Fortic sinon on l'ajoute

    148. 

  148.         $bUserFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerFromLogin($codeUsager),

    149. 

  149.                                      &$nUsrID, &$sLDAP);

    150. 

  150.         if ($bUserFound){ // l'usager existe d�j� dans FORTIC, met � jour

    151. 

  151.             //Traitement du lieu LDAP vs Fortic

    152. 

  152.             addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);

    153. 

  153.             // Mise � jour de l'usager

    154. 

  154.             $result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID,

    155. 

  155.                                       changeUTF16($sArrayLDAP[0]),

    156. 

  156.                                       changeUTF16($sArrayLDAP[1]),

    157. 

  157.                                       $sArrayLDAP[2], $sArrayLDAP[5],

    158. 

  158.                                       changeUTF16($sArrayLDAP[6]), "t",

    159. 

  159.                                       $nLieuID, "t"));

    160. 

  160.         } else { //Nouvel usager on l'ajoute

    161. 

  161.            ajouterUsagerLDAP($conn, $sArrayLDAP, $codeUsager, &$nUsrID);

    162. 

  162.         }

    163. 

  163.     }

    164. 

  164. }

    165. 

  165. 

    166. 

  166. 

    167. 

  167. ///////////////////////////////////////////////////////////////////////////////////////

    168. 

  168. // bugFromLdap($conn)

    169. 

  169. // m�thode appell�e losrqu'on a un probl�me avec l'ex�cution d'une requ�te ou � �tablir

    170. 

  170. // la connexion avec le serveur LDAP.

    171. 

  171. ///////////////////////////////////////////////////////////////////////////////////////

    172. 

  172. function bugFromLDAP($conn){

    173. 

  173.     echo _("Probleme avec la connexion LDAP");

    174. 

  174.     //echo pg_last_error($conn);

    175. 

  175.     //on quitte tous les script (pas de niasage)

    176. 

  176.     exit;

    177. 

  177. }

    178. 

  178. 

    179. 

  179. 

    180. 

  180. ///////////////////////////////////////////////////////////////////////////////////////

    181. 

  181. // fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage,

    182. 

  182. //                          &$arrnUsrLogin, &$arrUsrNom, &$arrUsrPrenom,

    183. 

  183. //                          &$arrUsrLieuID, &$arrUsrLieu, &$arrUsrFonction)

    184. 

  184. // remplit les tableaux de variables re�us en param�tre avec les valeurs contenus dans un 

    185. 

  185. // Array de SESSION "UsagerLieuLDAP"(provenant d'une requ�te LDAP)

    186. 

  186. // De plus ce type de requ�te tient compte de la notion des pages. On peut donc 

    187. 

  187. // se positionner sur la Xe page de r�sultat directement

    188. 

  188. // ATTENTION : Cette fonction est tr�s sp�cifique et remplit toujours le m�me 

    189. 

  189. //             nombre de tableau et dans un ordre tr�s sp�cifique.

    190. 

  190. //  IN:     

    191. 

  191. //          $pg: quelle page on veut se positionner

    192. 

  192. //          $pgSize: la grandeur des page (nb d'enregistrement par page)

    193. 

  193. //          $nbRecordTotal: nb d'entr�e dans le tableau de SESSION

    194. 

  194. //          $arrUsrLogin: 1er tableau � remplir

    195. 

  195. //          $arrUsrNom: 2e tableau � remplir

    196. 

  196. //          $arr...: Xe tableau � remplir

    197. 

  197. //  OUT:    -1: erreur lors de l'ex�cution de la requ�te

    198. 

  198. //          (int >= 0): nb de rang�es r�sultantes de la requ�te

    199. 

  199. ///////////////////////////////////////////////////////////////////////////////////////

    200. 

  200. function fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage, &$arrnUsrLogin,

    201. 

  201.                            &$arrUsrNom, &$arrUsrPrenom,&$arrUsrLieuID, &$arrUsrLieu,

    202. 

  202.                            &$arrUsrFonction){

    203. 

  203.     

    204. 

  204.         $nbPage = ceil($nbRecordTotal/$pgSize);

    205. 

  205.         if ($nbRecordTotal>0){

    206. 

  206.             $offset = ($pg-1)*$pgSize;

    207. 

  207.             $limit = $offset + $pgSize;

    208. 

  208.             $nbRow = min($nbRecordTotal,$limit)- $offset;

    209. 

  209.             for($iRow=0; $iRow<$nbRow; $iRow++,$offset++){

    210. 

  210.                 $arrnUsrLogin[$iRow] = $_SESSION["UsagerLieuLDAP"][5][$offset];

    211. 

  211.                 $arrUsrNom[$iRow] = $_SESSION["UsagerLieuLDAP"][0][$offset];

    212. 

  212.                 $arrUsrPrenom[$iRow] = $_SESSION["UsagerLieuLDAP"][1][$offset];

    213. 

  213.                 $arrUsrLieuID[$iRow] = $_SESSION["UsagerLieuLDAP"][2][$offset];

    214. 

  214.                 $arrUsrLieu[$iRow] = $_SESSION["UsagerLieuLDAP"][3][$offset];

    215. 

  215.                 $arrUsrFonction[$iRow] = $_SESSION["UsagerLieuLDAP"][4][$offset];

    216. 

  216.             }

    217. 

  217.             return ($nbRow);

    218. 

  218.         }

    219. 

  219.         else{

    220. 

  220.             return (0);

    221. 

  221.         }

    222. 

  222. }

    223. 

  223. 

    224. 

  224. ///////////////////////////////////////////////////////////////////////////////////////

    225. 

  225. // fillUsrFromLDAPServer($login, $mdp, &$bLoginValide, &$sArrayLDAP)

    226. 

  226. // remplit le usr_id de l'usager en fonction de ce qu'on trouv� dans ldap qui avait

    227. 

  227. // le m�me login et mot de passe que celui fournit en param�tre

    228. 

  228. //  IN:     $login: nom d'usager

    229. 

  229. //          $mdp: mot de passe

    230. 

  230. //          &$bLoginValide : si on a de quoi de valide sur ldap, on met true ici

    231. 

  231. //            &$sArrayLDAP : informations extraites du serveur LDAP

    232. 

  232. //  OUT:    1: user retrouv� dans ldap

    233. 

  233. //          0: user non retrouv� dans ldap

    234. 

  234. ///////////////////////////////////////////////////////////////////////////////////////

    235. 

  235. function fillUsrFromLDAPServer( $login, $mdp, &$bLoginValide, &$sArrayLDAP ){

    236. 

  236. 	global $ldap_var;

    237. 

  237. 	$OkLDAP = 0;

    238. 

  238. 	$bLoginValide = false;

    239. 

  239. 

    240. 

  240. 	// Connexion au serveur LDAP

    241. 

  241. 	$conLDAP = ldap_connect( $ldap_var[ 'db' ][ 'host' ], $ldap_var[ 'db' ][ 'port' ] );

    242. 

  242. 

    243. 

  243. 	//Connexion au serveur LDAP. Si non-r�ussi, on quitte

    244. 

  244. 	if( $conLDAP !== false ) {

    245. 

  245. 		//Si options LDAP on les appliquent 	 

    246. 

  246. 		if ( count($ldap_var["ldap_options"]) > 0) { 	 

    247. 

  247. 			OptionConnexion_LDAP($conLDAP); 	 

    248. 

  248. 		}

    249. 

  249. 		// Filtre pour rechercher seulement le code d'usager

    250. 

  250. 		$filtre = "(&(" . $ldap_var[ "db" ][ "searchKey" ] . "=" . $login. ")" . $ldap_var[ "db" ][ "filter" ] . ")";

    251. 

  251. 

    252. 

  252. 		//Recherche l'usager dans la base ldap

    253. 

  253. 		$codeRetour = Recherche_LDAP( $conLDAP, $filtre, &$sArrayRechLdap );

    254. 

  254. 		$sArrayRechLdap = $sArrayRechLdap[ 0 ];

    255. 

  255. 

    256. 

  256. 		//V�rifie le code de  retour pour savoir si l'usager existe dans l'annuaire

    257. 

  257. 		if( $codeRetour >= 0 ) {

    258. 

  258. 			$OkLDAP = 1;

    259. 

  259. 			if( $codeRetour > 0 ) {

    260. 

  260. 				//R�cupp�re le dn pour permettre de faire le nouveau bind

    261. 

  261. 				$dn = $sArrayRechLdap[ 7 ];        

    262. 

  262. 				//Si pas de mot de passe fournit on en g�n�re un bidon pour �tre certain de ne pas faire un bind anonyme

    263. 

  263. 				if( $mdp == "" ){

    264. 

  264. 					$mdp = crypt( microtime() );

    265. 

  265. 				}

    266. 

  266. 

    267. 

  267. 				// Si l'authentification a r�ussie, retourne les infos de l'usager ainsi qu'un code de retour valide

    268. 

  268. 				if( @ldap_bind( $conLDAP, $dn, $mdp ) ){

    269. 

  269. 				//if( ldap_compare( $conLDAP, $dn, "userpassword", $mdp ) ){

    270. 

  270. 					$sArrayLDAP = array( trim( $sArrayRechLdap[ 0 ] ), trim( $sArrayRechLdap[ 1 ] ), trim( $sArrayRechLdap[ 2 ] ),

    271. 

  271. 							trim( $sArrayRechLdap[ 3 ] ), trim( $sArrayRechLdap[ 4 ] ), trim( $sArrayRechLdap[ 5 ] ), trim( $sArrayRechLdap[ 6 ] ) );

    272. 

  272. 					$bLoginValide = true;

    273. 

  273. 				}

    274. 

  274. 			}

    275. 

  275. 		}

    276. 

  276. 

    277. 

  277. 		ldap_unbind( $conLDAP );

    278. 

  278. 	}

    279. 

  279. 

    280. 

  280. 	return $OkLDAP;

    281. 

  281. }

    282. 

  282. 

    283. 

  283. ///////////////////////////////////////////////////////////////////////////////////////

    284. 

  284. // OptionConnexion_LDAP 	 

    285. 

  285. // Affecte les options de connexion � l'annaire LDAP s'il y a lieu 	 

    286. 

  286. //  IN:     $conLDAP :Connexion au serveur ldap 	 

    287. 

  287. //  OUT:    ----- 	 

    288. 

  288. /////////////////////////////////////////////////////////////////////////////////////// 	 

    289. 

  289. function OptionConnexion_LDAP( $conLDAP){

    290. 

  290. 	global $ldap_var;

    291. 

  291. 

    292. 

  292. 	for( $i=0; is_array($ldap_var["ldap_options"]) && $i < count($ldap_var["ldap_options"]); $i++ ) {

    293. 

  293. 		if( isset( $ldap_var["ldap_options"][$i] ) && strpos( $ldap_var["ldap_options"][$i], ";" ) ) {

    294. 

  294. 			$param = explode(";",$ldap_var["ldap_options"][$i]);

    295. 

  295. 			ldap_set_option($conLDAP, constant($param[0]) ,$param[1]);

    296. 

  296. 		}

    297. 

  297. 	}

    298. 

  298. }

    299. 

  299. ///////////////////////////////////////////////////////////////////////////////////////

    300. 

  300. // Recherche_LDAP

    301. 

  301. // Recherche des informations selon le filtre sp�cifi�

    302. 

  302. //  IN:     $conLDAP :Connexion au serveur ldap

    303. 

  303. //        $filtre  : filtre de recherche

    304. 

  304. //           &$sArrayLDAP : informations extraites du serveur LDAP    

    305. 

  305. //  OUT:    nb: nb. user retrouv� dans ldap

    306. 

  306. //          0: user non retrouv� dans ldap

    307. 

  307. //           -1: connexion impossible

    308. 

  308. ///////////////////////////////////////////////////////////////////////////////////////

    309. 

  309. function Recherche_LDAP( $conLDAP, $filtre, $sArrayLDAP ){

    310. 

  310. 	global $ldap_var;

    311. 

  311. 	$codeRetour = 0;

    312. 

  312. 

    313. 

  313. 	// La connexion au serveur LDAP est �tablit on fait un premier bind

    314. 

  314. 	if( isset( $ldap_var[ 'db' ][ 'bind_dn' ] ) ) {

    315. 

  315. 		//Si aucun code de bind n'est d�fini on fait un alors un bind anonyme

    316. 

  316. 		$bindLDAP = ldap_bind( $conLDAP, $ldap_var[ 'db' ][ 'bind_dn' ], $ldap_var[ 'db' ][ 'bind_pwd' ] );

    317. 

  317. 	} else {

    318. 

  318. 		// Sinon on fait une connexion avec un usager ayant les droits n�cessaires dans l'annuaire

    319. 

  319. 		$bindLDAP = ldap_bind( $conLDAP );

    320. 

  320. 	}

    321. 

  321. 

    322. 

  322. 	// Bind au serveur LDAP non-r�ussi, on quitte

    323. 

  323. 	if( !$bindLDAP ) {

    324. 

  324. 		$codeRetour = -1;

    325. 

  325. 	} else {

    326. 

  326. 		// Liste des variables � retourner lors du search

    327. 

  327. 		$restrictions = array( $ldap_var[ 'info' ][ 'nom' ], $ldap_var[ 'info' ][ 'prenom' ], $ldap_var[ 'info' ][ 'email' ],

    328. 

  328. 				$ldap_var[ 'info' ][ 'lieuID' ], $ldap_var[ 'info' ][ 'lieuDescr' ], $ldap_var[ 'info' ][ 'telephone' ],

    329. 

  329. 				$ldap_var[ 'info' ][ 'fonction' ], $ldap_var[ 'db' ][ 'searchKey' ] );

    330. 

  330. 

    331. 

  331. 		// Cherche le dn de l'usager et met les enregistrements dans un tableau pour le traitement    

    332. 

  332. 		$arrayRecherche = ldap_search( $conLDAP, $ldap_var[ 'db' ][ 'searchBase' ], $filtre, $restrictions );

    333. 

  333. 		$info = ldap_get_entries($conLDAP, $arrayRecherche);

    334. 

  334. 		$codeRetour = count( $info ) - 1;

    335. 

  335. 

    336. 

  336. 		// Retourne toutes les informations de l'usager selon l'annuaire

    337. 

  337. 		for( $i = 0; is_array($info) && $i < $codeRetour; $i++) {

    338. 

  338. 			$entree = $info[ $i ];

    339. 

  339. 

    340. 

  340. 			//Correction si l'usager n'a pas de num�ro de t�l�phone dans ldap

    341. 

  341. 			if ( !isset( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) || 

    342. 

  342. 			     !is_array( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) ){

    343. 

  343. 				$entree[ $ldap_var[ 'info' ][ 'telephone' ] ] = array( "" );

    344. 

  344. 			}

    345. 

  345. 

    346. 

  346. 			$sArrayLDAP[ $i ] = array( $entree[ $ldap_var[ 'info' ][ 'nom' ] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'prenom' ] ][ 0 ],

    347. 

  347. 					$entree[ $ldap_var[ 'info' ][ 'email'] ][ 0 ], strtolower( $entree[ $ldap_var[ 'info' ]['lieuID' ] ][ 0 ] ),

    348. 

  348. 					$entree[ $ldap_var[ 'info' ][ 'lieuDescr'] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'telephone'] ][ 0 ],

    349. 

  349. 					$entree[ $ldap_var[ 'info' ][ 'fonction'] ][ 0 ], $entree[ 'dn' ],

    350. 

  350. 					strtolower( $entree[ $ldap_var[ 'db' ][ 'searchKey' ] ][ 0 ] ) );

    351. 

  351. 		}

    352. 

  352. 	}

    353. 

  353. 

    354. 

  354. 	return $codeRetour;

    355. 

  355. }

    356. 

  356. ///////////////////////////////////////////////////////////////////////////////////////

    357. 

  357. // Recherche_LDAP_Import

    358. 

  358. // Recherche des informations selon le filtre sp�cifi�

    359. 

  359. //  IN:     $conLDAP :Connexion au serveur ldap

    360. 

  360. //        $filtre  : filtre de recherche

    361. 

  361. //           &$sArrayLDAP : informations extraites du serveur LDAP    

    362. 

  362. //  OUT:    nb: nb. user retrouv� dans ldap

    363. 

  363. //          0: user non retrouv� dans ldap

    364. 

  364. //           -1: connexion impossible

    365. 

  365. ///////////////////////////////////////////////////////////////////////////////////////

    366. 

  366. function Recherche_LDAP_Import($conLDAP, $filtre, $sArrayLDAP){

    367. 

  367.     global $ldap_var;

    368. 

  368.     $codeRetour = 0;

    369. 

  369.     

    370. 

  370.     //La connexion au serveur LDAP est �tablit on fait un premier bind 

    371. 

  371.     //Si aucun code de bind n'est d�fini on fait un alors un bind anonyme

    372. 

  372.     //sinon on fait une connexion avec un usager ayant lesdroits n�cessaires dans l'annuaire'

    373. 

  373.     if(isset($ldap_var[db][bind_dn])) //Le LDAP n'est pas anonyme

    374. 

  374.     {

    375. 

  375.         $bindLDAP = ldap_bind($conLDAP, $ldap_var[db][bind_dn],$ldap_var[db][bind_pwd]);

    376. 

  376.     } 

    377. 

  377.     else                        //La recherche anonyme est permise

    378. 

  378.     {

    379. 

  379.         $bindLDAP = ldap_bind($conLDAP);

    380. 

  380.     }

    381. 

  381.     

    382. 

  382.     if(!$bindLDAP)    //Bind au serveur LDAP non-r�ussi, on quitte

    383. 

  383.     {

    384. 

  384.         ldap_unbind($conLDAP);    //D�connexion 

    385. 

  385.         $codeRetour = -1;

    386. 

  386.         return $codeRetour;     //Arr�t COMPLET de l'application (-1)

    387. 

  387.     }

    388. 

  388. 

    389. 

  389.     //Liste des variables � retourner lors du search

    390. 

  390.     $restrictions = array($ldap_var[info][nom],

    391. 

  391.                         $ldap_var[info][prenom],

    392. 

  392.                         $ldap_var[info][email],

    393. 

  393.                         $ldap_var[info][lieuID],

    394. 

  394.                         $ldap_var[info][lieuDescr],

    395. 

  395.                         $ldap_var[info][telephone],

    396. 

  396.                         $ldap_var[info][fonction],

    397. 

  397.                         $ldap_var[db][searchKey]);

    398. 

  398.                         

    399. 

  399.     // Aller chercher le dn de l'usager

    400. 

  400.     

    401. 

  401.     $arrayRecherche = ldap_search($conLDAP,$ldap_var[db][searchBase],

    402. 

  402.                     $filtre, $restrictions);

    403. 

  403.     

    404. 

  404.     // Mettre les enregistrements dans un tableau pour le traitement    

    405. 

  405.     $info = ldap_get_entries($conLDAP, $arrayRecherche);

    406. 

  406. 

    407. 

  407.     $codeRetour = count($info) - 1;

    408. 

  408. 

    409. 

  409.     for( $i = 0; is_array($info) && $i < (count($info)-1); $i++){

    410. 

  410. 		$arrayNom[$i]      = changeUTF16($info[$i][$ldap_var[info][nom]][0]);

    411. 

  411. 		$arrayPrenom[$i]    = changeUTF16($info[$i][$ldap_var[info][prenom]][0]);

    412. 

  412. 		$arrayLieuID[$i]    = $info[$i][$ldap_var[info][lieuID]][0];

    413. 

  413. 		$arrayLieuDescr[$i] = changeUTF16($info[$i][$ldap_var[info][lieuDescr]][0]);

    414. 

  414. 		$arrayFonction[$i]  = changeUTF16($info[$i][$ldap_var[info][fonction]][0]);

    415. 

  415. 		$arrayKey[$i]       = $info[$i][$ldap_var[db][searchKey]][0];

    416. 

  416.     }

    417. 

  417. 

    418. 

  418. 	$sArrayLDAP[0] = $arrayNom;

    419. 

  419. 	$sArrayLDAP[1] = $arrayPrenom;

    420. 

  420. 	$sArrayLDAP[2] = $arrayLieuID;

    421. 

  421. 	$sArrayLDAP[3] = $arrayLieuDescr;

    422. 

  422. 	$sArrayLDAP[4] = $arrayFonction;

    423. 

  423. 	$sArrayLDAP[5] = $arrayKey;

    424. 

  424. 

    425. 

  425. 	return $codeRetour;

    426. 

  426. }

    427. 

  427. ///////////////////////////////////////////////////////////////////////////////////////

    428. 

  428. // Retourne la requete SQL necessaire pour faire un SELECT LDAP

    429. 

  429. ///////////////////////////////////////////////////////////////////////////////////////

    430. 

  430. function getSQLStmtReqLieuxLDAP($mot, $motlnk, $adminlieu_id, $tech_id, $valide, $indx){

    431. 

  431.     $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_valide";

    432. 

  432.     $SQLStmt.=" FROM lieu";

    433. 

  433.     $SQLStmt.=" WHERE li_id = li_id";

    434. 

  434.     $SQLStmt.=" AND li_ldap ='t'";

    435. 

  435.     if ($mot!=""){

    436. 

  436.         if ($motlnk!="and" && $motlnk!="or"){

    437. 

  437.             $motlnk="and"; //valeur par defaut : securite

    438. 

  438.         }

    439. 

  439.         $arrMot=getArrayFromStringMot($mot);

    440. 

  440.         $SQLStmt.=" AND (";

    441. 

  441.         for ($i=0; $i<count($arrMot); $i++){

    442. 

  442.             $SQLStmt.="(li_lieu ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    443. 

  443.             $SQLStmt.=" OR li_adresse ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    444. 

  444.             if ($i<count($arrMot)-1){

    445. 

  445.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    446. 

  446.             }

    447. 

  447.         }

    448. 

  448.         $SQLStmt.=")";

    449. 

  449.     }

    450. 

  450.     if (is_numeric($adminlieu_id)){

    451. 

  451.         $SQLStmt.=" AND li_id IN (";

    452. 

  452.             $SQLStmt.=" SELECT li_id";

    453. 

  453.             $SQLStmt.=" FROM lieuadmin";

    454. 

  454.             $SQLStmt.=" WHERE usr_id=".$adminlieu_id;

    455. 

  455.         $SQLStmt.=")";

    456. 

  456.     }

    457. 

  457.     if (is_numeric($tech_id)){

    458. 

  458.         $SQLStmt.=" AND li_id IN (";

    459. 

  459.             $SQLStmt.=" SELECT li_id";

    460. 

  460.             $SQLStmt.=" FROM lieusupport";

    461. 

  461.             $SQLStmt.=" WHERE usr_id=".$tech_id;

    462. 

  462.         $SQLStmt.=")";

    463. 

  463.     }

    464. 

  464.     if ($valide!=""){

    465. 

  465.         if (!strcasecmp($valide,"t")){

    466. 

  466.             $SQLStmt.=" AND li_valide='t'";

    467. 

  467.         }

    468. 

  468.         else{

    469. 

  469.             $SQLStmt.=" AND li_valide='f'";

    470. 

  470.         }

    471. 

  471.     }

    472. 

  472.     if ($indx!=""){

    473. 

  473.         if ($indx=="lieua"){

    474. 

  474.             $SQLStmt.=" ORDER BY li_lieu ASC";

    475. 

  475.         }

    476. 

  476.         elseif ($indx=="lieud"){

    477. 

  477.             $SQLStmt.=" ORDER BY li_lieu DESC";

    478. 

  478.         }

    479. 

  479.         elseif ($indx=="adressea"){

    480. 

  480.             $SQLStmt.=" ORDER BY li_adresse ASC";

    481. 

  481.         }

    482. 

  482.         elseif ($indx=="adressed"){

    483. 

  483.             $SQLStmt.=" ORDER BY li_adresse DESC";

    484. 

  484.         }

    485. 

  485.         elseif ($indx=="trajeta"){

    486. 

  486.             $SQLStmt.=" ORDER BY li_trajet ASC";

    487. 

  487.         }

    488. 

  488.         elseif ($indx=="trajetd"){

    489. 

  489.             $SQLStmt.=" ORDER BY li_trajet DESC";

    490. 

  490.         }

    491. 

  491.         elseif ($indx=="lieunoa"){

    492. 

  492.             $SQLStmt.=" ORDER BY li_no ASC";

    493. 

  493.         }

    494. 

  494.         elseif ($indx=="lieunod"){

    495. 

  495.             $SQLStmt.=" ORDER BY li_no DESC";

    496. 

  496.         }

    497. 

  497.          else

    498. 

  498.         {

    499. 

  499.         	$SQLStmt.=" ORDER BY li_lieu ASC";		// ordre alphabetique de nom par defaut

    500. 

  500.         }

    501. 

  501.    }

    502. 

  502.     return $SQLStmt;

    503. 

  503. }

    504. 

  504. 

    505. 

  505. 

    506. 

  506. ///////////////////////////////////////////////////////////////////////////////////////

    507. 

  507. // Retourne le filtre necessaire pour faire la recherche LDAP par lieu

    508. 

  508. ///////////////////////////////////////////////////////////////////////////////////////

    509. 

  509. function getFiltreUsagersLdap($mot, $li_no){

    510. 

  510.     global $ldap_var;

    511. 

  511.     $filtre.="(&";

    512. 

  512.     if ($mot!=""){

    513. 

  513.         if ($motlnk!="and" && $motlnk!="or"){

    514. 

  514.             $motlnk="and"; //valeur par defaut : securite

    515. 

  515.         }

    516. 

  516.         $arrMot=getArrayFromStringMot($mot);

    517. 

  517.         for ($i=0; $i<count($arrMot); $i++){

    518. 

  518.         $rech = verifMot($mot);

    519. 

  519.         if($rech !="" ){

    520. 

  520.                 $filtre.="(".$ldap_var[info][nom]."=".$rech."*)";

    521. 

  521.         }

    522. 

  522.         }

    523. 

  523.     }

    524. 

  524. 

    525. 

  525. //Lieu recherch�

    526. 

  526.     if ($li_no !=""){

    527. 

  527.         $filtre.="(".$ldap_var[info][lieuID]."=".$li_no.")";

    528. 

  528.     }

    529. 

  529. //Filtre supl�mentaire sp�cial.

    530. 

  530.     $filtre .= $ldap_var[db][filter];

    531. 

  531.     $filtre .=")";

    532. 

  532.     return $filtre;

    533. 

  533. }

    534. 

  534. 

    535. 

  535. ///////////////////////////////////////////////////////////////////////////////////////

    536. 

  536. // verifMot($input)

    537. 

  537. // Enl�ve les caract�res *? de la chaine

    538. 

  538. //  IN:     $input: string qu'on veut v�rifier

    539. 

  539. //  OUT:    string �pur�e

    540. 

  540. ///////////////////////////////////////////////////////////////////////////////////////

    541. 

  541. function verifMot($input){

    542. 

  542. 

    543. 

  543.     $result = strtr($input,"*?","//");

    544. 

  544.     $result = trim($result);

    545. 

  545.     return ($result);

    546. 

  546. }

    547. 

  547. ///////////////////////////////////////////////////////////////////////////////////////

    548. 

  548. // TriArrayLDAP($cle)

    549. 

  549. // Tri le Array de SESSION "UsagerLieuLDAP"(provenant d'une requ�te LDAP)

    550. 

  550. //  IN:     $cle: Cle de tri 

    551. 

  551. //  OUT:    Array de SESSION tri�

    552. 

  552. //            True cle valide  

    553. 

  553. ///////////////////////////////////////////////////////////////////////////////////////

    554. 

  554. function TriArray($cle){

    555. 

  555.     

    556. 

  556.     //Extrait la partie ordre de tri 

    557. 

  557.     $typeTri = substr($cle,-1);

    558. 

  558.     //Ajuste l'ordre pour un tri descendant ou ascendant par d�faut

    559. 

  559.     if($typeTri == "d" || $typeTri == "D"){

    560. 

  560.         $ordre = "SORT_DESC";

    561. 

  561.     }

    562. 

  562.     else {

    563. 

  563.         $ordre = "SORT_ASC";

    564. 

  564.     }

    565. 

  565.     //Extrait la partie du mot qui indique la cle de tri

    566. 

  566.     $cleTri = substr($cle,0, -1);

    567. 

  567.     //Ajuste les cl�s pour un tri par fonction

    568. 

  568.     if($cleTri == "type") {

    569. 

  569.         $cle1 = 4;    //Fonction

    570. 

  570.         $cle2 = 0;    //Nom

    571. 

  571.         $cle3 = 1;    //Prenom

    572. 

  572.         $cle4 = 2;    //LieuID

    573. 

  573.     } 

    574. 

  574.     else if ($cleTri == "lieu") {

    575. 

  575.         $cle1 = 2;    //LieuID

    576. 

  576.         $cle2 = 0;    //Nom

    577. 

  577.         $cle3 = 1;    //Prenom

    578. 

  578.         $cle4 = 4;    //Fonction

    579. 

  579.         

    580. 

  580.     } 

    581. 

  581.     else {        //Tri par d�faut (Nom, Pr�nom, LieuID, Fonction)

    582. 

  582.         $cle1 = 0;  //Nom

    583. 

  583.         $cle2 = 1;    //Prenom

    584. 

  584.         $cle3 = 2;    //LieuID

    585. 

  585.         $cle4 = 4;    //Fonction

    586. 

  586.     }

    587. 

  587.     

    588. 

  588.     //Tri du tableau complet

    589. 

  589.     if($typeTri == "d" || $typeTri == "D"){

    590. 

  590.     array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_DESC, 

    591. 

  591.                     $_SESSION["UsagerLieuLDAP"][$cle2], SORT_DESC,

    592. 

  592.                     $_SESSION["UsagerLieuLDAP"][$cle3], SORT_DESC,

    593. 

  593.                     $_SESSION["UsagerLieuLDAP"][$cle4], SORT_DESC, 

    594. 

  594.                     $_SESSION["UsagerLieuLDAP"][3], 

    595. 

  595.                     $_SESSION["UsagerLieuLDAP"][5]); 

    596. 

  596.     }

    597. 

  597.     else{

    598. 

  598.     array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_ASC, 

    599. 

  599.                     $_SESSION["UsagerLieuLDAP"][$cle2], SORT_ASC,

    600. 

  600.                     $_SESSION["UsagerLieuLDAP"][$cle3], SORT_ASC,

    601. 

  601.                     $_SESSION["UsagerLieuLDAP"][$cle4], SORT_ASC, 

    602. 

  602.                     $_SESSION["UsagerLieuLDAP"][3], 

    603. 

  603.                     $_SESSION["UsagerLieuLDAP"][5]);

    604. 

  604.     }

    605. 

  605.     return (true);

    606. 

  606. }

    607. 

  607. 

    608. 

  608. ///////////////////////////////////////////////////////////////////////////////////////

    609. 

  609. // connextToPG($conn)

    610. 

  610. // �tablit la connexion avec le serveur Postgresql

    611. 

  611. ///////////////////////////////////////////////////////////////////////////////////////

    612. 

  612. function connectToPG( $conn_str ){

    613. 

  613. 	if( !$conn = pg_connect( $conn_str ) ) { bugFromPG( $conn ); };

    614. 

  614. 	return $conn;

    615. 

  615. }

    616. 

  616. 

    617. 

  617. ///////////////////////////////////////////////////////////////////////////////////////

    618. 

  618. // bugFromPG($conn)

    619. 

  619. // m�thode appell�e losrqu'on a un probl�me avec l'ex�cution d'une requ�te ou � �tablir

    620. 

  620. // la connexion avec le serveur Postgresql.

    621. 

  621. ///////////////////////////////////////////////////////////////////////////////////////

    622. 

  622. function bugFromPG($conn){

    623. 

  623.     echo _("Probleme avec la BD PostgreSQL");

    624. 

  624.     echo pg_last_error($conn);

    625. 

  625.     //on quitte tous les script (pas de niasage)

    626. 

  626.     exit;

    627. 

  627. }

    628. 

  628. 

    629. 

  629. ///////////////////////////////////////////////////////////////////////////////////////

    630. 

  630. // changeUTF16($chaine)

    631. 

  631. // m�thode appell�e pour convertir les lignes LDap d'UTF-8 � UTF-16

    632. 

  632. //

    633. 

  633. // IN: $chaine

    634. 

  634. // OUT: retourne la chaine UTF-8 ou ISO-8859-1, convertie en UTF-16

    635. 

  635. ///////////////////////////////////////////////////////////////////////////////////////

    636. 

  636. function changeUTF16( $chaine ){

    637. 

  637.     return mb_convert_encoding( $chaine, "ISO-8859-1","UTF-8" )."\n" ;

    638. 

  638. }

    639. 

  639. 

    640. 

  640. ///////////////////////////////////////////////////////////////////////////////////////

    641. 

  641. // Met un space HTML lorsqu'il n'y aucune valeur a afficher

    642. 

  642. ///////////////////////////////////////////////////////////////////////////////////////

    643. 

  643. function convNoDataToHTMLSpace($value){

    644. 

  644.     if (($value=="") || (!isset($value))){

    645. 

  645.         return("&nbsp;");

    646. 

  646.     }

    647. 

  647.     else{

    648. 

  648.         return($value);

    649. 

  649.     }

    650. 

  650. }

    651. 

  651. 

    652. 

  652. ///////////////////////////////////////////////////////////////////////////////////////

    653. 

  653. // fillArrFromDBStd($conn, $sqlstmt, $arrVal0 = NULL, $arrVal1 = NULL, ...)

    654. 

  654. // remplit les tableaux de variables re�u en param�tre avec la valeur des

    655. 

  655. // rang�es retourn�es par la requ�te sql fournie en param�tre

    656. 

  656. // ATTENTION :  l'ordre des variables sp�cifi�es en param�tre doit �tre le m�me

    657. 

  657. //              que l'odre des champs dans la requ�te

    658. 

  658. //              [SUPPORTE 40 tableaux]

    659. 

  659. //  IN:     $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    660. 

  660. //          $sqlstmt: requ�te SQL � ex�cuter

    661. 

  661. //          $arrVal1: 1er tableau � remplir

    662. 

  662. //          $arrVal2: 2e tableau � remplir

    663. 

  663. //          $arrValX: Xe tableau � remplir

    664. 

  664. //  OUT:    -1: erreur lors de l'ex�cution de la requ�te

    665. 

  665. //          (int): nb de rang�es r�sultantes de la requ�te

    666. 

  666. ///////////////////////////////////////////////////////////////////////////////////////

    667. 

  667. 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){

    668. 

  668. 	$nbRow = -1;

    669. 

  669. 

    670. 

  670. 	// tableau dynamique

    671. 

  671. 	$nbArray = func_num_args() - 2;

    672. 

  672. 	for( $i = 0; $i < $nbArray; $i++ ){

    673. 

  673. 		$name = "arrVal" . $i;

    674. 

  674. 		$args[ $i ] =& $$name;

    675. 

  675. 

    676. 

  676. 		// S'assure que ce qui sera retourn� sera au moins un tableau vide

    677. 

  677. 		if( is_null( $args[ $i ] ) ){

    678. 

  678. 			$args[ $i ] = array();

    679. 

  679. 		}

    680. 

  680. 	}

    681. 

  681. 

    682. 

  682. 	// bd time

    683. 

  683. 	$result = pg_query( $conn, $sqlstmt );

    684. 

  684. 	if( $result > 0 ){

    685. 

  685. 		$nbRow = pg_num_rows( $result );

    686. 

  686. 		$nbLoop = min( $nbArray, pg_num_fields( $result ) );

    687. 

  687. 

    688. 

  688. 		for( $iRow = 0; $iRow < $nbRow; $iRow++ ){

    689. 

  689. 			for( $iCol = 0; $iCol < $nbLoop; $iCol++ ){

    690. 

  690. 				$args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );

    691. 

  691. 			}

    692. 

  692. 		}

    693. 

  693. 		pg_free_result( $result );

    694. 

  694. 	}

    695. 

  695. 	return $nbRow;

    696. 

  696. }

    697. 

  697. 

    698. 

  698. ///////////////////////////////////////////////////////////////////////////////////////

    699. 

  699. // fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $arrVal0 = NULL, $arrVal1 = NULL, ...)

    700. 

  700. // remplit les tableaux de variables re�us en param�tre avec la valeur des

    701. 

  701. // rang�es retourn�es par la requ�te sql fournie en param�tre. De plus

    702. 

  702. // ce type de requ�te tient compte de la notion des pages. On peut donc 

    703. 

  703. // se positionner sur la Xe page de r�sultat directement

    704. 

  704. // ATTENTION :  l'ordre des variables sp�cifi�es en param�tre doit �tre le m�me

    705. 

  705. //              que l'odre des champs dans la requ�te

    706. 

  706. //              [SUPPORTE 40 tableaux]

    707. 

  707. //  IN:     $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    708. 

  708. //          $sqlstmt: requ�te SQL � ex�cuter

    709. 

  709. //          $page_no: quelle page on veut se positionner

    710. 

  710. //          $pgSize: la grandeur des page (nb d'enregistrement par page)

    711. 

  711. //          $page_size: nb de page r�sultant de la requ�te

    712. 

  712. //          $nbRecordTotal: nb d'enregistrement r�sultant de la requ�te

    713. 

  713. //          $arrVal1: 1er tableau � remplir

    714. 

  714. //          $arrVal2: 2e tableau � remplir

    715. 

  715. //          $arrValX: Xe tableau � remplir

    716. 

  716. //  OUT:    -1: erreur lors de l'ex�cution de la requ�te

    717. 

  717. //          (int >= 0): nb de rang�es r�sultantes de la requ�te

    718. 

  718. ///////////////////////////////////////////////////////////////////////////////////////

    719. 

  719. function fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $arrVal0 = NULL, $arrVal1 = NULL, $arrVal2 = NULL,

    720. 

  720. 		$arrVal3 = NULL, $arrVal4 = NULL, $arrVal5 = NULL, $arrVal6 = NULL, $arrVal7 = NULL, $arrVal8 = NULL, $arrVal9 = NULL, $arrVal10 = NULL,

    721. 

  721. 		$arrVal11 = NULL, $arrVal12 = NULL, $arrVal13 = NULL, $arrVal14 = NULL, $arrVal15 = NULL, $arrVal16 = NULL, $arrVal17 = NULL,

    722. 

  722. 		$arrVal18 = NULL, $arrVal19 = NULL, $arrVal20 = NULL, $arrVal21 = NULL, $arrVal22 = NULL, $arrVal23 = NULL, $arrVal24 = NULL,

    723. 

  723. 		$arrVal25 = NULL, $arrVal26 = NULL, $arrVal27 = NULL, $arrVal28 = NULL, $arrVal29 = NULL, $arrVal30 = NULL, $arrVal31 = NULL,

    724. 

  724. 		$arrVal32 = NULL, $arrVal33 = NULL, $arrVal34 = NULL, $arrVal35 = NULL, $arrVal36 = NULL, $arrVal37 = NULL, $arrVal38 = NULL, $arrVal39 = NULL){

    725. 

  725. 	$retour = -1;

    726. 

  726. 

    727. 

  727. 	// Cr�ation d'un tableau dynamique de pointeurs vers les tableaux de valeurs re�ues

    728. 

  728. 	$nbArray = func_num_args()-2;

    729. 

  729. 	for( $i = 0; $i < $nbArray; $i++ ){

    730. 

  730. 		$name = "arrVal" . $i;

    731. 

  731. 		$args[ $i ] = &$$name;

    732. 

  732. 	}

    733. 

  733. 

    734. 

  734. 	// Fait la requ�te en �tant tout ce qui suit "ORDER BY"

    735. 

  735. 	if( $result = pg_query( $conn, eregi_replace( " ORDER BY .*" , "", $sqlstmt ) ) ){

    736. 

  736. 		$retour = 0;

    737. 

  737. 		$nbRecordTotal = pg_num_rows( $result );

    738. 

  738. 		if( $nbRecordTotal > 0 ){

    739. 

  739. 			$nbPage = ceil( $nbRecordTotal / $page_size );

    740. 

  740. 			$limit = $page_size;

    741. 

  741. 			if (isset($page_no) )

    742. 

  742. 				$offset = ( $page_no - 1 ) * $page_size;

    743. 

  743. 			else

    744. 

  744. 				$offset = 0;

    745. 

  745. 

    746. 

  746. 			// on refait la requ�te avec des nouveaux param�tres

    747. 

  747. 			$result = pg_query( $conn, $sqlstmt . " LIMIT " . $limit . " OFFSET " . $offset );

    748. 

  748. 			$nbRow = pg_num_rows($result);

    749. 

  749. 			$nbCol = min( $nbArray, pg_num_fields( $result ) );

    750. 

  750. 			for( $iRow = 0; $iRow < $nbRow; $iRow++ ){

    751. 

  751. 				for( $iCol=0; $iCol < $nbCol; $iCol++ ){

    752. 

  752. 					$args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );

    753. 

  753. 				}

    754. 

  754. 			}

    755. 

  755. 			pg_free_result( $result ); // Lib�re la m�moire inutilis�e

    756. 

  756. 			$retour = $nbRow;

    757. 

  757. 		}

    758. 

  758. 	}

    759. 

  759. 

    760. 

  760. 	return $retour;

    761. 

  761. }

    762. 

  762. 

    763. 

  763. ///////////////////////////////////////////////////////////////////////////////////////

    764. 

  764. // fillVarFromDBStd($conn, $sqlstmt, &$val1, &$val2, &$val3)

    765. 

  765. // remplit les variables re�ues en param�tre avec la valeur de la premi�re

    766. 

  766. // rang�e du r�sultat de la requ�te (arrangez vous pour que la requ�te

    767. 

  767. // sql n'ait qu'une seule rang�e de r�sultat)

    768. 

  768. // ATTENTION :  l'ordre des variables sp�cifi�es en param�tre doit �tre le m�me

    769. 

  769. //              que l'odre des champs dans la requ�te  

    770. 

  770. //              [SUPPORTE 40 variables]

    771. 

  771. //  IN:     $conn: objet de connexion avec la db (doit �tre d�j� ouvert)

    772. 

  772. //          $sqlstmt: requ�te SQL � ex�cuter

    773. 

  773. //          $val1: 1ere variable � remplir

    774. 

  774. //          $val2: 2e variable � remplir

    775. 

  775. //          $valX: Xe variable � remplir

    776. 

  776. ///////////////////////////////////////////////////////////////////////////////////////

    777. 

  777. 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){

    778. 

  778.     // tableau dynamique

    779. 

  779.     $nbVariable = func_num_args()-2;

    780. 

  780.     for ($i=0; $i<$nbVariable; $i++){

    781. 

  781.         $name = "val" . $i;

    782. 

  782.         $args[$i]=&$$name;

    783. 

  783.     }

    784. 

  784.     //echo "fillVarFromDBStd: " .  $sqlstmt . "<br>";

    785. 

  785.     $result = pg_query($conn, $sqlstmt);

    786. 

  786.     if (!$result){ bugFromPG($conn); }

    787. 

  787.     if($result>0){

    788. 

  788.         $nbRow=pg_num_rows($result);

    789. 

  789.         $nbLoop=min($nbVariable,pg_num_fields($result));

    790. 

  790.         if($nbRow==1){

    791. 

  791.             for($iCol=0; $iCol<$nbLoop; $iCol++){

    792. 

  792.                 $args[$iCol]=pg_result($result, 0, $iCol);

    793. 

  793.             }

    794. 

  794.             pg_free_result($result);

    795. 

  795.             return(true);

    796. 

  796.         }

    797. 

  797.         pg_free_result($result);

    798. 

  798.     }

    799. 

  799.     return(false);

    800. 

  800. }

    801. 

  801. 

    802. 

  802. ///////////////////////////////////////////////////////////////////////////////////////

    803. 

  803. // fixPGQuote($input)

    804. 

  804. // fixe les quote pour que la requ�te demeure s�curitaire dans postgres..

    805. 

  805. //  IN:     $input: string qu'on veut s�curiser

    806. 

  806. //  OUT:    string s�curis�

    807. 

  807. ///////////////////////////////////////////////////////////////////////////////////////

    808. 

  808. function fixPGQuote($input){

    809. 

  809. 	// Peut �tre remplac� par 'pg_escape_string' mais doit �tre utilis� avec une connexion � Postgres 7.2

    810. 

  810.     return (addslashes($input));

    811. 

  811. }

    812. 

  812. 

    813. 

  813. ///////////////////////////////////////////////////////////////////////////////////////

    814. 

  814. // getWordStemRegExp()

    815. 

  815. // Retourne une expression reguliere qui permet de reconnaitre le debut d'un mot

    816. 

  816. // a l'interieur d'une chaine quelconque.

    817. 

  817. //  OUT:    expression reguliere

    818. 

  818. ///////////////////////////////////////////////////////////////////////////////////////

    819. 

  819. function getWordStemRegExp(){

    820. 

  820. 	// Tout caractere pouvant se trouver au debut d'un mot.

    821. 

  821.     return( "[ -.,?!:;([\']" );

    822. 

  822. }

    823. 

  823. 

    824. 

  824. ///////////////////////////////////////////////////////////////////////////////////////

    825. 

  825. // accentInsensitiveLike()

    826. 

  826. // Retourne une chaine pouvant remplacer une expression LIKE ou ILIKE afin

    827. 

  827. // d'effectuer un "pattern matching".

    828. 

  828. // Les expressions r�guli�res sont beaucoup plus rapides que LIKE ou ILIKE

    829. 

  829. //  IN: $field_name  Nom du champ

    830. 

  830. //      $field_value Valeur du champ

    831. 

  831. //      $case_insensitive true si l'on veut que la comparaison ne tienne pas compte

    832. 

  832. //                        de la casse

    833. 

  833. //  OUT: clause SQL

    834. 

  834. ///////////////////////////////////////////////////////////////////////////////////////

    835. 

  835. function accentInsensitiveLike($field_name, $field_value, $case_insensitive = true) {

    836. 

  836. 	$regexp_op = ( $case_insensitive == true ) ? "~*" : "~";

    837. 

  837. 

    838. 

  838. 	// 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

    839. 

  839. 	return "( " . $field_name . " " . $regexp_op . " E'^" . $field_value . "|[^\w]" . $field_value . "' )";

    840. 

  840. }

    841. 

  841. 

    842. 

  842. ///////////////////////////////////////////////////////////////////////////////////////

    843. 

  843. // flushCourriel()

    844. 

  844. // Envoit tous les courriels qui devraient etre envoyes

    845. 

  845. ///////////////////////////////////////////////////////////////////////////////////////

    846. 

  846. function flushCourriel(){

    847. 

  847. 	//echo "Les courriels n'ont pas �t� flush�s par le fichier 'forticFunctions.php'.";

    848. 

  848. }

    849. 

  849. 

    850. 

  850. ///////////////////////////////////////////////////////////////////////////////////////

    851. 

  851. // formatCR($sTemp)

    852. 

  852. // formate la sortie de mani�re � remplacer les CR par des <br>  (les ENTERS)

    853. 

  853. //  IN:     $sTemp: string � afficher

    854. 

  854. //  OUT:    (string) le r�sultat du string une fois format�

    855. 

  855. ///////////////////////////////////////////////////////////////////////////////////////

    856. 

  856. function formatCR($sTemp){

    857. 

  857.     return (str_replace("\r","<br/>",$sTemp));

    858. 

  858. }

    859. 

  859. 

    860. 

  860. ///////////////////////////////////////////////////////////////////////////////////////

    861. 

  861. // Set le format d'affichage pour les dates.

    862. 

  862. ///////////////////////////////////////////////////////////////////////////////////////

    863. 

  863. function formatDate($dTemp, $format){

    864. 

  864.     if ( (isDate($dTemp)) || (isTimeStamp($dTemp)) ){

    865. 

  865.         return date($format,strtotime($dTemp));

    866. 

  866.     }

    867. 

  867.     else{

    868. 

  868.         return $dTemp;

    869. 

  869.     }

    870. 

  870. }

    871. 

  871. 

    872. 

  872. ///////////////////////////////////////////////////////////////////////////////////////

    873. 

  873. // Set le format d'affichage pour les dates.

    874. 

  874. ///////////////////////////////////////////////////////////////////////////////////////

    875. 

  875. function formatDateInterval($dTemp1, $dTemp2, $style, $dateFormat, $timeFormat){

    876. 

  876.     if ($style=="date"){

    877. 

  877.         if  ( ((isDate($dTemp1))||(isTimeStamp($dTemp1))) && ((isDate($dTemp2))||(isTimeStamp($dTemp2))) ){

    878. 

  878.             $sDateTemp1 = date($dateFormat, strtotime($dTemp1));

    879. 

  879.             $sDateTemp2 = date($dateFormat, strtotime($dTemp2));

    880. 

  880.             if ($sDateTemp1 != $sDateTemp2){

    881. 

  881.                 $output = $sDateTemp1." "._("au")." ".$sDateTemp2;

    882. 

  882.             }

    883. 

  883.             else{

    884. 

  884.                 $output = $sDateTemp1;

    885. 

  885.             }

    886. 

  886.         }

    887. 

  887.         elseif( (isDate($dTemp1))||(isTimeStamp($dTemp1)) ){

    888. 

  888.             $sDateTemp1 = date($dateFormat, strtotime($dTemp1));

    889. 

  889.             $output = $sDateTemp1." "._("au")." "._("n/a");

    890. 

  890.         }

    891. 

  891.         elseif( (isDate($dTemp2))||(isTimeStamp($dTemp2)) ){

    892. 

  892.             $sDateTemp2 = date($dateFormat, strtotime($dTemp2));

    893. 

  893.             $output = _("n/a")." "._("au")." ".$sDateTemp2;

    894. 

  894.         }

    895. 

  895.         else{

    896. 

  896.             $output = _("dates indeterminees");

    897. 

  897.         }

    898. 

  898.     }

    899. 

  899.     elseif ($style=="time"){

    900. 

  900.         if ( (isTimeStamp($dTemp1)) && (isTimeStamp($dTemp2)) ){

    901. 

  901.             $sDateTemp1 = date($dateFormat, strtotime($dTemp1));

    902. 

  902.             $sDateTemp2 = date($dateFormat, strtotime($dTemp2));

    903. 

  903.             $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));

    904. 

  904.             $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));

    905. 

  905.             if ($sDateTemp1 == $sDateTemp2){

    906. 

  906.                 $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2;

    907. 

  907.             }

    908. 

  908.             else{

    909. 

  909.                 $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2." (".$sDateTemp1.")";

    910. 

  910.             }

    911. 

  911.         }

    912. 

  912.         elseif( (isTimeStamp($dTemp1))||(isTimeStamp($dTemp1)) ){

    913. 

  913.             $sDateTemp1 = date($dateFormat, strtotime($dTemp1));

    914. 

  914.             $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));

    915. 

  915.             $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." "._("n/a");

    916. 

  916.         }

    917. 

  917.         elseif( (isTimeStamp($dTemp2))||(isTimeStamp($dTemp2)) ){

    918. 

  918.             $sDateTemp2 = date($dateFormat, strtotime($dTemp2));

    919. 

  919.             $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));

    920. 

  920.             $output = _("n/a")." "._("a")." ".$sDateTemp2." ".$sTimeTemp2;

    921. 

  921.         }

    922. 

  922.         else{

    923. 

  923.             $output = _("moment indetermine");

    924. 

  924.         }

    925. 

  925.     }

    926. 

  926.     return $output;

    927. 

  927. }

    928. 

  928. 

    929. 

  929. ///////////////////////////////////////////////////////////////////////////////////////

    930. 

  930. // function formatDateLimite($dTemp, $dTempDisplay, $classOK="", $classNOT="", $classHOPE="")

    931. 

  931. // affiche la datelimite en couleur

    932. 

  932. ///////////////////////////////////////////////////////////////////////////////////////

    933. 

  933. function formatDateLimite( $dTemp, $format, $classOK = "", $classNOT = "", $classHOPE = "" ){

    934. 

  934. 	$output = "";

    935. 

  935. 	$class = "";

    936. 

  936. 	if( isDate( $dTemp ) ){

    937. 

  937. 		$today = strtotime( date( "Y-m-d" ) );

    938. 

  938. 		$limite = strtotime( $dTemp );

    939. 

  939. 

    940. 

  940. 		// Si la date limite n'est pas arriv� ou qu'elle est aujourd'hui et qu'on ne re�oit pas de classe HOPE

    941. 

  941. 		if( ( $today < $limite || ( $today == $limite && $classHOPE == "" ) ) && $classOK != "" ){

    942. 

  942. 			$class = $classOK;

    943. 

  943. 		// Si la date limite est d�pass�e

    944. 

  944. 		} elseif( $today > $limite && $classNOT != "" ){

    945. 

  945. 			$class = $classNOT;

    946. 

  946. 		// Si la date limite est aujourd'hui

    947. 

  947. 		} elseif( $today == $limite && $classHOPE != "" ){

    948. 

  948. 			$class = $classHOPE;

    949. 

  949. 		}

    950. 

  950. 

    951. 

  951. 		$output = formatDate( $dTemp, $format );

    952. 

  952. 		if( $class != "" ){

    953. 

  953. 			$output = "<span class='" . $class . "'>" . $output . "</span>";

    954. 

  954. 		}

    955. 

  955. 	}

    956. 

  956. 	return $output;

    957. 

  957. }

    958. 

  958. 

    959. 

  959. ///////////////////////////////////////////////////////////////////////////////////////

    960. 

  960. // function formatGabaritSub($sInput, $class=NULL)

    961. 

  961. // formate la sortie pour qu'on puisse voir si c'est un sous-gabarit

    962. 

  962. //  IN:     $sInput:        t ou f : designant si system

    963. 

  963. //  OUT:    (string)        ce qu'on affiche sur la page

    964. 

  964. ///////////////////////////////////////////////////////////////////////////////////////

    965. 

  965. function formatGabaritSub($sInput, $class=NULL){

    966. 

  966.     $state1=_("sous-gabarit");

    967. 

  967.     $state2=_("gabarit");

    968. 

  968.     if ($sInput=="t"){

    969. 

  969.         if ($class!=""){

    970. 

  970.             $output="<span class=\"".$class."\">".$state1."</span>";

    971. 

  971.         }

    972. 

  972.         else{

    973. 

  973.             $output=$state1;

    974. 

  974.         }

    975. 

  975.     }

    976. 

  976.     else{

    977. 

  977.         if ($class!=""){

    978. 

  978.             $output="<span class=\"".$class."\">".$state2."</span>";

    979. 

  979.         }

    980. 

  980.         else{

    981. 

  981.             $output=$state2;

    982. 

  982.         }

    983. 

  983.     }

    984. 

  984.     return $output;

    985. 

  985. }

    986. 

  986. 

    987. 

  987. ///////////////////////////////////////////////////////////////////////////////////////

    988. 

  988. // function formatGabaritSystem($sInput, $class=NULL)

    989. 

  989. // formate la sortie pour qu'on puisse voir si c'est un gabarit system

    990. 

  990. //  IN:     $sInput:        t ou f : designant si system

    991. 

  991. //  OUT:    (string)        ce qu'on affiche sur la page

    992. 

  992. ///////////////////////////////////////////////////////////////////////////////////////

    993. 

  993. function formatGabaritSystem($sInput, $class=NULL){

    994. 

  994.     $state="("._("Systeme").")";

    995. 

  995.     if ($sInput=="t"){

    996. 

  996.         if ($class!=""){

    997. 

  997.             $output="<span class=\"".$class."\">".$state."</span>";

    998. 

  998.         }

    999. 

  999.         else{

    1000. 

  1000.             $output=$state;

    1001. 

  1001.         }

    1002. 

  1002.     }

    1003. 

  1003.     return $output;

    1004. 

  1004. }

    1005. 

  1005. 

    1006. 

  1006. ///////////////////////////////////////////////////////////////////////////////////////

    1007. 

  1007. // formatHTML($sTemp)

    1008. 

  1008. // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de

    1009. 

  1009. // mot r�serv� propore au html.

    1010. 

  1010. //  IN:     $sTemp:             string � afficher

    1011. 

  1011. //  OUT:    (string)            le r�sultat du string une fois format�

    1012. 

  1012. ///////////////////////////////////////////////////////////////////////////////////////

    1013. 

  1013. function formatHTML($sTemp){

    1014. 

  1014.     return (htmlentities($sTemp));

    1015. 

  1015. }

    1016. 

  1016. 

    1017. 

  1017. ///////////////////////////////////////////////////////////////////////////////////////

    1018. 

  1018. // formatJS($sTemp)

    1019. 

  1019. // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de

    1020. 

  1020. // mot r�serv� propore au html.

    1021. 

  1021. //  IN:     $sTemp: string � afficher

    1022. 

  1022. //  OUT:    (string) le r�sultat du string une fois format�

    1023. 

  1023. ///////////////////////////////////////////////////////////////////////////////////////

    1024. 

  1024. function formatJS($sTemp){

    1025. 

  1025.     return (addslashes($sTemp));

    1026. 

  1026. }

    1027. 

  1027. 

    1028. 

  1028. ///////////////////////////////////////////////////////////////////////////////////////

    1029. 

  1029. // Set le format d'affichage d'un nom.

    1030. 

  1030. ///////////////////////////////////////////////////////////////////////////////////////

    1031. 

  1031. function formatName($sNom, $sPrenom){

    1032. 

  1032.     if (($sNom!="") && ($sPrenom!="")){

    1033. 

  1033.         return (strtoupper($sNom).", ".$sPrenom);

    1034. 

  1034.     }

    1035. 

  1035.     elseif ($sNom!=""){

    1036. 

  1036.         return (strtoupper($sNom));

    1037. 

  1037.     }

    1038. 

  1038.     elseif ($sPrenom!=""){

    1039. 

  1039.         return ($sPrenom);

    1040. 

  1040.     }

    1041. 

  1041.     else{

    1042. 

  1042.         return ( _("sans nom") );

    1043. 

  1043.     }

    1044. 

  1044. }

    1045. 

  1045. 

    1046. 

  1046. //S.C. 2007-03-28 demande #37 Ajout de la fonction formatNameLieu

    1047. 

  1047. ///////////////////////////////////////////////////////////////////////////////////////

    1048. 

  1048. // Set le format d'affichage d'un nom et le # lieu de travail

    1049. 

  1049. ///////////////////////////////////////////////////////////////////////////////////////

    1050. 

  1050. function formatNameLieu($sNom, $sPrenom, $sLieu){

    1051. 

  1051.     if (($sNom!="") && ($sPrenom!="") && ($sLieu!="")){

    1052. 

  1052.         return (strtoupper($sNom).", ".$sPrenom." (".$sLieu.")");

    1053. 

  1053.     }

    1054. 

  1054.     if (($sNom!="") && ($sPrenom!="")){

    1055. 

  1055.         return (strtoupper($sNom).", ".$sPrenom);

    1056. 

  1056.     }

    1057. 

  1057.     elseif ($sNom!=""){

    1058. 

  1058.         return (strtoupper($sNom));

    1059. 

  1059.     }

    1060. 

  1060.     elseif ($sPrenom!=""){

    1061. 

  1061.         return ($sPrenom);

    1062. 

  1062.     }

    1063. 

  1063.     elseif ($sLieu!=""){

    1064. 

  1064.         return ($sLieu);

    1065. 

  1065.     }

    1066. 

  1066.     else{

    1067. 

  1067.         return ( _("vide") );

    1068. 

  1068.     }

    1069. 

  1069. }

    1070. 

  1070. 

    1071. 

  1071. ///////////////////////////////////////////////////////////////////////////////////////

    1072. 

  1072. // function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL)

    1073. 

  1073. // formate le nombre d'inscription. Losrque c'est plein, ou pas plein, on a la possibilit�

    1074. 

  1074. // de changer le style sheet (couleur ou autres)

    1075. 

  1075. //  IN:     $nbIns      nombre de personne actuellement inscrit

    1076. 

  1076. //          $nbMax      nombre maximal de personne

    1077. 

  1077. //          $classOK    class si le nombre de personne permet l'inscription encore

    1078. 

  1078. //          $classNOT   class si la session est pleine

    1079. 

  1079. //  OUT:    (string) le r�sultat du string une fois format�

    1080. 

  1080. ///////////////////////////////////////////////////////////////////////////////////////

    1081. 

  1081. function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL){

    1082. 

  1082.     unset($output);

    1083. 

  1083.     if (is_numeric($nbIns) && is_numeric($nbMax)){

    1084. 

  1084.         if ($nbIns < $nbMax){

    1085. 

  1085.             $class = $classOK;

    1086. 

  1086.         }

    1087. 

  1087.         else{

    1088. 

  1088.             $class = $classNOT;

    1089. 

  1089.         }

    1090. 

  1090.         //output

    1091. 

  1091.         if ($class!=""){

    1092. 

  1092.             $output = "<span class=\"".$class."\">".$nbIns."/".$nbMax."</span>";

    1093. 

  1093.         }

    1094. 

  1094.         else{

    1095. 

  1095.             $output = $nbIns."/".$nbMax;

    1096. 

  1096.         }

    1097. 

  1097.     }

    1098. 

  1098.     return $output;

    1099. 

  1099. }

    1100. 

  1100. 

    1101. 

  1101. ///////////////////////////////////////////////////////////////////////////////////////

    1102. 

  1102. // formatNote($sNote $class)

    1103. 

  1103. // Set le format d'affichage pour les notes de sessions

    1104. 

  1104. //  IN:     $sNote      note � �crire

    1105. 

  1105. //          $class      est-ce qu'il y a une classe auquel on veux lier (CSS)

    1106. 

  1106. //  OUT:    (string)    affichage du code avec l'atelier et le projet

    1107. 

  1107. ///////////////////////////////////////////////////////////////////////////////////////

    1108. 

  1108. function formatNote( $sNote, $class = "" ){

    1109. 

  1109. 	if ( $sNote != "" ){

    1110. 

  1110. 		$sNote = "(" . $sNote . ")";

    1111. 

  1111. 		if ( $class != "" ){

    1112. 

  1112. 			$sNote = "<span class='" . $class . "'>" . $sNote . "</span>";

    1113. 

  1113. 		}

    1114. 

  1114. 	}

    1115. 

  1115. 

    1116. 

  1116. 	return $sNote;

    1117. 

  1117. }

    1118. 

  1118. 

    1119. 

  1119. ///////////////////////////////////////////////////////////////////////////////////////

    1120. 

  1120. // formatParamString($sParam, $sParamValeur)

    1121. 

  1121. // Set le format les parametre SQL et leurs valeurs

    1122. 

  1122. //  IN:     $sParam:            string contenant les parametres SQL separes par des virgules

    1123. 

  1123. //          $sParameValeur:     string contenant les valeurs des parametres SQL separees par des virgules

    1124. 

  1124. //  OUT:    (string)            une belle ligne qui nous fait le resume

    1125. 

  1125. ///////////////////////////////////////////////////////////////////////////////////////

    1126. 

  1126. function formatParamString($sParam, $sParamValeur){

    1127. 

  1127.     unset($output);

    1128. 

  1128.     if (($sParam!="") || ($sParamValeur!= "")){

    1129. 

  1129.         $arrParam = split(",", $sParam);

    1130. 

  1130.         $arrParamValeur = split(",", $sParamValeur);

    1131. 

  1131.         unset($arrOutput);

    1132. 

  1132.         for ($i=0; $i<count($arrParam); $i++){

    1133. 

  1133.             $arrOutput[$i] = $arrParam[$i]." = ".$arrParamValeur[$i];

    1134. 

  1134.         }

    1135. 

  1135.         $output = join(", ", $arrOutput);

    1136. 

  1136.     }

    1137. 

  1137.     return $output;

    1138. 

  1138. }

    1139. 

  1139. 

    1140. 

  1140. ///////////////////////////////////////////////////////////////////////////////

    1141. 

  1141. // function formatPresence

    1142. 

  1142. // Retourne une chaine approprie dependamment du statut de presence recu.

    1143. 

  1143. //  IN:     $sTemp:             (oui, non, ind)

    1144. 

  1144. //          $sTemp              statut de presence

    1145. 

  1145. //          $expire             assume une expiration de date

    1146. 

  1146. //  OUT:    (string)            le r�sultat du string une fois format�

    1147. 

  1147. ///////////////////////////////////////////////////////////////////////////////

    1148. 

  1148. function formatPresence($sTemps, $statut, $expire) {

    1149. 

  1149. 	if( $statut == "t" ) {

    1150. 

  1150. 		$output = $sTemps[0];

    1151. 

  1151. 	}

    1152. 

  1152. 	else if( $statut == "f" ) {

    1153. 

  1153. 		$output = $sTemps[1];

    1154. 

  1154. 	}

    1155. 

  1155. 	else {

    1156. 

  1156. 		$output = $expire ? $sTemps[1] : $sTemps[2];

    1157. 

  1157. 	}

    1158. 

  1158. 	

    1159. 

  1159. 	return $output;

    1160. 

  1160. }

    1161. 

  1161. 

    1162. 

  1162. ///////////////////////////////////////////////////////////////////////////////////////

    1163. 

  1163. // function formatRequeteSQL

    1164. 

  1164. // formate la sortie pour qu'on puisse afficher du code SQL lisible.

    1165. 

  1165. //  IN:     $sTemp:             string � afficher

    1166. 

  1166. //  OUT:    (string)            le r�sultat du string une fois format�

    1167. 

  1167. ///////////////////////////////////////////////////////////////////////////////////////

    1168. 

  1168. function formatRequeteSQL($sTemp){

    1169. 

  1169.     $output=$sTemp;

    1170. 

  1170.     $output=str_replace(" FROM ", "\rFROM ", $output);

    1171. 

  1171.     $output=str_replace(" from ", "\rFROM ", $output);

    1172. 

  1172.     $output=str_replace(" WHERE ", "\rWHERE ", $output);

    1173. 

  1173.     $output=str_replace(" where ", "\rWHERE ", $output);

    1174. 

  1174.     $output=str_replace(" AND ", "\rAND ", $output);

    1175. 

  1175.     $output=str_replace(" and ", "\rAND ", $output);

    1176. 

  1176.     $output=str_replace(" OR ", "\rOR ", $output);

    1177. 

  1177.     $output=str_replace(" or ", "\rOR ", $output);

    1178. 

  1178.     $output=str_replace(" GROUP BY ", "\rGROUP BY ", $output);

    1179. 

  1179.     $output=str_replace(" group by ", "\rGROUP BY ", $output);

    1180. 

  1180.     $output=str_replace(" ORDER BY ", "\rORDER BY ", $output);

    1181. 

  1181.     $output=str_replace(" order by ", "\rORDER BY ", $output);

    1182. 

  1182.     //$output=wordwrap($output, $width, "\r");

    1183. 

  1183.     return $output;

    1184. 

  1184. }

    1185. 

  1185. 

    1186. 

  1186. ///////////////////////////////////////////////////////////////////////////////////////

    1187. 

  1187. // formatSeance($sSesCode, $sAtelier, $sProjet, $sSeaCode)

    1188. 

  1188. // Set le format d'affichage pour les codes de sessions

    1189. 

  1189. //  IN:     $sCode      code de session

    1190. 

  1190. //          $sAtelier   nom de l'atelier parent

    1191. 

  1191. //          $sProjet    projet parent

    1192. 

  1192. //  OUT:    (string)    affichage du code avec l'atelier et le projet

    1193. 

  1193. ///////////////////////////////////////////////////////////////////////////////////////

    1194. 

  1194. function formatSeance($sSesCode, $sAtelier, $sProjet, $sSeaCode){

    1195. 

  1195.     $session = formatSession($sSesCode, $sAtelier, $sProjet);

    1196. 

  1196.     return ($session." : "._("seance")." ".$sSeaCode);

    1197. 

  1197. }

    1198. 

  1198. 

    1199. 

  1199. ///////////////////////////////////////////////////////////////////////////////////////

    1200. 

  1200. // formatSession($sSesCode, $sAtelier, $sProjet)

    1201. 

  1201. // Set le format d'affichage pour les codes de sessions

    1202. 

  1202. //  IN:     sSesCode    code de session

    1203. 

  1203. //          $sAtelier   nom de l'atelier parent

    1204. 

  1204. //          $sProjet    projet parent

    1205. 

  1205. //  OUT:    (string)    affichage du code avec l'atelier et le projet

    1206. 

  1206. ///////////////////////////////////////////////////////////////////////////////////////

    1207. 

  1207. function formatSession($sSesCode, $sAtelier, $sProjet){

    1208. 

  1208.     if( ( $sSesCode != "" ) && ( $sAtelier != "" ) ){

    1209. 

  1209. 		return ($sSesCode." [".$sAtelier."]");

    1210. 

  1210.     } else {

    1211. 

  1211. 		return $sSesCode;

    1212. 

  1212.     }

    1213. 

  1213. }

    1214. 

  1214. 

    1215. 

  1215. ///////////////////////////////////////////////////////////////////////////////////////

    1216. 

  1216. // formatSessionCode($sSesCode, $sAtelier, $sProjet)

    1217. 

  1217. // Set le format d'affichage pour les codes de sessions

    1218. 

  1218. //  IN:     sSesCode    code de session

    1219. 

  1219. //          $sAtelier   nom de l'atelier parent

    1220. 

  1220. //          $sProjet    projet parent

    1221. 

  1221. //  OUT:    (string)    affichage du code de la session

    1222. 

  1222. ///////////////////////////////////////////////////////////////////////////////////////

    1223. 

  1223. function formatSessionCode($sSesCode, $sAtelier, $sProjet){

    1224. 

  1224. 	return $sSesCode;

    1225. 

  1225. }

    1226. 

  1226. 

    1227. 

  1227. ///////////////////////////////////////////////////////////////////////////////////////

    1228. 

  1228. // formatSessionDescription($sSesCode, $sAtelier, $sProjet)

    1229. 

  1229. // Set le format d'affichage pour la description de la session

    1230. 

  1230. //  IN:     sSesCode    code de session

    1231. 

  1231. //          $sAtelier   nom de l'atelier parent

    1232. 

  1232. //          $sProjet    projet parent

    1233. 

  1233. //  OUT:    (string)    affichage de l'atelier et du projet

    1234. 

  1234. ///////////////////////////////////////////////////////////////////////////////////////

    1235. 

  1235. function formatSessionDescription($sSesCode, $sAtelier, $sProjet){

    1236. 

  1236. 	return $sAtelier;

    1237. 

  1237. }

    1238. 

  1238. 

    1239. 

  1239. ///////////////////////////////////////////////////////////////////////////////////////

    1240. 

  1240. // function formatSessionInscriptibleComplete( $nbInscription, $nbInscriptionMax, $sesAnnule, $dSesLimite, $separator, $classOK = "", $classNOT = "" )

    1241. 

  1241. // Set le format d'affichage lorsqu'une session est "non-inscriptible"

    1242. 

  1242. //  IN:   $nbIns           nombre de personne actuellement inscrit

    1243. 

  1243. //          $nbMax          nombre maximal de personne pouvant s'inscrire

    1244. 

  1244. //          $sesAnnule     "t" ou "f" qui dit si la sessions est annul�e

    1245. 

  1245. //          $dSesLimite   date limite de la session

    1246. 

  1246. //          $separator     separateur � l'affichage entre chaque raison qui rend une session "non-inscriptible"

    1247. 

  1247. //          $classOK        -- Inutile --

    1248. 

  1248. //          $classNOT     class si la session est pleine

    1249. 

  1249. //  OUT:    (string) le r�sultat du string une fois format�

    1250. 

  1250. ///////////////////////////////////////////////////////////////////////////////////////

    1251. 

  1251. function formatSessionInscriptibleComplete( $nbInscription, $nbInscriptionMax, $sesAnnule, $dSesLimite, $separator, $classOK = "", $classNOT = "" ){

    1252. 

  1252. 	$output = "";

    1253. 

  1253. 	$arrNOT = array();

    1254. 

  1254. 

    1255. 

  1255. 	// Cr�ation des messages d'erreur

    1256. 

  1256. 	if( $nbInscription >= $nbInscriptionMax ){

    1257. 

  1257. 		$arrNOT[] = _("session complete");

    1258. 

  1258. 	}

    1259. 

  1259. 	if( $sesAnnule == "t" ){

    1260. 

  1260. 		$arrNOT[]= _("session annulee");

    1261. 

  1261. 	}

    1262. 

  1262. 	if( ( isDate( $dSesLimite ) ) && ( strtotime( date( "Y-m-d" ) ) > strtotime( $dSesLimite ) ) ){

    1263. 

  1263. 		$arrNOT[] = _("date limite depassee");

    1264. 

  1264. 	}

    1265. 

  1265. 

    1266. 

  1266. 	// Si des messages d'erreur ont �t� cr��s, on les affiche

    1267. 

  1267. 	if( count( $arrNOT ) > 0 ){

    1268. 

  1268. 		if( $classNOT != "" ){

    1269. 

  1269. 			$output = "<span class='" . $classNOT . "'>"._("non inscriptible :")." " . implode( $separator, $arrNOT ) . "</span>";

    1270. 

  1270. 		} else {

    1271. 

  1271. 			$output = _("non inscriptible :")." " . implode( $separator, $arrNOT );

    1272. 

  1272. 		}

    1273. 

  1273. 	}

    1274. 

  1274. 	return $output;

    1275. 

  1275. }

    1276. 

  1276. 

    1277. 

  1277. ///////////////////////////////////////////////////////////////////////////////////////

    1278. 

  1278. // function formatStateActivite($classNOT, $separator, $args)

    1279. 

  1279. // JE M'EXCUSE CETTE FONCTION EST AFFREUSE(youri). Vous pouvez la refaire si vous voulez.

    1280. 

  1280. // affiche l'�tat d'une fiche dans un listing (ex: recherche). D�s que la fiche parent,

    1281. 

  1281. // ou la fiche actuelle est annul�e ou invalide, cette fonction affiche (annul�) ou (invalide).

    1282. 

  1282. //  IN:     $classNOT       class (pour le span) du style sheet si la fiche est invalide ou annul�e

    1283. 

  1283. //          $separator      separateur entre les 2 messages possible pour la fiche

    1284. 

  1284. //          $prj_valide     t ou f

    1285. 

  1285. //          $act_valide     t ou f

    1286. 

  1286. //          $act_annule     t ou f

    1287. 

  1287. ///////////////////////////////////////////////////////////////////////////////////////

    1288. 

  1288. function formatStateActivite($classNOT, $separator, $args){

    1289. 

  1289.     //config

    1290. 

  1290.     $arrState[0]=array("f","("._("invalide").")");  // projet

    1291. 

  1291.     $arrState[1]=array("f","("._("invalide").")");  // activite

    1292. 

  1292.     $arrState[2]=array("t","("._("annule").")");  // activite

    1293. 

  1293.     //ne pas toucher

    1294. 

  1294.     $MINPARAM = 2;

    1295. 

  1295.     unset($arrStateMatch);

    1296. 

  1296.     $iMatch=0;

    1297. 

  1297.     $args=func_get_args();

    1298. 

  1298.     for ($i = $MINPARAM; $i < count($args); $i++){

    1299. 

  1299.         if (!strcasecmp($args[$i], $arrState[$i-$MINPARAM][0])){

    1300. 

  1300.             $arrStateMatch[$iMatch]=$arrState[$i-$MINPARAM][1];

    1301. 

  1301.             $iMatch++;

    1302. 

  1302.         }

    1303. 

  1303.     }

    1304. 

  1304.     //le output

    1305. 

  1305.     unset($output);

    1306. 

  1306.     if (is_array($arrStateMatch)){

    1307. 

  1307.         $arrStateMatch=array_unique($arrStateMatch);

    1308. 

  1308.         if($classNOT!=""){

    1309. 

  1309.             $output="<span class=\"".$classNOT."\">".join($separator, $arrStateMatch)."</span>";

    1310. 

  1310.         }

    1311. 

  1311.         else{

    1312. 

  1312.             $output=join($separator, $arrStateMatch);

    1313. 

  1313.         }

    1314. 

  1314.     }

    1315. 

  1315.     return $output;

    1316. 

  1316. }

    1317. 

  1317. 

    1318. 

  1318. ///////////////////////////////////////////////////////////////////////////////////////

    1319. 

  1319. // function formatStateActiviteComplete($classOK, $classNOT, $separator, $args)

    1320. 

  1320. // JE M'EXCUSE CETTE FONCTION EST AFFREUSE(youri). Vous pouvez la refaire si vous voulez.

    1321. 

  1321. // affiche l'�tat d'une activite en fonction si la fiche ou la fiche parent est 

    1322. 

  1322. // annul�e ou invalide ou autres.

    1323. 

  1323. //  IN:     $classOK        class (pour le span) du style sheet si la fiche est valide et active

    1324. 

  1324. //          $classNOT       class (pour le span) du style sheet si la fiche est invalide ou annul�e

    1325. 

  1325. //          $separator      separateur entre les diff�rents messages de non validit�

    1326. 

  1326. //          $prj_valide     t ou f

    1327. 

  1327. //          $act_valide     t ou f

    1328. 

  1328. //          $act_annule     t ou f

    1329. 

  1329. ///////////////////////////////////////////////////////////////////////////////////////

    1330. 

  1330. function formatStateActiviteComplete($classOK, $classNOT, $separator, $args){

    1331. 

  1331.     //config: tableau qui fait la comparaison et affiche ce qui suit si la comparaison fit

    1332. 

  1332.     $arrState[0]=array("f",_("projet invalide") );      // projet

    1333. 

  1333.     $arrState[1]=array("f",_("activite invalide") );    // activite

    1334. 

  1334.     $arrState[2]=array("t",_("activite annulee") );     // activite

    1335. 

  1335.     $stateOK="actif";

    1336. 

  1336.     //ne pas toucher

    1337. 

  1337.     $MINPARAM = 3;

    1338. 

  1338.     unset($arrStateMatch);

    1339. 

  1339.     $iMatch=0;

    1340. 

  1340.     $args=func_get_args();

    1341. 

  1341.     for ($i = $MINPARAM; $i < count($args); $i++){

    1342. 

  1342.         if (!strcasecmp($args[$i], $arrState[$i-$MINPARAM][0])){

    1343. 

  1343.             $arrStateMatch[$iMatch]=$arrState[$i-$MINPARAM][1];

    1344. 

  1344.             $iMatch++;

    1345. 

  1345.         }

    1346. 

  1346.     }

    1347. 

  1347.     //le output

    1348. 

  1348.     unset($output);

    1349. 

  1349.     if (is_array($arrStateMatch)){

    1350. 

  1350.         if($classNOT!=""){

    1351. 

  1351.             $output="<span class=\"".$classNOT."\">".join($separator, $arrStateMatch)."</span>";

    1352. 

  1352.         }

    1353. 

  1353.         else{

    1354. 

  1354.             $output=join($seperator, $arrStateMatch);

    1355. 

  1355.         }

    1356. 

  1356.     }

    1357. 

  1357.     else{

    1358. 

  1358.         if($classOK!=""){

    1359. 

  1359.             $output="<span class=\"".$classOK."\">".$stateOK."</span>";

    1360. 

  1360.         }

    1361. 

  1361.         else{

    1362. 

  1362.             $output=$stateOK;

    1363. 

  1363.         }

    1364. 

  1364.     }

    1365. 

  1365.     return $output;

    1366. 

  1366. }

    1367. 

  1367. 

    1368. 

  1368. ///////////////////////////////////////////////////////////////////////////////////////

    1369. 

  1369. // function formatStateAnnule($annule, $class=NULL)

    1370. 

  1370. // Affiche un texte si c'est annul�.

    1371. 

  1371. //  IN:     $valide: 't' si valide

    1372. 

  1372. ///////////////////////////////////////////////////////////////////////////////////////

    1373. 

  1373. function formatStateAnnule($annule, $class=NULL){

    1374. 

  1374.     $state="("._("annule").")";

    1375. 

  1375.     if ($annule=="t"){

    1376. 

  1376.         if ($class!=""){

    1377. 

  1377.             $output="<span class=\"".$class."\">".$state."</span>";

    1378. 

  1378.         }

    1379. 

  1379.         else{

    1380. 

  1380.             $output=$state;

    1381. 

  1381.         }

    1382. 

  1382.     }

    1383. 

  1383.     return $output;

    1384. 

  1384. }

    1385. 

  1385. 

    1386. 

  1386. ///////////////////////////////////////////////////////////////////////////////////////

    1387. 

  1387. // function formatStateFormation($classNOT, $separator, $args)

    1388. 

  1388. // Affiche l'�tat d'une fiche dans un listing (ex: recherche) d'apr�s les informations re�ues

    1389. 

  1389. //  IN:     $classNOT       class (pour le span) du style sheet si la fiche est invalide ou annul�e

    1390. 

  1390. //          $separator      separateur entre les 2 messages possible pour la fiche

    1391. 

  1391. //          $prj_valide     t par d�faut

    1392. 

  1392. //          $atl_valide     t par d�faut

    1393. 

  1393. //          $ses_valide     t par d�faut

    1394. 

  1394. //          $ses_annule     f par d�faut

    1395. 

  1395. //          $sea_valide     t par d�faut

    1396. 

  1396. //          $sea_annule     f par d�faut

    1397. 

  1397. ///////////////////////////////////////////////////////////////////////////////////////

    1398. 

  1398. function formatStateFormation( $classNOT = "", $separator = "", $prj_valide = "t", $atl_valide = "t", $ses_valide = "t", $ses_annule = "f", $sea_valide = "t", $sea_annule = "f" ){

    1399. 

  1399. 	$output = "";

    1400. 

  1400. 

    1401. 

  1401. 	if( $prj_valide != "t" || $atl_valide != "t" || $ses_valide != "t" || $sea_valide != "t" ){

    1402. 

  1402. 		$output .= "("._("invalide").")";

    1403. 

  1403. 	}

    1404. 

  1404. 

    1405. 

  1405. 	if( $ses_annule != "f" || $sea_annule != "f" ){

    1406. 

  1406. 		if( $output != "" ){

    1407. 

  1407. 			$output .= $separator;

    1408. 

  1408. 		}

    1409. 

  1409. 		$output .= "("._("annulee").")";

    1410. 

  1410. 	}

    1411. 

  1411. 

    1412. 

  1412. 	// Met une classe CSS � notre �tat si elle a �t� fournit

    1413. 

  1413. 	if( $output != "" && $classNOT != "" ){

    1414. 

  1414. 		$output = "<span class='" . $classNOT . "'>" . $output . "</span>";

    1415. 

  1415. 	}

    1416. 

  1416. 

    1417. 

  1417. 	return $output;

    1418. 

  1418. }

    1419. 

  1419. ///////////////////////////////////////////////////////////////////////////////////////

    1420. 

  1420. // function formatStateFormationComplete($classOK, $classNOT, $separator, $args)

    1421. 

  1421. // JE M'EXCUSE CETTE FONCTION EST AFFREUSE(youri). Vous pouvez la refaire si vous voulez.

    1422. 

  1422. // affiche l'�tat d'une fiche (projet, atelier, session, seance) en fonction si la 

    1423. 

  1423. // fiche ou la fiche parent est annul� ou invalide ou autres.

    1424. 

  1424. //  IN:     $classOK        class (pour le span) du style sheet si la fiche est valide et active

    1425. 

  1425. //          $classNOT       class (pour le span) du style sheet si la fiche est invalide ou annul�e

    1426. 

  1426. //          $separator      separateur entre les diff�rents messages de non validit�

    1427. 

  1427. //          $prj_valide     t ou f

    1428. 

  1428. //          $atl_valide     t ou f

    1429. 

  1429. //          $ses_valide     t ou f

    1430. 

  1430. //          $ses_annule     t ou f

    1431. 

  1431. //          $sea_valide     t ou f

    1432. 

  1432. //          $sea_annule     t ou f

    1433. 

  1433. ///////////////////////////////////////////////////////////////////////////////////////

    1434. 

  1434. function formatStateFormationComplete($classOK, $classNOT, $separator, $args){

    1435. 

  1435.     //config: tableau qui fait la comparaison et affiche ce qui suit si la comparaison fit

    1436. 

  1436.     $arrState[0]=array("f",_("projet invalide") );  // projet

    1437. 

  1437.     $arrState[1]=array("f",_("atelier invalide") ); // atelier

    1438. 

  1438.     $arrState[2]=array("f",_("session invalide") ); // session

    1439. 

  1439.     $arrState[3]=array("t",_("session annulee") );  // session

    1440. 

  1440.     $arrState[4]=array("f",_("seance invalide") );  // seance

    1441. 

  1441.     $arrState[5]=array("t",-("seance annulee") );   // seance

    1442. 

  1442.     $stateOK="actif";

    1443. 

  1443.     //ne pas toucher

    1444. 

  1444.     $MINPARAM = 3;

    1445. 

  1445.     $ok=true;

    1446. 

  1446.     unset($arrStateMatch);

    1447. 

  1447.     $iMatch=0;

    1448. 

  1448.     $args=func_get_args();

    1449. 

  1449.     for ($i = $MINPARAM; $i < count($args); $i++){

    1450. 

  1450.         if (!strcasecmp($args[$i], $arrState[$i-$MINPARAM][0])){

    1451. 

  1451.             $ok=false;

    1452. 

  1452.             $arrStateMatch[$iMatch]=$arrState[$i-$MINPARAM][1];

    1453. 

  1453.             $iMatch++;

    1454. 

  1454.         }

    1455. 

  1455.     }

    1456. 

  1456.     //le output

    1457. 

  1457.     unset($output);

    1458. 

  1458.     if ($ok==true){

    1459. 

  1459.         if($classOK!=""){

    1460. 

  1460.             $output="<span class=\"".$classOK."\">".$stateOK."</span>";

    1461. 

  1461.         }

    1462. 

  1462.         else{

    1463. 

  1463.             $output=$stateOK;

    1464. 

  1464.         }

    1465. 

  1465.     }

    1466. 

  1466.     else{

    1467. 

  1467.         if (is_array($arrStateMatch)){

    1468. 

  1468.             if($classNOT!=""){

    1469. 

  1469.                 $output="<span class=\"".$classNOT."\">".join($separator, $arrStateMatch)."</span>";

    1470. 

  1470.             }

    1471. 

  1471.             else{

    1472. 

  1472.                 $output=join($seperator, $arrStateMatch);

    1473. 

  1473.             }

    1474. 

  1474.         }

    1475. 

  1475.     }

    1476. 

  1476.     return $output;

    1477. 

  1477. }

    1478. 

  1478. 

    1479. 

  1479. ///////////////////////////////////////////////////////////////////////////////////////

    1480. 

  1480. // function formatStateAnnule($annule, $class=NULL)

    1481. 

  1481. // Affiche un texte si c'est annul�.

    1482. 

  1482. //  IN:     $valide: 't' si valide

    1483. 

  1483. ///////////////////////////////////////////////////////////////////////////////////////

    1484. 

  1484. function formatStateInscription( $inscriptionEtat, $classOK = "", $classNOT = "", $classHOPE = ""){

    1485. 

  1485. 	$format = '<span class="%s">%s</span>';

    1486. 

  1486. 	switch( strtolower( $inscriptionEtat ) ){

    1487. 

  1487. 		case "t" :

    1488. 

  1488. 			$etat = _("Valide");

    1489. 

  1489. 			$class = $classOK;

    1490. 

  1490. 			break;

    1491. 

  1491. 		case "f" :

    1492. 

  1492. 			$etat = _("Invalide");

    1493. 

  1493. 			$class = $classNOT;

    1494. 

  1494. 			break;

    1495. 

  1495. 		case "" :

    1496. 

  1496. 			$etat = _("A valider");

    1497. 

  1497. 			$class = $classHOPE;

    1498. 

  1498. 			break;

    1499. 

  1499. 		default :

    1500. 

  1500. 			$etat = "";

    1501. 

  1501. 			$class = "";

    1502. 

  1502. 	}

    1503. 

  1503. 

    1504. 

  1504. 	if( $class <> "" ){

    1505. 

  1505. 		$output = sprintf( $format, $class, $etat );

    1506. 

  1506. 	} else {

    1507. 

  1507. 		$output = $etat;

    1508. 

  1508. 	}

    1509. 

  1509. 	return $output;

    1510. 

  1510. }

    1511. 

  1511. 

    1512. 

  1512. ///////////////////////////////////////////////////////////////////////////////////////

    1513. 

  1513. // formatStateValid($valide, $class=NULL)

    1514. 

  1514. // Affiche un texte si c'est valide ou invalide.

    1515. 

  1515. //  IN:     $valide: 't' si valide

    1516. 

  1516. ///////////////////////////////////////////////////////////////////////////////////////

    1517. 

  1517. function formatStateValid( $valide, $class = "" ){

    1518. 

  1518. 	$output = "";

    1519. 

  1519. 

    1520. 

  1520. 	if( $valide == "f" ){

    1521. 

  1521. 		$output = "("._("invalide").")";

    1522. 

  1522. 

    1523. 

  1523. 		if( $class <> "" ){

    1524. 

  1524. 			$output = "<span class='" . $class . "'>" . $output . "</span>";

    1525. 

  1525. 		}

    1526. 

  1526. 	}

    1527. 

  1527. 

    1528. 

  1528.     return $output;

    1529. 

  1529. }

    1530. 

  1530. 

    1531. 

  1531. ///////////////////////////////////////////////////////////////////////////////////////

    1532. 

  1532. // function formatTelephone($sTel, $countryCode = "ca")

    1533. 

  1533. // formate la sortie pour qu'on puisse afficher le num�ro tel�phone

    1534. 

  1534. //  IN:     $sTel:          no de tel

    1535. 

  1535. //  OUT:    (string)        le r�sultat du telephone une fois format�

    1536. 

  1536. ///////////////////////////////////////////////////////////////////////////////////////

    1537. 

  1537. function formatTelephone($sTel){

    1538. 

  1538. 	global $cfgCountry;

    1539. 

  1539.     $output=$sTel; 

    1540. 

  1540.     switch ($cfgCountry){

    1541. 

  1541.         case "us":

    1542. 

  1542.         case "ca":

    1543. 

  1543.             if (ereg("^[^0-9]*"."([0-9]{3})"."[^0-9]*"."([0-9]{3})"."[^0-9]*"."([0-9]{4})"."[^0-9]*"."([0-9]*)$", $sTel, $regs)){

    1544. 

  1544.                 if ($regs[4]!=""){

    1545. 

  1545.                     $output = "(".$regs[1].") ".$regs[2]."-".$regs[3]." ext:".$regs[4];

    1546. 

  1546.                 } else {

    1547. 

  1547.                     $output = "(".$regs[1].") ".$regs[2]."-".$regs[3];

    1548. 

  1548.                 }

    1549. 

  1549.             }

    1550. 

  1550.             break;

    1551. 

  1551.         default:

    1552. 

  1552.             break;

    1553. 

  1553.     }

    1554. 

  1554.     return $output;

    1555. 

  1555. }

    1556. 

  1556. 

    1557. 

  1557. ///////////////////////////////////////////////////////////////////////////////////////

    1558. 

  1558. // function generatePassword($nbLen, $numPercent, $bUseCase=false)

    1559. 

  1559. // Retourne le mot de passe g�n�r� automatiquement 

    1560. 

  1560. // m�thode tient compte de ne pas s�parer les mot entre guillemet

    1561. 

  1561. // IN:      $nbLen        longueur d�sir� du mot de passe

    1562. 

  1562. //            $numPercent    pourcentage des chances que le char soit un nombre

    1563. 

  1563. //            $bUseCase    est-ce qu'on veut utiliser le case dans les lettres

    1564. 

  1564. // OUT:     (string)     mot de passe

    1565. 

  1565. ///////////////////////////////////////////////////////////////////////////////////////

    1566. 

  1566. function generatePassword($nbLen, $numPercent, $bUseCase=false){

    1567. 

  1567.     unset($psw);

    1568. 

  1568.     for($i=0; $i<$nbLen; $i++){

    1569. 

  1569.         if (rand(0,100)<$numPercent){

    1570. 

  1570.             //on met un chiffre

    1571. 

  1571.             $char = chr(rand(48,57));

    1572. 

  1572.         }

    1573. 

  1573.         else{

    1574. 

  1574.             if ($bUseCase){

    1575. 

  1575.                 if (rand(0,1)==0){

    1576. 

  1576.                     //on met une lettre minuscule

    1577. 

  1577.                     $char = chr(rand(97,122));

    1578. 

  1578.                 }

    1579. 

  1579.                 else{

    1580. 

  1580.                     //on met une lettre majuscule

    1581. 

  1581.                     $char = chr(rand(65,90));

    1582. 

  1582.                 }

    1583. 

  1583.             }

    1584. 

  1584.             else{

    1585. 

  1585.                 //on met une lettre minuscule

    1586. 

  1586.                 $char = chr(rand(97,122));

    1587. 

  1587.             }

    1588. 

  1588.         }

    1589. 

  1589.         $psw.=$char;

    1590. 

  1590.     }

    1591. 

  1591.     return ($psw);

    1592. 

  1592. }

    1593. 

  1593. 

    1594. 

  1594. ///////////////////////////////////////////////////////////////////////////////////////

    1595. 

  1595. // getArrayFromStringMot($sQuery)

    1596. 

  1596. // Retourne le tableau contenant les diff�rents mot pour le moteur de recherche. Cette

    1597. 

  1597. // m�thode tient compte de ne pas s�parer les mot entre guillemet

    1598. 

  1598. // IN:      $sQuery: string de requ�te fait sur la page web

    1599. 

  1599. // OUT:     (array) tableau contenant chaque mot de la requ�te dans un �l�ments

    1600. 

  1600. ///////////////////////////////////////////////////////////////////////////////////////

    1601. 

  1601. function getArrayFromStringMot( $sQuery ){

    1602. 

  1602. 	// Retourne la liste de tous les �l�ments qui sont entour�s par des guillemets doubles OU qui sont des mots

    1603. 

  1603. 	$nb_match = preg_match_all( "(\"[^\"]+\"|\w+)", $sQuery, $list );

    1604. 

  1604. 

    1605. 

  1605. 	// Pour chaque �l�ment, remplace les guillemets par rien

    1606. 

  1606. 	foreach( $list[ 0 ] as $id => $element ){

    1607. 

  1607. 		$list[ 0 ][ $id ] = str_replace( "\"", "", $list[ 0 ][ $id ] );

    1608. 

  1608. 	}

    1609. 

  1609. 

    1610. 

  1610. 	// Comme PREG_MATCH_ALL retourne un array avec un array par s�quence et que nous n'en avons qu'une, on retourne la premi�re

    1611. 

  1611. 	return $list[ 0 ];

    1612. 

  1612. }

    1613. 

  1613. 

    1614. 

  1614. ///////////////////////////////////////////////////////////////////////////////////////

    1615. 

  1615. // function getMaxStrlenFromArray($arrTemp)

    1616. 

  1616. // Retourne le plus grand strlen de tous les �l�ments du tableaux

    1617. 

  1617. //  IN:     $arrTemp        tableau � parser

    1618. 

  1618. //  OUT:    (integer)       la plus grand strlen des �l�ments du tableau

    1619. 

  1619. ///////////////////////////////////////////////////////////////////////////////////////

    1620. 

  1620. function getMaxStrlenFromArray($arrTemp){

    1621. 

  1621.     $themax = 0;

    1622. 

  1622.     for ($i=0; $i<count($arrTemp); $i++){

    1623. 

  1623.         $temp = strlen($arrTemp[$i]);

    1624. 

  1624.         if($temp>$themax){

    1625. 

  1625.             $themax = $temp;

    1626. 

  1626.         }

    1627. 

  1627.     }

    1628. 

  1628.     return ($themax);

    1629. 

  1629. }

    1630. 

  1630. 

    1631. 

  1631. ///////////////////////////////////////////////////////////////////////////////////////

    1632. 

  1632. // function getMoney($sInput)

    1633. 

  1633. // Retourne un nombre avec deux d�cimales. On enl�ve toutes les currency. On veut rien

    1634. 

  1634. // savoir. Comme �a tout le monde (international) est content!

    1635. 

  1635. // voici le format comme on le veut : XXXXXXX.XX  (x = [0-9])

    1636. 

  1636. //  IN:     $sInput: le montant � v�rifier

    1637. 

  1637. //  OUT:    si le nombre est valide: 

    1638. 

  1638. ///////////////////////////////////////////////////////////////////////////////////////

    1639. 

  1639. function getMoney($sInput){

    1640. 

  1640.     if (ereg("([0-9]*[.]{0,1}[0-9]{1,2})",$sInput,$regs)){

    1641. 

  1641.         return ($regs[1]);

    1642. 

  1642.     }

    1643. 

  1643.     return (0);

    1644. 

  1644. }

    1645. 

  1645. 

    1646. 

  1646. ///////////////////////////////////////////////////////////////////////////////////////

    1647. 

  1647. // Retourne un string HTML contenant les textbox pour un noTel

    1648. 

  1648. ///////////////////////////////////////////////////////////////////////////////////////

    1649. 

  1649. function getTBTelephone($tbName, $sTel, $bExt, $class, $jsOnChange){

    1650. 

  1650. 	global $cfgCountry;

    1651. 

  1651.     $output = "<input class=\"".$class."\" type=\"hidden\" name=\"".$tbName."\" value=\"".formatHTML($sTel)."\" />";

    1652. 

  1652.     switch ($cfgCountry){

    1653. 

  1653.         case "us":

    1654. 

  1654.         case "ca":

    1655. 

  1655.             $jsOnchange = "this.form.".$tbName.".value=this.form.".$tbName."_1.value+this.form.".$tbName."_2.value+this.form.".$tbName."_3.value+this.form.".$tbName."_4.value;".$jsOnChange;

    1656. 

  1656.             ereg("^[^0-9]*"."([0-9]{3})"."[^0-9]*"."([0-9]{3})"."[^0-9]*"."([0-9]{4})"."[^0-9]*"."([0-9]*)$", $sTel, $regs);

    1657. 

  1657.             $output .= "( ";

    1658. 

  1658.             $output .= "<input class=\"".$class."\" type=\"text\" name=\"".$tbName."_1\" value=\"".$regs[1]."\" size=\"3\" maxlength=\"3\" onchange=\"".$jsOnchange."\" onfocus=\"select(this);\" onkeyup=\"if (this.value.length==3) { this.form.".$tbName."_2.focus(); }\" />";

    1659. 

  1659.             $output .= " ) ";

    1660. 

  1660.             $output .= "<input class=\"".$class."\" type=\"text\" name=\"".$tbName."_2\" value=\"".$regs[2]."\" size=\"3\" maxlength=\"3\" onchange=\"".$jsOnchange."\" onfocus=\"select(this);\" onkeyup=\"if (this.value.length==3) { this.form.".$tbName."_3.focus(); }\" />";

    1661. 

  1661.             $output .= " - ";

    1662. 

  1662.             $output .= "<input class=\"".$class."\" type=\"text\" name=\"".$tbName."_3\" value=\"".$regs[3]."\" size=\"4\" maxlength=\"4\" onchange=\"".$jsOnchange."\" onfocus=\"select(this);\" />";

    1663. 

  1663.             if ($bExt){

    1664. 

  1664.                 $output .= " ext:";

    1665. 

  1665.                 $output .= "<input class=\"".$class."\" type=\"text\" name=\"".$tbName."_4\" value=\"".$regs[4]."\" size=\"4\" maxlength=\"4\" onchange=\"".$jsOnchange."\" onfocus=\"select(this);\" />";

    1666. 

  1666.             } else {

    1667. 

  1667.                 $output .= "<input class=\"".$class."\" type=\"hidden\" name=\"".$tbName."_4\" value=\"".$regs[4]."\" />";

    1668. 

  1668.             }

    1669. 

  1669.             break;

    1670. 

  1670.         default:

    1671. 

  1671.             $output = _("Code d'identification du pays inconnu");

    1672. 

  1672.             break;

    1673. 

  1673.     }

    1674. 

  1674.     return $output;

    1675. 

  1675. }

    1676. 

  1676. 

    1677. 

  1677. ///////////////////////////////////////////////////////////////////////////////////////

    1678. 

  1678. // function getQueryStringUpdated($querystring)

    1679. 

  1679. // Modifie le querystring en fonction des variables et valeurs fournies en param�tres

    1680. 

  1680. // Si la variable en param�tre existe d�j� dans le querystring, sa valeur sera modifi�e

    1681. 

  1681. // pour la nouvelle valeur sp�cifi�e. Si la variable n'existe pas, alors le champs sera

    1682. 

  1682. // ajouter au querystring avec la valeur soumissionn�e.

    1683. 

  1683. //      ex: newQS = getQueryStringUpdated($HTTP_SERVER_VARS["QUERY_STRING"], "mode", "edit");

    1684. 

  1684. //  IN:     $querystring: le querystring actuel (ex:"mode=display&pg=1&indx=alpha")

    1685. 

  1685. //          $var1: variable dans le querystring qu'on veux ajouter au modifier (ex: "mode")

    1686. 

  1686. //          $val1: valeur � mettre dans la premi�re variable (ex: "edit")

    1687. 

  1687. //          $var2: 2e variable � modifier ou ajouter

    1688. 

  1688. //          $val2: valeur de la 2e variable

    1689. 

  1689. //          $varX: Xe variable � modifier ou ajouter

    1690. 

  1690. //          $valX: valeur de la Xe variable

    1691. 

  1691. //  OUT:    (querystringNew) le nouveau querystring

    1692. 

  1692. ///////////////////////////////////////////////////////////////////////////////////////

    1693. 

  1693. function getQueryStringUpdated( $query_string ){

    1694. 

  1694. 	// Enl�ve les ? du d�but de la string

    1695. 

  1695. 	while( isset( $query_string[ 0 ] ) && $query_string[ 0 ] == "?" ){

    1696. 

  1696. 		$query_string = substr( $query_string, 1 );

    1697. 

  1697. 	}

    1698. 

  1698. 

    1699. 

  1699. 	// Fait la liste de tous les �l�ments GET de l'URL

    1700. 

  1700. 	$query_tab = explode( "&", $query_string );

    1701. 

  1701. 	$list_elements = array();

    1702. 

  1702. 	foreach( $query_tab as $element ){

    1703. 

  1703. 		list( $nom, $valeur ) = explode( "=", $element );

    1704. 

  1704. 		if( $valeur <> "" ){

    1705. 

  1705. 			$list_elements[ $nom ] = $valeur;

    1706. 

  1706. 		}

    1707. 

  1707. 	}

    1708. 

  1708. 

    1709. 

  1709. 	// On passe par-dessus le premier parce que c'est QUERY_STRING

    1710. 

  1710. 	$num_args = func_num_args();

    1711. 

  1711. 	for( $i = 1; $i < $num_args; $i = $i + 2 ){

    1712. 

  1712. 		// Fetch les informations de l'argument

    1713. 

  1713. 		$nom_arg = urlencode( func_get_arg( $i ) );

    1714. 

  1714. 		if( $num_args >= ( $i + 1 ) ){

    1715. 

  1715. 			$val_arg = urlencode( func_get_arg( $i + 1 ) );

    1716. 

  1716. 		} else {

    1717. 

  1717. 			$val_arg = "";

    1718. 

  1718. 		}

    1719. 

  1719. 

    1720. 

  1720. 		$list_elements[ $nom_arg ] = $val_arg;

    1721. 

  1721. 	}

    1722. 

  1722. 

    1723. 

  1723. 	// B�tit la string � retourner

    1724. 

  1724. 	$query_string = "";

    1725. 

  1725. 	$premier_element = true;

    1726. 

  1726. 	foreach( $list_elements as $nom => $valeur ){

    1727. 

  1727. 		if( !$premier_element ){

    1728. 

  1728. 			$query_string .= "&";

    1729. 

  1729. 		} else {

    1730. 

  1730. 			$premier_element = false;

    1731. 

  1731. 		}

    1732. 

  1732. 		$query_string .= $nom . "=" . $valeur;

    1733. 

  1733. 	}

    1734. 

  1734. 	return $query_string;

    1735. 

  1735. }

    1736. 

  1736. 

    1737. 

  1737. ///////////////////////////////////////////////////////////////////////////////////////

    1738. 

  1738. // Retourne la requete SQL necessaire pour faire un DELETE

    1739. 

  1739. ///////////////////////////////////////////////////////////////////////////////////////

    1740. 

  1740. function getSQLStmtDelActivite($act_id){

    1741. 

  1741.     $SQLStmt="DELETE FROM activite";

    1742. 

  1742.     $SQLStmt.=" WHERE act_id=".$act_id;

    1743. 

  1743.     return $SQLStmt;

    1744. 

  1744. }

    1745. 

  1745. 

    1746. 

  1746. ///////////////////////////////////////////////////////////////////////////////////////

    1747. 

  1747. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1748. 

  1748. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1749. 

  1749. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1750. 

  1750. ///////////////////////////////////////////////////////////////////////////////////////

    1751. 

  1751. function getSQLStmtDelActiviteArray($arrnTemp){

    1752. 

  1752.     $SQLStmt="DELETE FROM activite";

    1753. 

  1753.     $SQLStmt.=" WHERE act_id<>act_id";

    1754. 

  1754.     for ($i=0; $i<=count($arrnTemp); $i++){

    1755. 

  1755.         if (is_numeric($arrnTemp[$i])){

    1756. 

  1756.             $SQLStmt.=" OR act_id=".$arrnTemp[$i];

    1757. 

  1757.         }

    1758. 

  1758.     }

    1759. 

  1759.     return $SQLStmt;

    1760. 

  1760. }

    1761. 

  1761. 

    1762. 

  1762. ///////////////////////////////////////////////////////////////////////////////////////

    1763. 

  1763. // Retourne la requete SQL necessaire pour faire un DELETE

    1764. 

  1764. ///////////////////////////////////////////////////////////////////////////////////////

    1765. 

  1765. function getSQLStmtDelActiviteFromProjet($prj_id){

    1766. 

  1766.     $SQLStmt="DELETE FROM activite";

    1767. 

  1767.     $SQLStmt.=" WHERE prj_id=".$prj_id;

    1768. 

  1768.     return $SQLStmt;

    1769. 

  1769. }

    1770. 

  1770. 

    1771. 

  1771. ///////////////////////////////////////////////////////////////////////////////////////

    1772. 

  1772. // Retourne la requete SQL necessaire pour faire un DELETE

    1773. 

  1773. ///////////////////////////////////////////////////////////////////////////////////////

    1774. 

  1774. function getSQLStmtDelAtelier($atl_id){

    1775. 

  1775.     $SQLStmt="DELETE FROM atelier";

    1776. 

  1776.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    1777. 

  1777.     return $SQLStmt;

    1778. 

  1778. }

    1779. 

  1779. 

    1780. 

  1780. ///////////////////////////////////////////////////////////////////////////////////////

    1781. 

  1781. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1782. 

  1782. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1783. 

  1783. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1784. 

  1784. ///////////////////////////////////////////////////////////////////////////////////////

    1785. 

  1785. function getSQLStmtDelAtelierArray($arrnTemp){

    1786. 

  1786. 	$SQLStmt = "Delete From atelier a Where a.atl_id <> a.atl_id";

    1787. 

  1787. 	foreach( $arrnTemp as $atl_id ) {

    1788. 

  1788. 		if( is_numeric( $atl_id ) ){

    1789. 

  1789. 			$SQLStmt .= " Or ( a.atl_id = '" . $atl_id . "' And a.atl_id Not In ( Select s.atl_id From session s Where a.atl_id = s.atl_id ) )";

    1790. 

  1790. 		}

    1791. 

  1791. 	}

    1792. 

  1792. 	return $SQLStmt;

    1793. 

  1793. }

    1794. 

  1794. 

    1795. 

  1795. ///////////////////////////////////////////////////////////////////////////////////////

    1796. 

  1796. // Retourne la requete SQL necessaire pour faire un DELETE

    1797. 

  1797. ///////////////////////////////////////////////////////////////////////////////////////

    1798. 

  1798. function getSQLStmtDelAtelierClasse($atl_id){

    1799. 

  1799.     $SQLStmt="DELETE FROM atelier_classe";

    1800. 

  1800.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    1801. 

  1801.     return $SQLStmt;

    1802. 

  1802. }

    1803. 

  1803. 

    1804. 

  1804. ///////////////////////////////////////////////////////////////////////////////////////

    1805. 

  1805. // Retourne la requete SQL necessaire pour faire un DELETE

    1806. 

  1806. ///////////////////////////////////////////////////////////////////////////////////////

    1807. 

  1807. function getSQLStmtDelAtelierClientele($atl_id){

    1808. 

  1808.     $SQLStmt="DELETE FROM atelier_clientele";

    1809. 

  1809.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    1810. 

  1810.     return $SQLStmt;

    1811. 

  1811. }

    1812. 

  1812. 

    1813. 

  1813. ///////////////////////////////////////////////////////////////////////////////////////

    1814. 

  1814. // Retourne la requete SQL necessaire pour faire un DELETE

    1815. 

  1815. ///////////////////////////////////////////////////////////////////////////////////////

    1816. 

  1816. function getSQLStmtDelAtelierExpertise($atl_id){

    1817. 

  1817.     $SQLStmt="DELETE FROM atelier_expertise";

    1818. 

  1818.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    1819. 

  1819.     return $SQLStmt;

    1820. 

  1820. }

    1821. 

  1821. 

    1822. 

  1822. ///////////////////////////////////////////////////////////////////////////////////////

    1823. 

  1823. // Retourne la requete SQL necessaire pour faire un DELETE

    1824. 

  1824. ///////////////////////////////////////////////////////////////////////////////////////

    1825. 

  1825. function getSQLStmtDelAtelierProjet($atl_id){

    1826. 

  1826.     $SQLStmt="DELETE FROM projet_atelier";

    1827. 

  1827.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    1828. 

  1828.     return $SQLStmt;

    1829. 

  1829. }

    1830. 

  1830. 

    1831. 

  1831. ///////////////////////////////////////////////////////////////////////////////////////

    1832. 

  1832. // Retourne la requete SQL necessaire pour faire un DELETE

    1833. 

  1833. ///////////////////////////////////////////////////////////////////////////////////////

    1834. 

  1834. function getSQLStmtDelCedule($ced_id){

    1835. 

  1835.     $SQLStmt="DELETE FROM ceduleur";

    1836. 

  1836.     $SQLStmt.=" WHERE ced_id=".$ced_id;

    1837. 

  1837.     return $SQLStmt;

    1838. 

  1838. }

    1839. 

  1839. 

    1840. 

  1840. ///////////////////////////////////////////////////////////////////////////////////////

    1841. 

  1841. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1842. 

  1842. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1843. 

  1843. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1844. 

  1844. ///////////////////////////////////////////////////////////////////////////////////////

    1845. 

  1845. function getSQLStmtDelCeduleArray($arrnTemp){

    1846. 

  1846.     $SQLStmt="DELETE FROM ceduleur";

    1847. 

  1847.     $SQLStmt.=" WHERE ced_id<>ced_id";

    1848. 

  1848.     for ($i=0; $i<=count($arrnTemp); $i++){

    1849. 

  1849.         if (is_numeric($arrnTemp[$i])){

    1850. 

  1850.             $SQLStmt.=" OR ced_id=".$arrnTemp[$i];

    1851. 

  1851.         }

    1852. 

  1852.     }

    1853. 

  1853.     return $SQLStmt;

    1854. 

  1854. }

    1855. 

  1855. 

    1856. 

  1856. ///////////////////////////////////////////////////////////////////////////////////////

    1857. 

  1857. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1858. 

  1858. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1859. 

  1859. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1860. 

  1860. ///////////////////////////////////////////////////////////////////////////////////////

    1861. 

  1861. function getSQLStmtDelClasseArray($arrnTemp){

    1862. 

  1862.     return (getSQLStmtDelNodeArray($arrnTemp));

    1863. 

  1863. }

    1864. 

  1864. 

    1865. 

  1865. ///////////////////////////////////////////////////////////////////////////////////////

    1866. 

  1866. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1867. 

  1867. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1868. 

  1868. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1869. 

  1869. ///////////////////////////////////////////////////////////////////////////////////////

    1870. 

  1870. /* $Author: stacil $ [$Date: 2008/07/03 18:29:46 $]

    1871. 

  1871. function getSQLStmtDelClienteleArray($arrnTemp){

    1872. 

  1872.     $SQLStmt="DELETE FROM clientele";

    1873. 

  1873.     $SQLStmt.=" WHERE cli_id<>cli_id";

    1874. 

  1874.     for ($i=0; $i<=count($arrnTemp); $i++){

    1875. 

  1875.         if ($arrnTemp[$i]!="" && is_numeric($arrnTemp[$i])){

    1876. 

  1876.             $SQLStmt.=" OR cli_id=".$arrnTemp[$i];

    1877. 

  1877.         }

    1878. 

  1878.     }

    1879. 

  1879.     return $SQLStmt;

    1880. 

  1880. }

    1881. 

  1881. */

    1882. 

  1882. function getSQLStmtDelClienteleArray($arrnTemp){

    1883. 

  1883.     return (getSQLStmtDelNodeArray($arrnTemp));

    1884. 

  1884. }

    1885. 

  1885. 

    1886. 

  1886. ///////////////////////////////////////////////////////////////////////////////////////

    1887. 

  1887. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1888. 

  1888. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1889. 

  1889. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1890. 

  1890. ///////////////////////////////////////////////////////////////////////////////////////

    1891. 

  1891. function getSQLStmtDelExpertiseArray($arrnTemp){

    1892. 

  1892.     return (getSQLStmtDelNodeArray($arrnTemp));

    1893. 

  1893. }

    1894. 

  1894. 

    1895. 

  1895. ///////////////////////////////////////////////////////////////////////////////////////

    1896. 

  1896. // Retourne la requete SQL necessaire pour faire un DELETE

    1897. 

  1897. ///////////////////////////////////////////////////////////////////////////////////////

    1898. 

  1898. function getSQLStmtDelGabarit($gab_id){

    1899. 

  1899.     $SQLStmt="DELETE FROM gabarit";

    1900. 

  1900.     $SQLStmt.=" WHERE gab_id=".$gab_id;

    1901. 

  1901.     $SQLStmt.=" AND gab_system='f'";

    1902. 

  1902.     return $SQLStmt;

    1903. 

  1903. }

    1904. 

  1904. 

    1905. 

  1905. ///////////////////////////////////////////////////////////////////////////////////////

    1906. 

  1906. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1907. 

  1907. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1908. 

  1908. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1909. 

  1909. ///////////////////////////////////////////////////////////////////////////////////////

    1910. 

  1910. function getSQLStmtDelGabaritArray($arrnTemp){

    1911. 

  1911.     $SQLStmt="DELETE FROM gabarit";

    1912. 

  1912.     $SQLStmt.=" WHERE gab_id<>gab_id";

    1913. 

  1913.     for ($i=0; $i<=count($arrnTemp); $i++){

    1914. 

  1914.         if (is_numeric($arrnTemp[$i])){

    1915. 

  1915.             $SQLStmt.=" OR (gab_id=".$arrnTemp[$i];

    1916. 

  1916.             $SQLStmt.=" AND gab_system='f')";

    1917. 

  1917.         }

    1918. 

  1918.     }

    1919. 

  1919.     return $SQLStmt;

    1920. 

  1920. }

    1921. 

  1921. 

    1922. 

  1922. ///////////////////////////////////////////////////////////////////////////////////////

    1923. 

  1923. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1924. 

  1924. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1925. 

  1925. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1926. 

  1926. ///////////////////////////////////////////////////////////////////////////////////////

    1927. 

  1927. function getSQLStmtDelGabaritBaliseArray($gab_id, $arrnTemp){

    1928. 

  1928.     $SQLStmt="DELETE FROM gabaritBalise";

    1929. 

  1929.     $SQLStmt.=" WHERE gab_id = ".$gab_id;

    1930. 

  1930.     $SQLStmt.=" AND ( gb_id <> gb_id";

    1931. 

  1931.     for ($i=0; $i<=count($arrnTemp); $i++){

    1932. 

  1932.         if ($arrnTemp[$i]!="" && is_numeric($arrnTemp[$i])){

    1933. 

  1933.             $SQLStmt.=" OR gb_id=".$arrnTemp[$i];

    1934. 

  1934.         }

    1935. 

  1935.     }

    1936. 

  1936.     $SQLStmt.=")";

    1937. 

  1937.     return $SQLStmt;

    1938. 

  1938. }

    1939. 

  1939. ///////////////////////////////////////////////////////////////////////////////////////

    1940. 

  1940. // Retourne la requete SQL necessaire pour valider si la premiere seance de la 	 

    1941. 

  1941. // session est depassee 	 

    1942. 

  1942. // Ajout� par Francine Bolduc le 2 mars 2010 	 

    1943. 

  1943. /////////////////////////////////////////////////////////////////////////////////////// 	 

    1944. 

  1944. function getSQLStmtReqSessionTermineBySesId($ses_id){ 	 

    1945. 

  1945. 	$SQLStmt = "";

    1946. 

  1946. 

    1947. 

  1947. 	if( is_numeric( $ses_id ) && $ses_id != null){

    1948. 

  1948. 		$SQLStmt = "SELECT MIN(SUBSTR(sea_datedebut::text,1,10)) as db

    1949. 

  1949. 		FROM seance

    1950. 

  1950. 		WHERE ses_id = '" . $ses_id . "'" . " AND sea_valide='t'";

    1951. 

  1951. 	}

    1952. 

  1952. 	return $SQLStmt;

    1953. 

  1953. }

    1954. 

  1954. ///////////////////////////////////////////////////////////////////////////////////////

    1955. 

  1955. // Retourne la requete SQL necessaire pour faire un DELETE

    1956. 

  1956. ///////////////////////////////////////////////////////////////////////////////////////

    1957. 

  1957. function getSQLStmtDelInscription($usrid, $sesid){

    1958. 

  1958.     $SQLStmt="DELETE FROM inscriptionSession";

    1959. 

  1959.     $SQLStmt.=" WHERE usr_id=".$usrid;

    1960. 

  1960.     $SQLStmt.=" AND ses_id=".$sesid;

    1961. 

  1961.     return $SQLStmt;

    1962. 

  1962. }

    1963. 

  1963. 

    1964. 

  1964. ///////////////////////////////////////////////////////////////////////////////////////

    1965. 

  1965. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    1966. 

  1966. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    1967. 

  1967. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    1968. 

  1968. ///////////////////////////////////////////////////////////////////////////////////////

    1969. 

  1969. function getSQLStmtDelInscriptionArray($arrnTemp){

    1970. 

  1970.     $SQLStmt="DELETE FROM inscriptionSession";

    1971. 

  1971.     $SQLStmt.=" WHERE ses_id<>ses_id";

    1972. 

  1972.     for ($i=0; $i<=count($arrnTemp); $i++){

    1973. 

  1973.         ereg("^([0-9]+)[.]{1}([0-9]+)$",$arrnTemp[$i],$regs);

    1974. 

  1974.         $usager=$regs[1];

    1975. 

  1975.         $session=$regs[2];

    1976. 

  1976.         if ((is_numeric($usager))&&(is_numeric($session))){

    1977. 

  1977.             $SQLStmt.=" OR ( usr_id=".$usager;

    1978. 

  1978.             $SQLStmt.=" AND ses_id=".$session.")";

    1979. 

  1979.         }

    1980. 

  1980.     }

    1981. 

  1981.     return $SQLStmt;

    1982. 

  1982. }

    1983. 

  1983. 

    1984. 

  1984. ///////////////////////////////////////////////////////////////////////////////////////

    1985. 

  1985. // Retourne la requete SQL necessaire pour faire un DELETE

    1986. 

  1986. ///////////////////////////////////////////////////////////////////////////////////////

    1987. 

  1987. function getSQLStmtDelLieu($li_id){

    1988. 

  1988.     $SQLStmt="DELETE FROM lieu";

    1989. 

  1989.     $SQLStmt.=" WHERE li_id=".$li_id;

    1990. 

  1990.     return $SQLStmt;

    1991. 

  1991. }

    1992. 

  1992. 

    1993. 

  1993. ///////////////////////////////////////////////////////////////////////////////////////

    1994. 

  1994. // Retourne la requete SQL necessaire pour faire un DELETE

    1995. 

  1995. ///////////////////////////////////////////////////////////////////////////////////////

    1996. 

  1996. function getSQLStmtDelLieuAdmin($li_id){

    1997. 

  1997.     $SQLStmt="DELETE FROM lieuAdmin";

    1998. 

  1998.     $SQLStmt.=" WHERE li_id=".$li_id;

    1999. 

  1999.     return $SQLStmt;

    2000. 

  2000. }

    2001. 

  2001. 

    2002. 

  2002. ///////////////////////////////////////////////////////////////////////////////////////

    2003. 

  2003. // Retourne la requete SQL necessaire pour faire un DELETE

    2004. 

  2004. ///////////////////////////////////////////////////////////////////////////////////////

    2005. 

  2005. function getSQLStmtDelLieuSupport($li_id){

    2006. 

  2006.     $SQLStmt="DELETE FROM lieuSupport";

    2007. 

  2007.     $SQLStmt.=" WHERE li_id=".$li_id;

    2008. 

  2008.     return $SQLStmt;

    2009. 

  2009. }

    2010. 

  2010. 

    2011. 

  2011. ///////////////////////////////////////////////////////////////////////////////////////

    2012. 

  2012. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2013. 

  2013. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2014. 

  2014. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2015. 

  2015. ///////////////////////////////////////////////////////////////////////////////////////

    2016. 

  2016. function getSQLStmtDelLieuArray($arrnTemp){

    2017. 

  2017.     $SQLStmt="DELETE FROM lieu";

    2018. 

  2018.     $SQLStmt.=" WHERE li_id<>li_id";

    2019. 

  2019.     for ($i=0; $i<=count($arrnTemp); $i++){

    2020. 

  2020.         if (is_numeric($arrnTemp[$i])){

    2021. 

  2021.             $SQLStmt.=" OR li_id=".$arrnTemp[$i];

    2022. 

  2022.         }

    2023. 

  2023.     }

    2024. 

  2024.     return $SQLStmt;

    2025. 

  2025. }

    2026. 

  2026. 

    2027. 

  2027. ///////////////////////////////////////////////////////////////////////////////////////

    2028. 

  2028. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2029. 

  2029. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2030. 

  2030. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2031. 

  2031. ///////////////////////////////////////////////////////////////////////////////////////

    2032. 

  2032. function getSQLStmtDelNodeArray($arrnTemp){

    2033. 

  2033.     $SQLStmt="DELETE FROM nodes";

    2034. 

  2034.     $SQLStmt.=" WHERE node<>node";

    2035. 

  2035.     for ($i=0; $i<=count($arrnTemp); $i++){

    2036. 

  2036.         if (is_numeric($arrnTemp[$i])){

    2037. 

  2037.             $SQLStmt.=" OR node=".$arrnTemp[$i];

    2038. 

  2038.         }

    2039. 

  2039.     }

    2040. 

  2040.     return $SQLStmt;

    2041. 

  2041. }

    2042. 

  2042. 

    2043. 

  2043. ///////////////////////////////////////////////////////////////////////////////////////

    2044. 

  2044. // Retourne la requete SQL necessaire pour faire un DELETE

    2045. 

  2045. ///////////////////////////////////////////////////////////////////////////////////////

    2046. 

  2046. function getSQLStmtDelPresence($sea_id){

    2047. 

  2047.     $SQLStmt="DELETE FROM presence";

    2048. 

  2048.     $SQLStmt.=" WHERE sea_id=".$sea_id;

    2049. 

  2049.     return $SQLStmt;

    2050. 

  2050. }

    2051. 

  2051. 

    2052. 

  2052. function getSQLStmtDelProjetAdmin($prj_id){

    2053. 

  2053.     $SQLStmt="DELETE FROM projetAdmin";

    2054. 

  2054.     $SQLStmt.=" WHERE prj_id=".$prj_id;

    2055. 

  2055.     return $SQLStmt;

    2056. 

  2056. }

    2057. 

  2057. 

    2058. 

  2058. ///////////////////////////////////////////////////////////////////////////////////////

    2059. 

  2059. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2060. 

  2060. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2061. 

  2061. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2062. 

  2062. ///////////////////////////////////////////////////////////////////////////////////////

    2063. 

  2063. function getSQLStmtDelProjetArray($arrnTemp){

    2064. 

  2064.     $SQLStmt="DELETE FROM projet";

    2065. 

  2065.     $SQLStmt.=" WHERE prj_id<>prj_id";

    2066. 

  2066.     for ($i=0; $i<=count($arrnTemp); $i++){

    2067. 

  2067.         if (is_numeric($arrnTemp[$i])){

    2068. 

  2068.             $SQLStmt.=" OR prj_id=".$arrnTemp[$i];

    2069. 

  2069.         }

    2070. 

  2070.     }

    2071. 

  2071.     return $SQLStmt;

    2072. 

  2072. }

    2073. 

  2073. 

    2074. 

  2074. ///////////////////////////////////////////////////////////////////////////////////////

    2075. 

  2075. // Retourne la requete SQL necessaire pour faire un DELETE

    2076. 

  2076. ///////////////////////////////////////////////////////////////////////////////////////

    2077. 

  2077. function getSQLStmtDelSeance($sea_id){

    2078. 

  2078.     $SQLStmt="DELETE FROM seance";

    2079. 

  2079.     $SQLStmt.=" WHERE sea_id=".$sea_id;

    2080. 

  2080.     return $SQLStmt;

    2081. 

  2081. }

    2082. 

  2082. 

    2083. 

  2083. ///////////////////////////////////////////////////////////////////////////////////////

    2084. 

  2084. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2085. 

  2085. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2086. 

  2086. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2087. 

  2087. ///////////////////////////////////////////////////////////////////////////////////////

    2088. 

  2088. function getSQLStmtDelSeanceArray($arrnTemp){

    2089. 

  2089.     $SQLStmt="DELETE FROM seance";

    2090. 

  2090.     $SQLStmt.=" WHERE sea_id<>sea_id";

    2091. 

  2091.     for ($i=0; $i<=count($arrnTemp); $i++){

    2092. 

  2092.         if (is_numeric($arrnTemp[$i])){

    2093. 

  2093.             $SQLStmt.=" OR sea_id=".$arrnTemp[$i];

    2094. 

  2094.         }

    2095. 

  2095.     }

    2096. 

  2096.     return $SQLStmt;

    2097. 

  2097. }

    2098. 

  2098. 

    2099. 

  2099. ///////////////////////////////////////////////////////////////////////////////////////

    2100. 

  2100. // Retourne la requete SQL necessaire pour faire un DELETE

    2101. 

  2101. ///////////////////////////////////////////////////////////////////////////////////////

    2102. 

  2102. function getSQLStmtDelSession($ses_id){

    2103. 

  2103.     $SQLStmt="DELETE FROM session";

    2104. 

  2104.     $SQLStmt.=" WHERE ses_id=".$ses_id;

    2105. 

  2105.     return $SQLStmt;

    2106. 

  2106. }

    2107. 

  2107. 

    2108. 

  2108. ///////////////////////////////////////////////////////////////////////////////////////

    2109. 

  2109. // Retourne la requete SQL necessaire pour faire un DELETE

    2110. 

  2110. ///////////////////////////////////////////////////////////////////////////////////////

    2111. 

  2111. function getSQLStmtDelSessionAnimation($ses_id){

    2112. 

  2112.     $SQLStmt="DELETE FROM animation";

    2113. 

  2113.     $SQLStmt.=" WHERE ses_id=".$ses_id;

    2114. 

  2114.     return $SQLStmt;

    2115. 

  2115. }

    2116. 

  2116. 

    2117. 

  2117. ///////////////////////////////////////////////////////////////////////////////////////

    2118. 

  2118. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2119. 

  2119. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2120. 

  2120. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2121. 

  2121. ///////////////////////////////////////////////////////////////////////////////////////

    2122. 

  2122. function getSQLStmtDelSessionArray($arrnTemp){

    2123. 

  2123.     $SQLStmt="DELETE FROM session";

    2124. 

  2124.     $SQLStmt.=" WHERE ses_id<>ses_id";

    2125. 

  2125.     for ($i=0; $i<=count($arrnTemp); $i++){

    2126. 

  2126.         if (is_numeric($arrnTemp[$i])){

    2127. 

  2127.             $SQLStmt.=" OR ses_id=".$arrnTemp[$i];

    2128. 

  2128.         }

    2129. 

  2129.     }

    2130. 

  2130.     return $SQLStmt;

    2131. 

  2131. }

    2132. 

  2132. 

    2133. 

  2133. ///////////////////////////////////////////////////////////////////////////////////////

    2134. 

  2134. // Retourne la requete SQL necessaire pour faire un DELETE

    2135. 

  2135. ///////////////////////////////////////////////////////////////////////////////////////

    2136. 

  2136. function getSQLStmtDelUsager($usr_id){

    2137. 

  2137.     $SQLStmt="DELETE FROM usager";

    2138. 

  2138.     $SQLStmt.=" WHERE usr_id=".$usr_id;

    2139. 

  2139.     return $SQLStmt;

    2140. 

  2140. }

    2141. 

  2141. 

    2142. 

  2142. ///////////////////////////////////////////////////////////////////////////////////////

    2143. 

  2143. // Retourne la requete SQL necessaire pour faire un DELETE sur un ARRAY

    2144. 

  2144. //  IN:     $arrnTemp: tableau contenant les ID a supprimer

    2145. 

  2145. //  OUT:    (sqlstmt) requ�te sql effectuant la supression

    2146. 

  2146. ///////////////////////////////////////////////////////////////////////////////////////

    2147. 

  2147. function getSQLStmtDelUsagerArray($arrnTemp){

    2148. 

  2148.     $SQLStmt="DELETE FROM usager";

    2149. 

  2149.     $SQLStmt.=" WHERE usr_id<>usr_id";

    2150. 

  2150.     for ($i=0; $i<=count($arrnTemp); $i++){

    2151. 

  2151.         if (is_numeric($arrnTemp[$i])){

    2152. 

  2152.             $SQLStmt.=" OR usr_id=".$arrnTemp[$i];

    2153. 

  2153.         }

    2154. 

  2154.     }

    2155. 

  2155.     return $SQLStmt;

    2156. 

  2156. }

    2157. 

  2157. 

    2158. 

  2158. ///////////////////////////////////////////////////////////////////////////////////////

    2159. 

  2159. // Retourne la requete SQL necessaire pour faire un DELETE

    2160. 

  2160. ///////////////////////////////////////////////////////////////////////////////////////

    2161. 

  2161. function getSQLStmtDelUsagerUsrTypeArray($usr_id, $arrnTemp){

    2162. 

  2162.     $SQLStmt="DELETE FROM usager_usagerType";

    2163. 

  2163.     $SQLStmt.=" WHERE usr_id=".$usr_id;

    2164. 

  2164.     $SQLStmt.=" AND (ut_id<>ut_id";

    2165. 

  2165.     for ($i=0; $i<=count($arrnTemp); $i++){

    2166. 

  2166.         if (is_numeric($arrnTemp[$i])){

    2167. 

  2167.             $SQLStmt.=" OR ut_id=".$arrnTemp[$i];

    2168. 

  2168.         }

    2169. 

  2169.     }

    2170. 

  2170.     $SQLStmt.=")";

    2171. 

  2171.     return $SQLStmt;

    2172. 

  2172. }

    2173. 

  2173. 

    2174. 

  2174. ///////////////////////////////////////////////////////////////////////////////////////

    2175. 

  2175. // Retourne la requete SQL necessaire pour faire un INSERT

    2176. 

  2176. ///////////////////////////////////////////////////////////////////////////////////////

    2177. 

  2177. function getSQLStmtInsActivite($act_activite, $prj_id){

    2178. 

  2178.     $SQLStmt="INSERT INTO activite";

    2179. 

  2179.     $SQLField="(";

    2180. 

  2180.     $SQLValue="VALUES(";

    2181. 

  2181.     $SQLField.="act_activite,";

    2182. 

  2182.     $SQLValue.="'".fixPGQuote($act_activite)."',";

    2183. 

  2183.     $SQLField.="prj_id)";

    2184. 

  2184.     if (is_numeric($prj_id)){

    2185. 

  2185.         $SQLValue.=$prj_id.")";

    2186. 

  2186.     }

    2187. 

  2187.     else{

    2188. 

  2188.         $SQLValue.="NULL)";

    2189. 

  2189.     }

    2190. 

  2190.     //Building SQLStmt

    2191. 

  2191.     $SQLStmt.=$SQLField.$SQLValue;

    2192. 

  2192.     return ($SQLStmt);

    2193. 

  2193. }

    2194. 

  2194. 

    2195. 

  2195. ///////////////////////////////////////////////////////////////////////////////////////

    2196. 

  2196. // Retourne la requete SQL necessaire pour faire un INSERT

    2197. 

  2197. ///////////////////////////////////////////////////////////////////////////////////////

    2198. 

  2198. function getSQLStmtInsAtelier($atl_atelier){

    2199. 

  2199.     $SQLStmt="INSERT INTO atelier";

    2200. 

  2200.     $SQLField="(";

    2201. 

  2201.     $SQLValue="VALUES(";

    2202. 

  2202.     $SQLField.="atl_atelier)";

    2203. 

  2203.     $SQLValue.="'".fixPGQuote($atl_atelier)."')";

    2204. 

  2204.     //Building SQLStmt

    2205. 

  2205.     $SQLStmt.=$SQLField.$SQLValue;

    2206. 

  2206.     return ($SQLStmt);

    2207. 

  2207. } 

    2208. 

  2208. 

    2209. 

  2209. ///////////////////////////////////////////////////////////////////////////////////////

    2210. 

  2210. // Retourne la requete SQL necessaire pour faire un INSERT

    2211. 

  2211. ///////////////////////////////////////////////////////////////////////////////////////

    2212. 

  2212. function getSQLStmtInsAtelierClasse($atl_id, $cla_id){

    2213. 

  2213.     $SQLStmt="INSERT INTO atelier_classe";

    2214. 

  2214.     $SQLField="(";

    2215. 

  2215.     $SQLValue="VALUES(";

    2216. 

  2216.     $SQLField.="atl_id,";

    2217. 

  2217.     $SQLValue.=$atl_id.",";

    2218. 

  2218.     $SQLField.="cla_id)";

    2219. 

  2219.     $SQLValue.=$cla_id.")";

    2220. 

  2220.     //Building SQLStmt

    2221. 

  2221.     $SQLStmt.=$SQLField.$SQLValue;

    2222. 

  2222.     return ($SQLStmt);

    2223. 

  2223. } 

    2224. 

  2224. 

    2225. 

  2225. ///////////////////////////////////////////////////////////////////////////////////////

    2226. 

  2226. // Retourne la requete SQL necessaire pour faire un INSERT

    2227. 

  2227. ///////////////////////////////////////////////////////////////////////////////////////

    2228. 

  2228. function getSQLStmtInsAtelierClientele($atl_id, $cli_id){

    2229. 

  2229.     $SQLStmt="INSERT INTO atelier_clientele";

    2230. 

  2230.     $SQLField="(";

    2231. 

  2231.     $SQLValue="VALUES(";

    2232. 

  2232.     $SQLField.="atl_id,";

    2233. 

  2233.     $SQLValue.=$atl_id.",";

    2234. 

  2234.     $SQLField.="cli_id)";

    2235. 

  2235.     $SQLValue.=$cli_id.")";

    2236. 

  2236.     //Building SQLStmt

    2237. 

  2237.     $SQLStmt.=$SQLField.$SQLValue;

    2238. 

  2238.     return ($SQLStmt);

    2239. 

  2239. } 

    2240. 

  2240. 

    2241. 

  2241. ///////////////////////////////////////////////////////////////////////////////////////

    2242. 

  2242. // Retourne la requete SQL necessaire pour faire un INSERT

    2243. 

  2243. ///////////////////////////////////////////////////////////////////////////////////////

    2244. 

  2244. function getSQLStmtInsAtelierExpertise($atl_id, $exp_id){

    2245. 

  2245.     $SQLStmt="INSERT INTO atelier_expertise";

    2246. 

  2246.     $SQLField="(";

    2247. 

  2247.     $SQLValue="VALUES(";

    2248. 

  2248.     $SQLField.="atl_id,";

    2249. 

  2249.     $SQLValue.=$atl_id.",";

    2250. 

  2250.     $SQLField.="exp_id)";

    2251. 

  2251.     $SQLValue.=$exp_id.")";

    2252. 

  2252.     //Building SQLStmt

    2253. 

  2253.     $SQLStmt.=$SQLField.$SQLValue;

    2254. 

  2254.     return ($SQLStmt);

    2255. 

  2255. }

    2256. 

  2256. 

    2257. 

  2257. ///////////////////////////////////////////////////////////////////////////////////////

    2258. 

  2258. // Retourne la requete SQL necessaire pour faire un INSERT

    2259. 

  2259. ///////////////////////////////////////////////////////////////////////////////////////

    2260. 

  2260. function getSQLStmtInsAtelierProjet($atl_id, $prj_id){

    2261. 

  2261.     $SQLStmt="INSERT INTO projet_atelier";

    2262. 

  2262.     $SQLField="(";

    2263. 

  2263.     $SQLValue="VALUES(";

    2264. 

  2264.     $SQLField.="atl_id,";

    2265. 

  2265.     $SQLValue.=$atl_id.",";

    2266. 

  2266.     $SQLField.="prj_id)";

    2267. 

  2267.     $SQLValue.=$prj_id.")";

    2268. 

  2268.     //Building SQLStmt

    2269. 

  2269.     $SQLStmt.=$SQLField.$SQLValue;

    2270. 

  2270.     return ($SQLStmt);

    2271. 

  2271. }

    2272. 

  2272. 

    2273. 

  2273. ///////////////////////////////////////////////////////////////////////////////////////

    2274. 

  2274. // Retourne la requete SQL necessaire pour faire un INSERT

    2275. 

  2275. ///////////////////////////////////////////////////////////////////////////////////////

    2276. 

  2276. function getSQLStmtInsCedule($ced_cedule, $gab_id){

    2277. 

  2277.     $SQLStmt="INSERT INTO ceduleur";

    2278. 

  2278.     $SQLField="(";

    2279. 

  2279.     $SQLValue="VALUES(";

    2280. 

  2280.     $SQLField.="ced_cedule,";

    2281. 

  2281.     $SQLValue.="'".fixPGQuote($ced_cedule)."',";

    2282. 

  2282.     $SQLField.="gab_id)";

    2283. 

  2283.     $SQLValue.=$gab_id.")";

    2284. 

  2284.     //Building SQLStmt

    2285. 

  2285.     $SQLStmt.=$SQLField.$SQLValue;

    2286. 

  2286.     return ($SQLStmt);

    2287. 

  2287. }

    2288. 

  2288. 

    2289. 

  2289. ///////////////////////////////////////////////////////////////////////////////////////

    2290. 

  2290. // Retourne la requete SQL necessaire pour faire un INSERT

    2291. 

  2291. ///////////////////////////////////////////////////////////////////////////////////////

    2292. 

  2292. function getSQLStmtInsClasse($parent, $label){

    2293. 

  2293.     return (getSQLStmtInsNode(1, $parent, $label));

    2294. 

  2294. }

    2295. 

  2295. 

    2296. 

  2296. ///////////////////////////////////////////////////////////////////////////////////////

    2297. 

  2297. // Retourne la requete SQL necessaire pour faire un INSERT

    2298. 

  2298. ///////////////////////////////////////////////////////////////////////////////////////

    2299. 

  2299. /* $Author: stacil $ [$Date: 2008/07/03 18:29:46 $]

    2300. 

  2300. function getSQLStmtInsClientele($cli_clientele, $cli_description){

    2301. 

  2301.     $SQLStmt="INSERT INTO clientele";

    2302. 

  2302.     $SQLField="(";

    2303. 

  2303.     $SQLValue="VALUES(";

    2304. 

  2304.     $SQLField=$SQLField."cli_clientele,";

    2305. 

  2305.     $SQLValue=$SQLValue."'".fixPGQuote($cli_clientele)."',";

    2306. 

  2306.     $SQLField=$SQLField."cli_description)";

    2307. 

  2307.     $SQLValue=$SQLValue."'".fixPGQuote($cli_description)."')";

    2308. 

  2308.     //Building SQLStmt

    2309. 

  2309.     $SQLStmt.=$SQLField.$SQLValue;

    2310. 

  2310.     return $SQLStmt;

    2311. 

  2311. }

    2312. 

  2312. */

    2313. 

  2313. function getSQLStmtInsClientele($parent, $label) {

    2314. 

  2314. 	return (getSQLStmtInsNode(3, $parent, $label));

    2315. 

  2315. }

    2316. 

  2316. 

    2317. 

  2317. ///////////////////////////////////////////////////////////////////////////////////////

    2318. 

  2318. // Retourne la requete SQL necessaire pour faire un INSERT

    2319. 

  2319. ///////////////////////////////////////////////////////////////////////////////////////

    2320. 

  2320. function getSQLStmtInsCourriel($gab_id, $cou_paramValeur){

    2321. 

  2321. 	// cou_paramValeur = no_fiche_session,id_usager (SSSSS,UUUUU)

    2322. 

  2322.     return "INSERT INTO courriel ( gab_id, cou_paramValeur ) VALUES ( '" . $gab_id."'," . "'" . fixPGQuote( $cou_paramValeur ) . "')";

    2323. 

  2323. }

    2324. 

  2324. 

    2325. 

  2325. ///////////////////////////////////////////////////////////////////////////////////////

    2326. 

  2326. // Retourne la requete SQL necessaire pour faire un INSERT

    2327. 

  2327. ///////////////////////////////////////////////////////////////////////////////////////

    2328. 

  2328. function getSQLStmtInsGabarit($gab_gabarit){

    2329. 

  2329.     $SQLStmt="INSERT INTO gabarit";

    2330. 

  2330.     $SQLField="(";

    2331. 

  2331.     $SQLValue="VALUES(";

    2332. 

  2332.     $SQLField.="gab_gabarit)";

    2333. 

  2333.     $SQLValue.="'".fixPGQuote($gab_gabarit)."')";

    2334. 

  2334.     //Building SQLStmt

    2335. 

  2335.     $SQLStmt.=$SQLField.$SQLValue;

    2336. 

  2336.     return ($SQLStmt);

    2337. 

  2337. }

    2338. 

  2338. 

    2339. 

  2339. ///////////////////////////////////////////////////////////////////////////////////////

    2340. 

  2340. // Retourne la requete SQL necessaire pour faire un INSERT

    2341. 

  2341. ///////////////////////////////////////////////////////////////////////////////////////

    2342. 

  2342. function getSQLStmtInsGabaritBalise($gab_id, $gb_balise, $gb_champ, $gb_description){

    2343. 

  2343.     $SQLStmt="INSERT INTO gabaritBalise";

    2344. 

  2344.     $SQLField="(";

    2345. 

  2345.     $SQLValue="VALUES(";

    2346. 

  2346.     $SQLField=$SQLField."gab_id,";

    2347. 

  2347.     $SQLValue=$SQLValue.$gab_id.",";

    2348. 

  2348.     $SQLField=$SQLField."gb_balise,";

    2349. 

  2349.     $SQLValue=$SQLValue."'".fixPGQuote($gb_balise)."',";

    2350. 

  2350.     $SQLField=$SQLField."gb_champ,";

    2351. 

  2351.     $SQLValue=$SQLValue."'".fixPGQuote($gb_champ)."',";

    2352. 

  2352.     $SQLField=$SQLField."gb_description)";

    2353. 

  2353.     $SQLValue=$SQLValue."'".fixPGQuote($gb_description)."')";

    2354. 

  2354.     //Building SQLStmt

    2355. 

  2355.     $SQLStmt.=$SQLField.$SQLValue;

    2356. 

  2356.     return $SQLStmt;

    2357. 

  2357. }

    2358. 

  2358. 

    2359. 

  2359. ///////////////////////////////////////////////////////////////////////////////////////

    2360. 

  2360. // Retourne la requete SQL necessaire pour faire un INSERT

    2361. 

  2361. ///////////////////////////////////////////////////////////////////////////////////////

    2362. 

  2362. function getSQLStmtInsInscription($usr_id, $ses_id, $is_ipsoumission, $ie_id, $is_majpar_usr_id){

    2363. 

  2363.     $SQLStmt="INSERT INTO inscriptionSession";

    2364. 

  2364.     $SQLField="(";

    2365. 

  2365.     $SQLValue="VALUES(";

    2366. 

  2366.     $SQLField.="usr_id,";

    2367. 

  2367.     $SQLValue.=$usr_id.",";

    2368. 

  2368.     $SQLField.="ses_id,";

    2369. 

  2369.     $SQLValue.=$ses_id.",";

    2370. 

  2370.     $SQLField.="is_datesoumission,";

    2371. 

  2371.     $SQLValue.="NOW(),";

    2372. 

  2372.     $SQLField.="is_ipsoumission,";

    2373. 

  2373.     $SQLValue.="'".fixPGQuote($is_ipsoumission)."',";

    2374. 

  2374.     $SQLField.="ie_id,";

    2375. 

  2375.     $SQLValue.=$ie_id.",";

    2376. 

  2376.     $SQLField.='lieu_id_aInscription,';

    2377. 

  2377.     $SQLValue.="(SELECT Li_id from Usager WHERE usr_id=".$usr_id."),";

    2378. 

  2378.     $SQLField.="is_majpar_usr_id)";

    2379. 

  2379.     $SQLValue.=$is_majpar_usr_id.")";

    2380. 

  2380.     //Building SQLStmt

    2381. 

  2381.     $SQLStmt.=$SQLField.$SQLValue;

    2382. 

  2382.     return $SQLStmt;

    2383. 

  2383. }

    2384. 

  2384. 

    2385. 

  2385. ///////////////////////////////////////////////////////////////////////////////////////

    2386. 

  2386. // Retourne la requete SQL necessaire pour faire un INSERT

    2387. 

  2387. ///////////////////////////////////////////////////////////////////////////////////////

    2388. 

  2388. function getSQLStmtInsLieu($li_lieu){

    2389. 

  2389.     $SQLStmt="INSERT INTO lieu";

    2390. 

  2390.     $SQLField="(";

    2391. 

  2391.     $SQLValue="VALUES(";

    2392. 

  2392.     $SQLField.="li_lieu)";

    2393. 

  2393.     $SQLValue.="'".fixPGQuote($li_lieu)."')";

    2394. 

  2394.     //Building SQLStmt

    2395. 

  2395.     $SQLStmt.=$SQLField.$SQLValue;

    2396. 

  2396.     return ($SQLStmt);

    2397. 

  2397. } 

    2398. 

  2398. 

    2399. 

  2399. ///////////////////////////////////////////////////////////////////////////////////////

    2400. 

  2400. // Retourne la requete SQL necessaire pour faire un INSERT

    2401. 

  2401. ///////////////////////////////////////////////////////////////////////////////////////

    2402. 

  2402. function getSQLStmtInsExpertise($parent, $label){

    2403. 

  2403.     return (getSQLStmtInsNode(2, $parent, $label));

    2404. 

  2404. }

    2405. 

  2405. 

    2406. 

  2406. ///////////////////////////////////////////////////////////////////////////////////////

    2407. 

  2407. // Retourne la requete SQL necessaire pour faire un INSERT

    2408. 

  2408. ///////////////////////////////////////////////////////////////////////////////////////

    2409. 

  2409. function getSQLStmtInsLieuAdmin($li_id, $usr_id, $la_responsable)

    2410. 

  2410. {

    2411. 

  2411. 	return getSQLStmtInsLieuAdminFull($li_id, $usr_id, $la_responsable, 'f');

    2412. 

  2412. }

    2413. 

  2413. 

    2414. 

  2414. 

    2415. 

  2415. 

    2416. 

  2416. function getSQLStmtInsLieuAdminFull($li_id, $usr_id, $la_responsable, $la_loi90){

    2417. 

  2417.     $SQLStmt="INSERT INTO lieuAdmin";

    2418. 

  2418.     $SQLField="(";

    2419. 

  2419.     $SQLValue="VALUES(";

    2420. 

  2420.     $SQLField.="li_id,";

    2421. 

  2421.     $SQLValue.=$li_id.",";

    2422. 

  2422.     $SQLField.="usr_id,";

    2423. 

  2423.     $SQLValue.=$usr_id.",";

    2424. 

  2424.     $SQLField.="la_responsable,";

    2425. 

  2425.     if (!strcasecmp($la_responsable,"t")){

    2426. 

  2426.         $SQLValue.="'t',";

    2427. 

  2427.     }

    2428. 

  2428.     else{

    2429. 

  2429.         $SQLValue.="'f',";

    2430. 

  2430.     }

    2431. 

  2431. 

    2432. 

  2432. 	$SQLField.="la_courriel_loi90)";

    2433. 

  2433. 	    

    2434. 

  2434. 	if (!strcasecmp($la_loi90,"t"))

    2435. 

  2435. 	{

    2436. 

  2436.         $SQLValue.="'t')";

    2437. 

  2437.     }

    2438. 

  2438.     else

    2439. 

  2439. 	{

    2440. 

  2440.         $SQLValue.="'f')";

    2441. 

  2441.     };

    2442. 

  2442. 

    2443. 

  2443.     //Building SQLStmt

    2444. 

  2444.     $SQLStmt.=$SQLField.$SQLValue;

    2445. 

  2445.     return ($SQLStmt);

    2446. 

  2446. }

    2447. 

  2447. 

    2448. 

  2448. ///////////////////////////////////////////////////////////////////////////////////////

    2449. 

  2449. // Retourne la requete SQL necessaire pour faire un INSERT

    2450. 

  2450. ///////////////////////////////////////////////////////////////////////////////////////

    2451. 

  2451. function getSQLStmtInsLieuSupport($li_id, $usr_id, $ls_responsable){

    2452. 

  2452.     $SQLStmt="INSERT INTO lieuSupport";

    2453. 

  2453.     $SQLField="(";

    2454. 

  2454.     $SQLValue="VALUES(";

    2455. 

  2455.     $SQLField.="li_id,";

    2456. 

  2456.     $SQLValue.=$li_id.",";

    2457. 

  2457.     $SQLField.="usr_id,";

    2458. 

  2458.     $SQLValue.=$usr_id.",";

    2459. 

  2459.     $SQLField.="ls_responsable)";

    2460. 

  2460.     if (!strcasecmp($ls_responsable,"t")){

    2461. 

  2461.         $SQLValue.="'t')";

    2462. 

  2462.     }

    2463. 

  2463.     else{

    2464. 

  2464.         $SQLValue.="'f')";

    2465. 

  2465.     }

    2466. 

  2466.     //Building SQLStmt

    2467. 

  2467.     $SQLStmt.=$SQLField.$SQLValue;

    2468. 

  2468.     return ($SQLStmt);

    2469. 

  2469. }

    2470. 

  2470. 

    2471. 

  2471. ///////////////////////////////////////////////////////////////////////////////////////

    2472. 

  2472. // Retourne la requete SQL necessaire pour faire un INSERT

    2473. 

  2473. ///////////////////////////////////////////////////////////////////////////////////////

    2474. 

  2474. function getSQLStmtInsNode($tr_id, $parent, $label){

    2475. 

  2475.     $SQLStmt="INSERT INTO nodes";

    2476. 

  2476.     $SQLField="(";

    2477. 

  2477.     $SQLValue="VALUES(";

    2478. 

  2478.     $SQLField.="tr_id,";

    2479. 

  2479.     if (is_numeric($tr_id)){

    2480. 

  2480.         $SQLValue.=$tr_id.",";

    2481. 

  2481.     }

    2482. 

  2482.     else{

    2483. 

  2483.         $SQLValue.="NULL,";

    2484. 

  2484.     }

    2485. 

  2485.     $SQLField.="parent,";

    2486. 

  2486.     if (is_numeric($parent)){

    2487. 

  2487.         $SQLValue.=$parent.",";

    2488. 

  2488.     }

    2489. 

  2489.     else{

    2490. 

  2490.         $SQLValue.="NULL,";

    2491. 

  2491.     }

    2492. 

  2492.     $SQLField.="etiquette)";

    2493. 

  2493.     $SQLValue.="'".fixPGQuote($label)."')";

    2494. 

  2494.     //Building SQLStmt

    2495. 

  2495.     $SQLStmt.=$SQLField.$SQLValue;

    2496. 

  2496.     return ($SQLStmt);

    2497. 

  2497. }

    2498. 

  2498. 

    2499. 

  2499. ///////////////////////////////////////////////////////////////////////////////////////

    2500. 

  2500. // Retourne la requete SQL necessaire pour faire un INSERT

    2501. 

  2501. ///////////////////////////////////////////////////////////////////////////////////////

    2502. 

  2502. function getSQLStmtInsPresence($sea_id, $usr_id, $pr_presence){

    2503. 

  2503.     $SQLStmt="INSERT INTO presence";

    2504. 

  2504.     $SQLField="(";

    2505. 

  2505.     $SQLValue="VALUES(";

    2506. 

  2506.     $SQLField.="sea_id,";

    2507. 

  2507.     $SQLValue.=$sea_id.",";

    2508. 

  2508.     $SQLField.="usr_id,";

    2509. 

  2509.     $SQLValue.=$usr_id.",";

    2510. 

  2510.     $SQLField.="pr_presence)";

    2511. 

  2511.     if (!strcasecmp($pr_presence,"t")){

    2512. 

  2512.         $SQLValue.="'t')";

    2513. 

  2513.     }

    2514. 

  2514.     else{

    2515. 

  2515.         $SQLValue.="'f')";

    2516. 

  2516.     }

    2517. 

  2517.     //Building SQLStmt

    2518. 

  2518.     $SQLStmt.=$SQLField.$SQLValue;

    2519. 

  2519.     return ($SQLStmt);

    2520. 

  2520. } 

    2521. 

  2521. 

    2522. 

  2522. ///////////////////////////////////////////////////////////////////////////////////////

    2523. 

  2523. // Retourne la requete SQL necessaire pour faire un INSERT

    2524. 

  2524. ///////////////////////////////////////////////////////////////////////////////////////

    2525. 

  2525. function getSQLStmtInsProjet($prj_projet, $pt_id){

    2526. 

  2526.     $SQLStmt="INSERT INTO projet";

    2527. 

  2527.     $SQLField="(";

    2528. 

  2528.     $SQLValue="VALUES(";

    2529. 

  2529.     $SQLField.="prj_projet,";

    2530. 

  2530.     $SQLValue.="'".fixPGQuote($prj_projet)."',";

    2531. 

  2531.     $SQLField.="pt_id)";

    2532. 

  2532.     $SQLValue.=$pt_id.")";

    2533. 

  2533.     //Building SQLStmt

    2534. 

  2534.     $SQLStmt.=$SQLField.$SQLValue;

    2535. 

  2535.     return ($SQLStmt);

    2536. 

  2536. } 

    2537. 

  2537. 

    2538. 

  2538. function getSQLStmtInsProjetAdmin($prj_id, $usr_id, $pa_responsable){

    2539. 

  2539.     $SQLStmt="INSERT INTO projetAdmin";

    2540. 

  2540.     $SQLField="(";

    2541. 

  2541.     $SQLValue="VALUES(";

    2542. 

  2542.     $SQLField.="prj_id,";

    2543. 

  2543.     $SQLValue.=$prj_id.",";

    2544. 

  2544.     $SQLField.="usr_id,";

    2545. 

  2545.     $SQLValue.=$usr_id.",";

    2546. 

  2546.     $SQLField.="pa_responsable)";

    2547. 

  2547.     if (!strcasecmp($pa_responsable,"t")){

    2548. 

  2548.         $SQLValue.="'t')";

    2549. 

  2549.     }

    2550. 

  2550.     else{

    2551. 

  2551.         $SQLValue.="'f')";

    2552. 

  2552.     }

    2553. 

  2553.     //Building SQLStmt

    2554. 

  2554.     $SQLStmt.=$SQLField.$SQLValue;

    2555. 

  2555.     return ($SQLStmt);

    2556. 

  2556. }

    2557. 

  2557. 

    2558. 

  2558. ///////////////////////////////////////////////////////////////////////////////////////

    2559. 

  2559. // Retourne la requete SQL necessaire pour faire un INSERT

    2560. 

  2560. ///////////////////////////////////////////////////////////////////////////////////////

    2561. 

  2561. function getSQLStmtInsSeance($ses_id){

    2562. 

  2562.     $SQLStmt="INSERT INTO seance";

    2563. 

  2563.     $SQLField="(";

    2564. 

  2564.     $SQLValue="VALUES(";

    2565. 

  2565.     $SQLField.="ses_id)";

    2566. 

  2566.     $SQLValue.=$ses_id.")";

    2567. 

  2567.     //Building SQLStmt

    2568. 

  2568.     $SQLStmt.=$SQLField.$SQLValue;

    2569. 

  2569.     return ($SQLStmt);

    2570. 

  2570. } 

    2571. 

  2571. 

    2572. 

  2572. ///////////////////////////////////////////////////////////////////////////////////////

    2573. 

  2573. // Retourne la requete SQL necessaire pour faire un INSERT

    2574. 

  2574. ///////////////////////////////////////////////////////////////////////////////////////

    2575. 

  2575. function getSQLStmtInsSession($prj_id, $atl_id){

    2576. 

  2576.     $SQLStmt="INSERT INTO session";

    2577. 

  2577.     $SQLField="(";

    2578. 

  2578.     $SQLValue="VALUES(";

    2579. 

  2579.     $SQLField.="prj_id,";

    2580. 

  2580.     $SQLValue.=$prj_id.",";

    2581. 

  2581.     $SQLField.="atl_id)";

    2582. 

  2582.     $SQLValue.=$atl_id.")";

    2583. 

  2583.     //Building SQLStmt

    2584. 

  2584.     $SQLStmt.=$SQLField.$SQLValue;

    2585. 

  2585.     return ($SQLStmt);

    2586. 

  2586. } 

    2587. 

  2587. 

    2588. 

  2588. ///////////////////////////////////////////////////////////////////////////////////////

    2589. 

  2589. // Retourne la requete SQL necessaire pour faire un INSERT

    2590. 

  2590. ///////////////////////////////////////////////////////////////////////////////////////

    2591. 

  2591. function getSQLStmtInsSessionAnimation($ses_id, $usr_id, $an_responsable){

    2592. 

  2592.     $SQLStmt="INSERT INTO animation";

    2593. 

  2593.     $SQLField="(";

    2594. 

  2594.     $SQLValue="VALUES(";

    2595. 

  2595.     $SQLField.="ses_id,";

    2596. 

  2596.     $SQLValue.=$ses_id.",";

    2597. 

  2597.     $SQLField.="usr_id,";

    2598. 

  2598.     $SQLValue.=$usr_id.",";

    2599. 

  2599.     $SQLField.="an_responsable)";

    2600. 

  2600.     if (!strcasecmp($an_responsable,"t")){

    2601. 

  2601.         $SQLValue.="'t')";

    2602. 

  2602.     }

    2603. 

  2603.     else{

    2604. 

  2604.         $SQLValue.="'f')";

    2605. 

  2605.     }

    2606. 

  2606.     //Building SQLStmt

    2607. 

  2607.     $SQLStmt.=$SQLField.$SQLValue;

    2608. 

  2608.     return ($SQLStmt);

    2609. 

  2609. }

    2610. 

  2610. 

    2611. 

  2611. ///////////////////////////////////////////////////////////////////////////////////////

    2612. 

  2612. // Retourne la requete SQL necessaire pour faire un INSERT

    2613. 

  2613. ///////////////////////////////////////////////////////////////////////////////////////

    2614. 

  2614. function getSQLStmtInsUsager($usr_login, $usr_nom, $usr_prenom, $li_id){

    2615. 

  2615.     $SQLStmt="INSERT INTO usager";

    2616. 

  2616.     $SQLField="(";

    2617. 

  2617.     $SQLValue="VALUES(";

    2618. 

  2618.     $SQLField.="usr_login,";

    2619. 

  2619.     $SQLValue.="'".fixPGQuote(rtrim($usr_login))."',";

    2620. 

  2620.     $SQLField.="usr_nom,";

    2621. 

  2621.     $SQLValue.="'".fixPGQuote(rtrim($usr_nom))."',";

    2622. 

  2622.     $SQLField.="usr_prenom,";

    2623. 

  2623.     $SQLValue.="'".fixPGQuote(rtrim($usr_prenom))."',";

    2624. 

  2624.     $SQLField.="li_id)";

    2625. 

  2625.     if (is_numeric($li_id)){

    2626. 

  2626.         $SQLValue.=$li_id.")";

    2627. 

  2627.     }

    2628. 

  2628.     else{

    2629. 

  2629.         $SQLValue.="NULL)";

    2630. 

  2630.     }

    2631. 

  2631.     //Building SQLStmt

    2632. 

  2632.     $SQLStmt.=$SQLField.$SQLValue;

    2633. 

  2633.     return ($SQLStmt);

    2634. 

  2634. } 

    2635. 

  2635. 

    2636. 

  2636. ///////////////////////////////////////////////////////////////////////////////////////

    2637. 

  2637. // Retourne la requete SQL necessaire pour faire un INSERT

    2638. 

  2638. ///////////////////////////////////////////////////////////////////////////////////////

    2639. 

  2639. function getSQLStmtInsUsagerUsrType($usr_id, $ut_id){

    2640. 

  2640.     $SQLStmt="INSERT INTO usager_usagerType";

    2641. 

  2641.     $SQLField="(";

    2642. 

  2642.     $SQLValue="VALUES(";

    2643. 

  2643.     $SQLField.="usr_id,";

    2644. 

  2644.     $SQLValue.=$usr_id.",";

    2645. 

  2645.     $SQLField.="ut_id)";

    2646. 

  2646.     $SQLValue.=$ut_id.")";

    2647. 

  2647.     //Building SQLStmt

    2648. 

  2648.     $SQLStmt.=$SQLField.$SQLValue;

    2649. 

  2649.     return ($SQLStmt);

    2650. 

  2650. } 

    2651. 

  2651. 

    2652. 

  2652. ///////////////////////////////////////////////////////////////////////////////////////

    2653. 

  2653. // Retourne la requete SQL necessaire pour faire un UPDATE

    2654. 

  2654. ///////////////////////////////////////////////////////////////////////////////////////

    2655. 

  2655. function getSQLStmtUpdActivite($id, $act_activite, $act_description, $act_lieu, $act_datedebut, $act_datefin, $act_frais, $act_annule, $act_annuleraison, $prj_id, $act_valide){

    2656. 

  2656.     $SQLStmt="UPDATE activite SET";

    2657. 

  2657.     $SQLStmt.=" act_activite = '".fixPGQuote($act_activite)."',";

    2658. 

  2658.     $SQLStmt.=" act_description = '".fixPGQuote($act_description)."',";

    2659. 

  2659.     $SQLStmt.=" act_lieu = '".fixPGQuote($act_lieu)."',";

    2660. 

  2660.     if (isTimeStamp($act_datedebut)){

    2661. 

  2661.         $SQLStmt.=" act_datedebut = '".fixPGQuote($act_datedebut)."',";

    2662. 

  2662.     }

    2663. 

  2663.     else{

    2664. 

  2664.         $SQLStmt.=" act_datedebut = NULL,";

    2665. 

  2665.     }

    2666. 

  2666.     if (isTimeStamp($act_datefin)){

    2667. 

  2667.         $SQLStmt.=" act_datefin = '".fixPGQuote($act_datefin)."',";

    2668. 

  2668.     }

    2669. 

  2669.     else{

    2670. 

  2670.         $SQLStmt.=" act_datefin = NULL,";

    2671. 

  2671.     }

    2672. 

  2672.     $SQLStmt.=" act_frais = '".fixPGQuote($act_frais)."',";

    2673. 

  2673.     if (!strcasecmp($act_annule,"t")){

    2674. 

  2674.         $SQLStmt.=" act_annule = 't',";

    2675. 

  2675.     }

    2676. 

  2676.     else{

    2677. 

  2677.         $SQLStmt.=" act_annule = 'f',";

    2678. 

  2678.     }

    2679. 

  2679.     $SQLStmt.=" act_annuleraison = '".fixPGQuote($act_annuleraison)."',";

    2680. 

  2680.     if (is_numeric($prj_id)){

    2681. 

  2681.         $SQLStmt.=" prj_id = ".fixPGQuote($prj_id).",";

    2682. 

  2682.     }

    2683. 

  2683.     else{

    2684. 

  2684.         $SQLStmt.=" prj_id = NULL,";

    2685. 

  2685.     }

    2686. 

  2686.     if (!strcasecmp($act_valide,"t")){

    2687. 

  2687.         $SQLStmt.=" act_valide = 't'";

    2688. 

  2688.     }

    2689. 

  2689.     else{

    2690. 

  2690.         $SQLStmt.=" act_valide = 'f'";

    2691. 

  2691.     }

    2692. 

  2692.     $SQLStmt.=" WHERE act_id = ".$id;

    2693. 

  2693.     return $SQLStmt;

    2694. 

  2694. }

    2695. 

  2695. 

    2696. 

  2696. ///////////////////////////////////////////////////////////////////////////////////////

    2697. 

  2697. // Retourne la requete SQL necessaire pour faire un UPDATE

    2698. 

  2698. ///////////////////////////////////////////////////////////////////////////////////////

    2699. 

  2699. function getSQLStmtUpdAtelier($id, $atl_atelier, $atl_description, $atl_url, $atl_prealable, $atl_condition, $atl_calendrier, $atl_fraistypique, $atl_note, $atl_commentaire, $atl_alacartedisponible, $usr_id, $atl_valide){

    2700. 

  2700.     $SQLStmt="UPDATE atelier SET";

    2701. 

  2701.     $SQLStmt.=" atl_atelier = '".fixPGQuote($atl_atelier)."',";

    2702. 

  2702.     $SQLStmt.=" atl_description = '".fixPGQuote($atl_description)."',";

    2703. 

  2703.     $SQLStmt.=" atl_url = '".fixPGQuote($atl_url)."',";

    2704. 

  2704.     $SQLStmt.=" atl_prealable = '".fixPGQuote($atl_prealable)."',";

    2705. 

  2705.     $SQLStmt.=" atl_condition = '".fixPGQuote($atl_condition)."',";

    2706. 

  2706.     $SQLStmt.=" atl_calendrier = '".fixPGQuote($atl_calendrier)."',";

    2707. 

  2707.     $SQLStmt.=" atl_fraistypique = '".fixPGQuote($atl_fraistypique)."',";

    2708. 

  2708.     $SQLStmt.=" atl_note = '".fixPGQuote($atl_note)."',";

    2709. 

  2709.     $SQLStmt.=" atl_commentaire = '".fixPGQuote($atl_commentaire)."',";

    2710. 

  2710.     if (!strcasecmp($atl_alacartedisponible,"t")){

    2711. 

  2711.         $SQLStmt.=" atl_alacartedisponible = 't',";

    2712. 

  2712.     }

    2713. 

  2713.     else{

    2714. 

  2714.         $SQLStmt.=" atl_alacartedisponible = 'f',";

    2715. 

  2715.     }

    2716. 

  2716.     if (is_numeric($usr_id)){

    2717. 

  2717.         $SQLStmt.=" usr_id = ".fixPGQuote($usr_id).",";

    2718. 

  2718.     }

    2719. 

  2719.     else{

    2720. 

  2720.         $SQLStmt.=" usr_id = NULL,";

    2721. 

  2721.     }

    2722. 

  2722.     if (!strcasecmp($atl_valide,"t")){

    2723. 

  2723.         $SQLStmt.=" atl_valide = 't'";

    2724. 

  2724.     }

    2725. 

  2725.     else{

    2726. 

  2726.         $SQLStmt.=" atl_valide = 'f'";

    2727. 

  2727.     }

    2728. 

  2728.     $SQLStmt.=" WHERE atl_id = ".$id;

    2729. 

  2729.     return $SQLStmt;

    2730. 

  2730. }

    2731. 

  2731. 

    2732. 

  2732. ///////////////////////////////////////////////////////////////////////////////////////

    2733. 

  2733. // Retourne la requete SQL necessaire pour faire un UPDATE

    2734. 

  2734. ///////////////////////////////////////////////////////////////////////////////////////

    2735. 

  2735. function getSQLStmtUpdCedule($id, $ced_cedule, $gab_id, $ced_paramValeur, $ced_intervalle, $ced_dateNext, $ced_valide){

    2736. 

  2736.     $SQLStmt="UPDATE ceduleur SET";

    2737. 

  2737.     $SQLStmt.=" ced_cedule = '".fixPGQuote($ced_cedule)."',";

    2738. 

  2738.     if (is_numeric($gab_id)){

    2739. 

  2739.         $SQLStmt.=" gab_id = ". $gab_id.",";

    2740. 

  2740.     }

    2741. 

  2741.     else{

    2742. 

  2742.         $SQLStmt.=" gab_id = NULL,";

    2743. 

  2743.     }

    2744. 

  2744.     $SQLStmt.=" ced_paramValeur = '".fixPGQuote($ced_paramValeur)."',";

    2745. 

  2745.     if (is_numeric($ced_intervalle)){

    2746. 

  2746.         $SQLStmt.=" ced_intervalle = ". $ced_intervalle.",";

    2747. 

  2747.     }

    2748. 

  2748.     else{

    2749. 

  2749.         $SQLStmt.=" ced_intervalle = NULL,";

    2750. 

  2750.     }

    2751. 

  2751.     if (isTimeStamp($ced_dateNext)){

    2752. 

  2752.         $SQLStmt.=" ced_dateNext = '".fixPGQuote($ced_dateNext)."',";

    2753. 

  2753.     }

    2754. 

  2754.     else{

    2755. 

  2755.         $SQLStmt.=" ced_dateNext = NULL,";

    2756. 

  2756.     }

    2757. 

  2757.     if (!strcasecmp($ced_valide,"t")){

    2758. 

  2758.         $SQLStmt.=" ced_valide = 't'";

    2759. 

  2759.     }

    2760. 

  2760.     else{

    2761. 

  2761.         $SQLStmt.=" ced_valide = 'f'";

    2762. 

  2762.     }

    2763. 

  2763.     $SQLStmt.=" WHERE ced_id = ".$id;

    2764. 

  2764.     return $SQLStmt;

    2765. 

  2765. }

    2766. 

  2766. 

    2767. 

  2767. ///////////////////////////////////////////////////////////////////////////////////////

    2768. 

  2768. // Retourne la requete SQL necessaire pour faire un UPDATE

    2769. 

  2769. ///////////////////////////////////////////////////////////////////////////////////////

    2770. 

  2770. function getSQLStmtUpdClasse($node, $parent, $label){

    2771. 

  2771.     return getSQLStmtUpdNode($node, 1, $parent, $label);

    2772. 

  2772. }

    2773. 

  2773. 

    2774. 

  2774. ///////////////////////////////////////////////////////////////////////////////////////

    2775. 

  2775. // Retourne la requete SQL necessaire pour faire un UPDATE

    2776. 

  2776. ///////////////////////////////////////////////////////////////////////////////////////

    2777. 

  2777. /* $Author: stacil $ [$Date: 2008/07/03 18:29:46 $]

    2778. 

  2778. function getSQLStmtUpdClientele($cli_id, $cli_clientele, $cli_description){

    2779. 

  2779.     $SQLStmt="UPDATE clientele SET";

    2780. 

  2780.     $SQLStmt.=" cli_clientele = '".fixPGQuote($cli_clientele)."',";

    2781. 

  2781.     $SQLStmt.=" cli_description = '".fixPGQuote($cli_description)."'";

    2782. 

  2782.     $SQLStmt.=" WHERE cli_id = ".$cli_id;

    2783. 

  2783.     return $SQLStmt;

    2784. 

  2784. }

    2785. 

  2785. */

    2786. 

  2786. function getSQLStmtUpdClientele($node, $parent, $label) {

    2787. 

  2787.     return getSQLStmtUpdNode($node, 3, $parent, $label);

    2788. 

  2788. }

    2789. 

  2789. 

    2790. 

  2790. ///////////////////////////////////////////////////////////////////////////////////////

    2791. 

  2791. // Retourne la requete SQL necessaire pour faire un UPDATE

    2792. 

  2792. ///////////////////////////////////////////////////////////////////////////////////////

    2793. 

  2793. function getSQLStmtUpdGabarit($id, $gab_gabarit, $gab_system, $gab_description, $gab_requeteSQL, $gab_param, $gab_TO, $gab_CC, $gab_BCC, $gab_objet, $gab_body, $gab_valide, $gab_multicourriel){

    2794. 

  2794.     $SQLStmt="UPDATE gabarit SET";

    2795. 

  2795.     $SQLStmt.=" gab_gabarit = '".fixPGQuote($gab_gabarit)."',";

    2796. 

  2796.     if (!strcasecmp($gab_system,"t")){

    2797. 

  2797.         $SQLStmt.=" gab_system = 't',";

    2798. 

  2798.     }

    2799. 

  2799.     else{

    2800. 

  2800.         $SQLStmt.=" gab_system = 'f',";

    2801. 

  2801.     }

    2802. 

  2802.     $SQLStmt.=" gab_description = '".fixPGQuote($gab_description)."',";

    2803. 

  2803.     $SQLStmt.=" gab_requeteSQL = '".fixPGQuote($gab_requeteSQL)."',";

    2804. 

  2804.     $SQLStmt.=" gab_param = '".fixPGQuote($gab_param)."',";

    2805. 

  2805.     $SQLStmt.=" gab_TO = '".fixPGQuote($gab_TO)."',";

    2806. 

  2806.     $SQLStmt.=" gab_CC = '".fixPGQuote($gab_CC)."',";

    2807. 

  2807.     $SQLStmt.=" gab_BCC = '".fixPGQuote($gab_BCC)."',";

    2808. 

  2808.     $SQLStmt.=" gab_objet = '".fixPGQuote($gab_objet)."',";

    2809. 

  2809.     $SQLStmt.=" gab_body = '".fixPGQuote($gab_body)."',";

    2810. 

  2810.     if (!strcasecmp($gab_valide,"t")){

    2811. 

  2811.         $SQLStmt.=" gab_valide = 't',";

    2812. 

  2812.     }

    2813. 

  2813.     else{

    2814. 

  2814.         $SQLStmt.=" gab_valide = 'f',";

    2815. 

  2815.     }

    2816. 

  2816.     if (!strcasecmp($gab_multicourriel,"t")){

    2817. 

  2817.         $SQLStmt.=" gab_multicourriel = 't'";

    2818. 

  2818.     }

    2819. 

  2819.     else{

    2820. 

  2820.         $SQLStmt.=" gab_multicourriel = 'f'";

    2821. 

  2821.     }

    2822. 

  2822.     $SQLStmt.=" WHERE gab_id = ".$id;

    2823. 

  2823.     return $SQLStmt;

    2824. 

  2824. }

    2825. 

  2825. 

    2826. 

  2826. ///////////////////////////////////////////////////////////////////////////////////////

    2827. 

  2827. // Retourne la requete SQL necessaire pour faire un UPDATE

    2828. 

  2828. ///////////////////////////////////////////////////////////////////////////////////////

    2829. 

  2829. function getSQLStmtUpdGabaritBalise($gab_id, $gb_id, $gb_balise, $gb_champ, $gb_description){

    2830. 

  2830.     $SQLStmt="UPDATE gabaritBalise SET";

    2831. 

  2831.     $SQLStmt.=" gb_balise = '".fixPGQuote($gb_balise)."',";

    2832. 

  2832.     $SQLStmt.=" gb_champ = '".fixPGQuote($gb_champ)."',";

    2833. 

  2833.     $SQLStmt.=" gb_description = '".fixPGQuote($gb_description)."'";

    2834. 

  2834.     $SQLStmt.=" WHERE gb_id = ".$gb_id;

    2835. 

  2835.     $SQLStmt.=" AND gab_id = ".$gab_id;

    2836. 

  2836.     return $SQLStmt;

    2837. 

  2837. }

    2838. 

  2838. 

    2839. 

  2839. ///////////////////////////////////////////////////////////////////////////////////////

    2840. 

  2840. // Retourne la requete SQL necessaire pour faire un UPDATE

    2841. 

  2841. ///////////////////////////////////////////////////////////////////////////////////////

    2842. 

  2842. function getSQLStmtUpdExpertise($node, $parent, $label){

    2843. 

  2843.     return getSQLStmtUpdNode($node, 2, $parent, $label);

    2844. 

  2844. }

    2845. 

  2845. 

    2846. 

  2846. ///////////////////////////////////////////////////////////////////////////////////////

    2847. 

  2847. // Retourne la requete SQL necessaire pour faire un UPDATE

    2848. 

  2848. ///////////////////////////////////////////////////////////////////////////////////////

    2849. 

  2849. function getSQLStmtUpdInscriptionEtat($usr_id, $ses_id, $oldetat, $ie_id, $is_majpar_usr_id){

    2850. 

  2850.     $SQLStmt="UPDATE inscriptionSession SET";

    2851. 

  2851.     if (is_numeric($ie_id)){

    2852. 

  2852.         $SQLStmt.=" ie_id = ". $ie_id.",";

    2853. 

  2853.     }

    2854. 

  2854.     else{

    2855. 

  2855.         $SQLStmt.=" ie_id = NULL,";

    2856. 

  2856.     }

    2857. 

  2857.     if (is_numeric($is_majpar_usr_id)){

    2858. 

  2858.         $SQLStmt.=" is_majpar_usr_id = ".$is_majpar_usr_id;

    2859. 

  2859.     }

    2860. 

  2860.     else{

    2861. 

  2861.         $SQLStmt.=" is_majpar_usr_id = NULL";

    2862. 

  2862.     }

    2863. 

  2863.     $SQLStmt.=" WHERE usr_id = ".$usr_id;

    2864. 

  2864.     $SQLStmt.=" AND ses_id = ".$ses_id;

    2865. 

  2865.     if (is_numeric($oldetat)){

    2866. 

  2866.         $SQLStmt.=" AND ie_id = ".$oldetat;

    2867. 

  2867.     }

    2868. 

  2868.     return $SQLStmt;

    2869. 

  2869. }

    2870. 

  2870. 

    2871. 

  2871. ///////////////////////////////////////////////////////////////////////////////////////

    2872. 

  2872. // Retourne la requete SQL necessaire pour faire un UPDATE

    2873. 

  2873. ///////////////////////////////////////////////////////////////////////////////////////

    2874. 

  2874. function getSQLStmtUpdLieu($id, $li_lieu, $newno, $li_adresse, $li_trajet, $li_trajetURL, $li_telephone, $li_ldap, $li_valide, $lt_id){

    2875. 

  2875.     $SQLStmt="UPDATE lieu SET";

    2876. 

  2876.     $SQLStmt.=" li_lieu = '".fixPGQuote($li_lieu)."',";

    2877. 

  2877.     if ( $newno!="" ){

    2878. 

  2878.         $SQLStmt.=" li_no = '".$newno."',";

    2879. 

  2879.     }

    2880. 

  2880.     else{

    2881. 

  2881.         $SQLStmt.=" li_no = NULL,";

    2882. 

  2882.     }

    2883. 

  2883.     if ($lt_id == "") $lt_id = "0";			//	ajout 2006/09/18 R.Franche

    2884. 

  2884.     $SQLStmt.=" li_adresse = '".fixPGQuote($li_adresse)."',";

    2885. 

  2885.     $SQLStmt.=" li_trajet = '".fixPGQuote($li_trajet)."',";

    2886. 

  2886.     $SQLStmt.=" li_trajetURL = '".fixPGQuote($li_trajetURL)."',";

    2887. 

  2887.     $SQLStmt.=" li_telephone = '".fixPGQuote($li_telephone)."',";

    2888. 

  2888.     $SQLStmt.=" lt_id = '".fixPGQuote($lt_id)."',";

    2889. 

  2889.     if (!strcasecmp($li_ldap,"t")){

    2890. 

  2890.         $SQLStmt.=" li_ldap = 't',";

    2891. 

  2891.     }

    2892. 

  2892.     else{

    2893. 

  2893.         $SQLStmt.=" li_ldap = 'f',";

    2894. 

  2894.     }

    2895. 

  2895.     if (!strcasecmp($li_valide,"t")){

    2896. 

  2896.         $SQLStmt.=" li_valide = 't'";

    2897. 

  2897.     }

    2898. 

  2898.     else{

    2899. 

  2899.         $SQLStmt.=" li_valide = 'f'";

    2900. 

  2900.     }

    2901. 

  2901.     $SQLStmt.=" WHERE li_id = ".$id;

    2902. 

  2902.     //echo $SQLStmt;

    2903. 

  2903.     return $SQLStmt;

    2904. 

  2904.     

    2905. 

  2905. }

    2906. 

  2906. 

    2907. 

  2907. ///////////////////////////////////////////////////////////////////////////////////////

    2908. 

  2908. // Retourne la requete SQL necessaire pour faire un UPDATE

    2909. 

  2909. ///////////////////////////////////////////////////////////////////////////////////////

    2910. 

  2910. function getSQLStmtUpdNode($node, $tr_id, $parent, $label){

    2911. 

  2911.     $SQLStmt="UPDATE nodes SET";

    2912. 

  2912.     if (is_numeric($tr_id)){

    2913. 

  2913.         $SQLStmt.=" tr_id = ".$tr_id.",";

    2914. 

  2914.     }

    2915. 

  2915.     else{

    2916. 

  2916.         $SQLStmt.=" tr_id = NULL,";

    2917. 

  2917.     }

    2918. 

  2918.     if (is_numeric($parent)){

    2919. 

  2919.         $SQLStmt.=" parent = ".$parent.",";

    2920. 

  2920.     }

    2921. 

  2921.     else{

    2922. 

  2922.         $SQLStmt.=" parent = NULL,";

    2923. 

  2923.     }

    2924. 

  2924.     $SQLStmt.=" etiquette = '".fixPGQuote($label)."'";

    2925. 

  2925.     $SQLStmt.=" WHERE node = ".$node;

    2926. 

  2926.     return ($SQLStmt);

    2927. 

  2927. }

    2928. 

  2928. 

    2929. 

  2929. ///////////////////////////////////////////////////////////////////////////////////////

    2930. 

  2930. // Retourne la requete SQL necessaire pour faire un UPDATE

    2931. 

  2931. ///////////////////////////////////////////////////////////////////////////////////////

    2932. 

  2932. function getSQLStmtUpdProjet($id, $prj_projet, $prj_description, $prj_prefixe, $prj_url, $prj_datedebut, $prj_datefin, $prj_datelimite, $prj_fraisglobaux, $pt_id, $prj_valide){

    2933. 

  2933.     $SQLStmt="UPDATE projet SET";

    2934. 

  2934.     $SQLStmt.=" prj_projet = '".fixPGQuote($prj_projet)."',";

    2935. 

  2935.     $SQLStmt.=" prj_description = '".fixPGQuote($prj_description)."',";

    2936. 

  2936.     $SQLStmt.=" prj_prefixe = '".fixPGQuote($prj_prefixe)."',";

    2937. 

  2937.     $SQLStmt.=" prj_url = '".fixPGQuote($prj_url)."',";

    2938. 

  2938.     if (isDate($prj_datedebut)){

    2939. 

  2939.         $SQLStmt.=" prj_datedebut = '".fixPGQuote($prj_datedebut)."',";

    2940. 

  2940.     }

    2941. 

  2941.     else{

    2942. 

  2942.         $SQLStmt.=" prj_datedebut = NULL,";

    2943. 

  2943.     }

    2944. 

  2944.     if (isDate($prj_datefin)){

    2945. 

  2945.         $SQLStmt.=" prj_datefin = '".fixPGQuote($prj_datefin)."',";

    2946. 

  2946.     }

    2947. 

  2947.     else{

    2948. 

  2948.         $SQLStmt.=" prj_datefin = NULL,";

    2949. 

  2949.     }

    2950. 

  2950.     if (isDate($prj_datelimite)){

    2951. 

  2951.         $SQLStmt.=" prj_datelimite = '".fixPGQuote($prj_datelimite)."',";

    2952. 

  2952.     }

    2953. 

  2953.     else{

    2954. 

  2954.         $SQLStmt.=" prj_datelimite = NULL,";

    2955. 

  2955.     }

    2956. 

  2956.     $SQLStmt.=" prj_fraisglobaux = '".fixPGQuote($prj_fraisglobaux)."',";

    2957. 

  2957.     $SQLStmt.=" pt_id = '".fixPGQuote($pt_id)."',";

    2958. 

  2958.     if (!strcasecmp($prj_valide,"t")){

    2959. 

  2959.         $SQLStmt.=" prj_valide = 't'";

    2960. 

  2960.     }

    2961. 

  2961.     else{

    2962. 

  2962.         $SQLStmt.=" prj_valide = 'f'";

    2963. 

  2963.     }

    2964. 

  2964.     $SQLStmt.=" WHERE prj_id = ".$id;

    2965. 

  2965.     return $SQLStmt;

    2966. 

  2966. }

    2967. 

  2967. 

    2968. 

  2968. ///////////////////////////////////////////////////////////////////////////////////////

    2969. 

  2969. // Retourne la requete SQL necessaire pour faire un UPDATE

    2970. 

  2970. ///////////////////////////////////////////////////////////////////////////////////////

    2971. 

  2971. function getSQLStmtUpdSeance($id, $ses_id, $sea_dateDebut, $sea_dateFin, $sea_duree, $li_id, $sea_lieudetail, $sea_materiel, $sea_materielAnimation, $sea_fraisAnimation, $sea_fraisProduction, $sea_fraisLiberation, $sea_fraisLocation, $sea_fraisAutre, $sea_note, $sea_commentaire, $sea_annule, $sea_annuleRaison, $sea_valide){

    2972. 

  2972.     $SQLStmt="UPDATE seance SET";

    2973. 

  2973.     if (is_numeric($ses_id)){

    2974. 

  2974.         $SQLStmt.=" ses_id = ".$ses_id.",";

    2975. 

  2975.     }

    2976. 

  2976.     else{

    2977. 

  2977.         $SQLStmt.=" ses_id = NULL,";

    2978. 

  2978.     }

    2979. 

  2979.     if (isTimeStamp($sea_dateDebut)){

    2980. 

  2980.         $SQLStmt.=" sea_datedebut = '".fixPGQuote($sea_dateDebut)."',";

    2981. 

  2981.     }

    2982. 

  2982.     else{

    2983. 

  2983.         $SQLStmt.=" sea_datedebut = NULL,";

    2984. 

  2984.     }

    2985. 

  2985.     if (isTimeStamp($sea_dateFin)){

    2986. 

  2986.         $SQLStmt.=" sea_datefin = '".fixPGQuote($sea_dateFin)."',";

    2987. 

  2987.     }

    2988. 

  2988.     else{

    2989. 

  2989.         $SQLStmt.=" sea_datefin = NULL,";

    2990. 

  2990.     }

    2991. 

  2991.     if (is_numeric($sea_duree)){

    2992. 

  2992.         $SQLStmt.=" sea_duree = ".$sea_duree.",";

    2993. 

  2993.     }

    2994. 

  2994.     else{

    2995. 

  2995.         $SQLStmt.=" sea_duree = NULL,";

    2996. 

  2996.     }

    2997. 

  2997.     if (is_numeric($li_id)){

    2998. 

  2998.         $SQLStmt.=" li_id = ".$li_id.",";

    2999. 

  2999.     }

    3000. 

  3000.     else{

    3001. 

  3001.         $SQLStmt.=" li_id = NULL,";

    3002. 

  3002.     }

    3003. 

  3003.     $SQLStmt.=" sea_lieudetail = '".fixPGQuote($sea_lieudetail)."',";

    3004. 

  3004.     $SQLStmt.=" sea_materiel = '".fixPGQuote($sea_materiel)."',";

    3005. 

  3005.     $SQLStmt.=" sea_materielAnimation = '".fixPGQuote($sea_materielAnimation)."',";

    3006. 

  3006.     $SQLStmt.=" sea_fraisAnimation = '".getMoney($sea_fraisAnimation)."',";

    3007. 

  3007.     $SQLStmt.=" sea_fraisProduction = '".getMoney($sea_fraisProduction)."',";

    3008. 

  3008.     $SQLStmt.=" sea_fraisLiberation = '".getMoney($sea_fraisLiberation)."',";

    3009. 

  3009.     $SQLStmt.=" sea_fraisLocation = '".getMoney($sea_fraisLocation)."',";

    3010. 

  3010.     $SQLStmt.=" sea_fraisAutre = '".getMoney($sea_fraisAutre)."',";

    3011. 

  3011.     $SQLStmt.=" sea_note = '".fixPGQuote($sea_note)."',";

    3012. 

  3012.     $SQLStmt.=" sea_commentaire = '".fixPGQuote($sea_commentaire)."',";

    3013. 

  3013.     if (!strcasecmp($sea_annule,"t")){

    3014. 

  3014.         $SQLStmt.=" sea_annule = 't',";

    3015. 

  3015.     }

    3016. 

  3016.     else{

    3017. 

  3017.         $SQLStmt.=" sea_annule = 'f',";

    3018. 

  3018.     }

    3019. 

  3019.     $SQLStmt.=" sea_annuleRaison = '".fixPGQuote($sea_annuleRaison)."',";

    3020. 

  3020.     if (!strcasecmp($sea_valide,"t")){

    3021. 

  3021.         $SQLStmt.=" sea_valide = 't'";

    3022. 

  3022.     }

    3023. 

  3023.     else{

    3024. 

  3024.         $SQLStmt.=" sea_valide = 'f'";

    3025. 

  3025.     }

    3026. 

  3026.     $SQLStmt.=" WHERE sea_id = ".$id;

    3027. 

  3027.     return $SQLStmt;

    3028. 

  3028. }

    3029. 

  3029. 

    3030. 

  3030. ///////////////////////////////////////////////////////////////////////////////////////

    3031. 

  3031. // Retourne la requete SQL necessaire pour faire un UPDATE

    3032. 

  3032. ///////////////////////////////////////////////////////////////////////////////////////

    3033. 

  3033. function getSQLStmtUpdSession($id, $prj_id, $atl_id, $ses_notemini, $ses_note, $ses_commentaire, $ses_dateLimite, $ses_nbMin, $ses_nbMax, $ses_frais, $ses_coutparusager, $ses_regionnal, $ses_annule, $ses_annuleraison, $ses_valide){

    3034. 

  3034.     $SQLStmt="UPDATE session SET";

    3035. 

  3035.     if (is_numeric($prj_id)){

    3036. 

  3036.         $SQLStmt.=" prj_id = ".$prj_id.",";

    3037. 

  3037.     }

    3038. 

  3038.     else{

    3039. 

  3039.         $SQLStmt.=" prj_id = NULL,";

    3040. 

  3040.     }

    3041. 

  3041.     if (is_numeric($atl_id)){

    3042. 

  3042.         $SQLStmt.=" atl_id = ".$atl_id.",";

    3043. 

  3043.     }

    3044. 

  3044.     else{

    3045. 

  3045.         $SQLStmt.=" atl_id = NULL,";

    3046. 

  3046.     }

    3047. 

  3047.     $SQLStmt.=" ses_notemini = '".fixPGQuote($ses_notemini)."',";

    3048. 

  3048.     $SQLStmt.=" ses_note = '".fixPGQuote($ses_note)."',";

    3049. 

  3049.     $SQLStmt.=" ses_commentaire = '".fixPGQuote($ses_commentaire)."',";

    3050. 

  3050.     if (isDate($ses_dateLimite)){

    3051. 

  3051.         $SQLStmt.=" ses_dateLimite = '".fixPGQuote($ses_dateLimite)."',";

    3052. 

  3052.     }

    3053. 

  3053.     else{

    3054. 

  3054.         $SQLStmt.=" ses_dateLimite = NULL,";

    3055. 

  3055.     }

    3056. 

  3056.     if (is_numeric($ses_nbMin)){

    3057. 

  3057.         $SQLStmt.=" ses_nbMin = ".$ses_nbMin.",";

    3058. 

  3058.     }

    3059. 

  3059.     else{

    3060. 

  3060.         $SQLStmt.=" ses_nbMin = 0,";

    3061. 

  3061.     }

    3062. 

  3062.     if (is_numeric($ses_nbMax)){

    3063. 

  3063.         $SQLStmt.=" ses_nbMax = ".$ses_nbMax.",";

    3064. 

  3064.     }

    3065. 

  3065.     else{

    3066. 

  3066.         $SQLStmt.=" ses_nbMax = 0,";

    3067. 

  3067.     }

    3068. 

  3068.     $SQLStmt.=" ses_frais = '".fixPGQuote($ses_frais)."',";

    3069. 

  3069.     if (is_numeric($ses_coutparusager)){

    3070. 

  3070.         $SQLStmt.=" ses_coutParUsager = $ses_coutparusager,";

    3071. 

  3071.     }

    3072. 

  3072.     else{

    3073. 

  3073.         $SQLStmt.=" ses_coutParUsager = NULL,";

    3074. 

  3074.     }

    3075. 

  3075.     if (!strcasecmp($ses_regionnal,"t")){

    3076. 

  3076.         $SQLStmt.=" ses_regionnal = 't',";

    3077. 

  3077.     }

    3078. 

  3078.     else{

    3079. 

  3079.         $SQLStmt.=" ses_regionnal = 'f',";

    3080. 

  3080.     }

    3081. 

  3081.     if (!strcasecmp($ses_annule,"t")){

    3082. 

  3082.         $SQLStmt.=" ses_annule = 't',";

    3083. 

  3083.     }

    3084. 

  3084.     else{

    3085. 

  3085.         $SQLStmt.=" ses_annule = 'f',";

    3086. 

  3086.     }

    3087. 

  3087.     $SQLStmt.=" ses_annuleraison = '".fixPGQuote($ses_annuleraison)."',";

    3088. 

  3088.     if (!strcasecmp($ses_valide,"t")){

    3089. 

  3089.         $SQLStmt.=" ses_valide = 't'";

    3090. 

  3090.     }

    3091. 

  3091.     else{

    3092. 

  3092.         $SQLStmt.=" ses_valide = 'f'";

    3093. 

  3093.     }

    3094. 

  3094.     $SQLStmt.=" WHERE ses_id = ".$id;

    3095. 

  3095.     return $SQLStmt;

    3096. 

  3096. }

    3097. 

  3097. 

    3098. 

  3098. ///////////////////////////////////////////////////////////////////////////////////////

    3099. 

  3099. // Retourne la requete SQL necessaire pour faire un UPDATE

    3100. 

  3100. ///////////////////////////////////////////////////////////////////////////////////////

    3101. 

  3101. function getSQLStmtUpdUsager($id, $usr_nom, $usr_prenom, $usr_email, $usr_url, $usr_telRejoindre, $usr_telTravail, $usr_telMaison, $usr_telCellulaire, $usr_telPage, $usr_telFax, $usr_adresse, $usr_ville, $usr_codePostal, $usr_societe, $usr_fonction, $usr_nas, $usr_dateNaissance, $usr_commentaire, $usr_interet, $usr_LDAP, $li_id, $usr_valide, $usr_locale){

    3102. 

  3102.     $SQLStmt="UPDATE usager SET";

    3103. 

  3103.     $SQLStmt.=" usr_nom = '".fixPGQuote(rtrim($usr_nom))."',";

    3104. 

  3104.     $SQLStmt.=" usr_prenom = '".fixPGQuote(rtrim($usr_prenom))."',";

    3105. 

  3105.     $SQLStmt.=" usr_email = '".fixPGQuote($usr_email)."',";

    3106. 

  3106.     $SQLStmt.=" usr_url = '".fixPGQuote($usr_url)."',";

    3107. 

  3107.     $SQLStmt.=" usr_telRejoindre = '".fixPGQuote($usr_telRejoindre)."',";

    3108. 

  3108.     $SQLStmt.=" usr_telTravail = '".fixPGQuote($usr_telTravail)."',";

    3109. 

  3109.     $SQLStmt.=" usr_telMaison = '".fixPGQuote($usr_telMaison)."',";

    3110. 

  3110.     $SQLStmt.=" usr_telCellulaire = '".fixPGQuote($usr_telCellulaire)."',";

    3111. 

  3111.     $SQLStmt.=" usr_telPage = '".fixPGQuote($usr_telPage)."',";

    3112. 

  3112.     $SQLStmt.=" usr_telFax = '".fixPGQuote($usr_telFax)."',";

    3113. 

  3113.     $SQLStmt.=" usr_adresse = '".fixPGQuote($usr_adresse)."',";

    3114. 

  3114.     $SQLStmt.=" usr_ville = '".fixPGQuote($usr_ville)."',";

    3115. 

  3115.     $SQLStmt.=" usr_codePostal = '".fixPGQuote($usr_codePostal)."',";

    3116. 

  3116.     $SQLStmt.=" usr_societe = '".fixPGQuote($usr_societe)."',";

    3117. 

  3117.     $SQLStmt.=" usr_fonction = '".fixPGQuote($usr_fonction)."',";

    3118. 

  3118. 	$SQLStmt.=" usr_locale = '".fixPGQuote($usr_locale)."',";

    3119. 

  3119.     $SQLStmt.=" usr_nas = '".fixPGQuote($usr_nas)."',";

    3120. 

  3120.     if (isDate($usr_dateNaissance)){

    3121. 

  3121.         $SQLStmt.=" usr_dateNaissance = '".fixPGQuote($usr_dateNaissance)."',";

    3122. 

  3122.     }

    3123. 

  3123.     else{

    3124. 

  3124.         $SQLStmt.=" usr_dateNaissance = NULL,";

    3125. 

  3125.     }

    3126. 

  3126.     $SQLStmt.=" usr_commentaire = '".fixPGQuote($usr_commentaire)."',";

    3127. 

  3127.     $SQLStmt.=" usr_interet = '".fixPGQuote($usr_interet)."',";

    3128. 

  3128.     if (!strcasecmp($usr_LDAP,"t")){

    3129. 

  3129.         $SQLStmt.=" usr_LDAP = 't',";

    3130. 

  3130.     }

    3131. 

  3131.     else{

    3132. 

  3132.         $SQLStmt.=" usr_LDAP = 'f',";

    3133. 

  3133.     }

    3134. 

  3134.     if (is_numeric($li_id)){

    3135. 

  3135.         $SQLStmt.=" li_id = ".fixPGQuote($li_id).",";

    3136. 

  3136.     }

    3137. 

  3137.     else{

    3138. 

  3138.         $SQLStmt.=" li_id = NULL,";

    3139. 

  3139.     }

    3140. 

  3140.     if (!strcasecmp($usr_valide,"t")){

    3141. 

  3141.         $SQLStmt.=" usr_valide = 't'";

    3142. 

  3142.     }

    3143. 

  3143.     else{

    3144. 

  3144.         $SQLStmt.=" usr_valide = 'f'";

    3145. 

  3145.     }

    3146. 

  3146.     $SQLStmt.=" WHERE usr_id = ".$id;

    3147. 

  3147.     return $SQLStmt;

    3148. 

  3148. }

    3149. 

  3149. 

    3150. 

  3150. ///////////////////////////////////////////////////////////////////////////////////////

    3151. 

  3151. // Retourne la requete SQL necessaire pour faire un UPDATE

    3152. 

  3152. ///////////////////////////////////////////////////////////////////////////////////////

    3153. 

  3153. function getSQLStmtUpdUsagerLimited($id, $usr_nom, $usr_prenom, $usr_email, $usr_url, $usr_telRejoindre, $usr_telTravail, $usr_telMaison, $usr_telCellulaire, $usr_telPage, $usr_telFax, $usr_adresse, $usr_ville, $usr_codePostal, $usr_societe, $usr_fonction, $usr_dateNaissance, $usr_locale){

    3154. 

  3154.     $SQLStmt="UPDATE usager SET";

    3155. 

  3155.     $SQLStmt.=" usr_nom = '".fixPGQuote(rtrim($usr_nom))."',";

    3156. 

  3156.     $SQLStmt.=" usr_prenom = '".fixPGQuote(rtrim($usr_prenom))."',";

    3157. 

  3157.     $SQLStmt.=" usr_email = '".fixPGQuote($usr_email)."',";

    3158. 

  3158.     $SQLStmt.=" usr_url = '".fixPGQuote($usr_url)."',";

    3159. 

  3159.     $SQLStmt.=" usr_telRejoindre = '".fixPGQuote($usr_telRejoindre)."',";

    3160. 

  3160.     $SQLStmt.=" usr_telTravail = '".fixPGQuote($usr_telTravail)."',";

    3161. 

  3161.     $SQLStmt.=" usr_telMaison = '".fixPGQuote($usr_telMaison)."',";

    3162. 

  3162.     $SQLStmt.=" usr_telCellulaire = '".fixPGQuote($usr_telCellulaire)."',";

    3163. 

  3163.     $SQLStmt.=" usr_telPage = '".fixPGQuote($usr_telPage)."',";

    3164. 

  3164.     $SQLStmt.=" usr_telFax = '".fixPGQuote($usr_telFax)."',";

    3165. 

  3165.     $SQLStmt.=" usr_adresse = '".fixPGQuote($usr_adresse)."',";

    3166. 

  3166.     $SQLStmt.=" usr_ville = '".fixPGQuote($usr_ville)."',";

    3167. 

  3167.     $SQLStmt.=" usr_codePostal = '".fixPGQuote($usr_codePostal)."',";

    3168. 

  3168.     $SQLStmt.=" usr_societe = '".fixPGQuote($usr_societe)."',";

    3169. 

  3169.     $SQLStmt.=" usr_fonction = '".fixPGQuote($usr_fonction)."',";

    3170. 

  3170. 	$SQLStmt.=" usr_locale = '".fixPGQuote($usr_locale)."',";

    3171. 

  3171.     if (isDate($usr_dateNaissance)){

    3172. 

  3172.         $SQLStmt.=" usr_dateNaissance = '".fixPGQuote($usr_dateNaissance)."'";

    3173. 

  3173.     }

    3174. 

  3174.     else{

    3175. 

  3175.         $SQLStmt.=" usr_dateNaissance = NULL";

    3176. 

  3176.     }

    3177. 

  3177.     $SQLStmt.=" WHERE usr_id = ".$id;

    3178. 

  3178.     return $SQLStmt;

    3179. 

  3179. }

    3180. 

  3180. 

    3181. 

  3181. ///////////////////////////////////////////////////////////////////////////////////////

    3182. 

  3182. // Retourne la requete SQL necessaire pour faire un UPDATE

    3183. 

  3183. ///////////////////////////////////////////////////////////////////////////////////////

    3184. 

  3184. function getSQLStmtUpdUsagerLDAP($id, $usr_nom, $usr_prenom, $usr_email, $usr_telTravail, $usr_fonction, $usr_LDAP, $li_id, $usr_valide){

    3185. 

  3185.     $SQLStmt="UPDATE usager SET";

    3186. 

  3186.     $SQLStmt.=" usr_nom = '".fixPGQuote(rtrim($usr_nom))."',";

    3187. 

  3187.     $SQLStmt.=" usr_prenom = '".fixPGQuote(rtrim($usr_prenom))."',";

    3188. 

  3188.     $SQLStmt.=" usr_email = '".fixPGQuote($usr_email)."',";

    3189. 

  3189.     $SQLStmt.=" usr_telTravail = '".fixPGQuote($usr_telTravail)."',";

    3190. 

  3190.     $SQLStmt.=" usr_fonction = '".fixPGQuote($usr_fonction)."',";

    3191. 

  3191.     if (!strcasecmp($usr_LDAP,"t")){

    3192. 

  3192.         $SQLStmt.=" usr_LDAP = 't',";

    3193. 

  3193.     }

    3194. 

  3194.     else{

    3195. 

  3195.         $SQLStmt.=" usr_LDAP = 'f',";

    3196. 

  3196.     }

    3197. 

  3197.     if (is_numeric($li_id)){

    3198. 

  3198.         $SQLStmt.=" li_id = ".fixPGQuote($li_id).",";

    3199. 

  3199.     }

    3200. 

  3200.     else{

    3201. 

  3201.         $SQLStmt.=" li_id = NULL,";

    3202. 

  3202.     }

    3203. 

  3203.     if (!strcasecmp($usr_valide,"t")){

    3204. 

  3204.         $SQLStmt.=" usr_valide = 't'";

    3205. 

  3205.     }

    3206. 

  3206.     else{

    3207. 

  3207.         $SQLStmt.=" usr_valide = 'f'";

    3208. 

  3208.     }

    3209. 

  3209.     $SQLStmt.=" WHERE usr_id = ".$id;

    3210. 

  3210.     return $SQLStmt;

    3211. 

  3211. }

    3212. 

  3212. 

    3213. 

  3213. ///////////////////////////////////////////////////////////////////////////////////////

    3214. 

  3214. // Retourne la requete SQL necessaire pour faire un UPDATE

    3215. 

  3215. ///////////////////////////////////////////////////////////////////////////////////////

    3216. 

  3216. function getSQLStmtUpdUsagerLogged($usr_id, $usr_enLigne){

    3217. 

  3217.     $SQLStmt="UPDATE usager SET";

    3218. 

  3218.     if (!strcasecmp($usr_enLigne,"t")){

    3219. 

  3219.         $SQLStmt.=" usr_enLigne = 't',";

    3220. 

  3220.         $SQLStmt.=" usr_dernierAcces = NOW()";

    3221. 

  3221.     }

    3222. 

  3222.     else{

    3223. 

  3223.         $SQLStmt.=" usr_enLigne = 'f'";

    3224. 

  3224.     }

    3225. 

  3225.     $SQLStmt.=" WHERE usr_id = " . $usr_id;

    3226. 

  3226.     return $SQLStmt;

    3227. 

  3227. }

    3228. 

  3228. 

    3229. 

  3229. ///////////////////////////////////////////////////////////////////////////////////////

    3230. 

  3230. // Retourne la requete SQL necessaire pour faire un UPDATE

    3231. 

  3231. ///////////////////////////////////////////////////////////////////////////////////////

    3232. 

  3232. function getSQLStmtUpdUsagerPassword($id, $usr_psw){

    3233. 

  3233.     $SQLStmt="UPDATE usager SET";

    3234. 

  3234.     $SQLStmt.=" usr_psw = '".fixPGQuote($usr_psw)."'";

    3235. 

  3235.     $SQLStmt.=" WHERE usr_id = ".$id;

    3236. 

  3236.     return $SQLStmt;

    3237. 

  3237. }

    3238. 

  3238. 

    3239. 

  3239. ///////////////////////////////////////////////////////////////////////////////////////

    3240. 

  3240. // Retourne la requete SQL necessaire pour faire un SELECT

    3241. 

  3241. ///////////////////////////////////////////////////////////////////////////////////////

    3242. 

  3242. function getSQLStmtReqActivite($act_id){

    3243. 

  3243.     $SQLStmt="SELECT act_activite, act_description, act_lieu, TO_CHAR(activite.act_datedebut, 'YYYY-MM-DD HH24:MI:SS') AS act_datedebut, TO_CHAR(activite.act_datefin, 'YYYY-MM-DD HH24:MI:SS') AS act_datefin, act_frais, act_annule, act_annuleraison, projet.prj_id, projet.prj_projet, projet.prj_valide, act_valide, TO_CHAR(activite.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(activite.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    3244. 

  3244.     $SQLStmt.=" FROM activite, projet";

    3245. 

  3245.     $SQLStmt.=" WHERE activite.prj_id = projet.prj_id";

    3246. 

  3246.     $SQLStmt.=" AND act_id=".$act_id;

    3247. 

  3247.     return $SQLStmt;

    3248. 

  3248. }

    3249. 

  3249. 

    3250. 

  3250. ///////////////////////////////////////////////////////////////////////////////////////

    3251. 

  3251. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    3252. 

  3252. ///////////////////////////////////////////////////////////////////////////////////////

    3253. 

  3253. function getSQLStmtReqActiviteLAST(){

    3254. 

  3254.     $SQLStmt="SELECT MAX(act_id) FROM activite";

    3255. 

  3255.     return $SQLStmt;

    3256. 

  3256. }

    3257. 

  3257. 

    3258. 

  3258. ///////////////////////////////////////////////////////////////////////////////////////

    3259. 

  3259. // Retourne la requete SQL necessaire pour faire un SELECT

    3260. 

  3260. ///////////////////////////////////////////////////////////////////////////////////////

    3261. 

  3261. function getSQLStmtReqActivites($prj_id, $indx){

    3262. 

  3262.     $SQLStmt="SELECT act_id, act_activite, act_lieu, TO_CHAR(activite.act_datedebut, 'YYYY-MM-DD HH24:MI:SS'), TO_CHAR(activite.act_datefin, 'YYYY-MM-DD HH24:MI:SS') AS act_datefin, act_annule, act_annuleraison, projet.prj_id, projet.prj_projet, projet.prj_valide, act_valide";

    3263. 

  3263.     $SQLStmt.=" FROM activite, projet";

    3264. 

  3264.     $SQLStmt.=" WHERE activite.prj_id = projet.prj_id";

    3265. 

  3265.     if (is_numeric($prj_id)){

    3266. 

  3266.         $SQLStmt.=" AND activite.prj_id=".$prj_id;

    3267. 

  3267.     }

    3268. 

  3268.     if ($indx!=""){

    3269. 

  3269.         if ($indx=="datea"){

    3270. 

  3270.             $SQLStmt.=" ORDER BY act_dateDebut ASC, act_dateFin ASC";

    3271. 

  3271.         }

    3272. 

  3272.         elseif ($indx=="dated"){

    3273. 

  3273.             $SQLStmt.=" ORDER BY act_dateDebut DESC, act_dateFin DESC";

    3274. 

  3274.         }

    3275. 

  3275.     }

    3276. 

  3276.     return $SQLStmt;

    3277. 

  3277. }

    3278. 

  3278. 

    3279. 

  3279. ///////////////////////////////////////////////////////////////////////////////////////

    3280. 

  3280. // Retourne la requete SQL necessaire pour faire un SELECT

    3281. 

  3281. ///////////////////////////////////////////////////////////////////////////////////////

    3282. 

  3282. function getSQLStmtReqAtelier($atl_id){

    3283. 

  3283.     $SQLStmt="SELECT atl_atelier, atl_description, atl_url, atl_prealable, atl_condition, atl_calendrier, atl_fraistypique, atl_note, atl_commentaire, atl_alacartedisponible, usager.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, usager.usr_telRejoindre, atl_valide, TO_CHAR(atelier.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(atelier.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    3284. 

  3284.     $SQLStmt.=" FROM atelier LEFT JOIN usager ON atelier.usr_id = usager.usr_id";

    3285. 

  3285.     $SQLStmt.=" WHERE atl_id=".$atl_id;

    3286. 

  3286.     return ($SQLStmt);

    3287. 

  3287. }

    3288. 

  3288. 

    3289. 

  3289. ///////////////////////////////////////////////////////////////////////////////////////

    3290. 

  3290. // Retourne la requete SQL necessaire pour faire un SELECT

    3291. 

  3291. ///////////////////////////////////////////////////////////////////////////////////////

    3292. 

  3292. function getSQLStmtReqAtelierClasses($atl_id){

    3293. 

  3293.     $SQLStmt="SELECT classe.cla_id, classe.cla_Complete";

    3294. 

  3294.     $SQLStmt.=" FROM atelier_classe, classe";

    3295. 

  3295.     $SQLStmt.=" WHERE atelier_classe.cla_id=classe.cla_id";

    3296. 

  3296.     $SQLStmt.=" AND atelier_classe.atl_id = " . $atl_id;

    3297. 

  3297.     return ($SQLStmt);

    3298. 

  3298. }

    3299. 

  3299. 

    3300. 

  3300. ///////////////////////////////////////////////////////////////////////////////////////

    3301. 

  3301. // Retourne la requete SQL necessaire pour faire un SELECT

    3302. 

  3302. ///////////////////////////////////////////////////////////////////////////////////////

    3303. 

  3303. function getSQLStmtReqAtelierClienteles($atl_id){

    3304. 

  3304.     $SQLStmt="SELECT clientele.cli_id, clientele.cli_clientele, clientele.cli_complete";

    3305. 

  3305.     $SQLStmt.=" FROM atelier_clientele, clientele";

    3306. 

  3306.     $SQLStmt.=" WHERE atelier_clientele.cli_id=clientele.cli_id";

    3307. 

  3307.     $SQLStmt.=" AND atelier_clientele.atl_id = " . $atl_id;

    3308. 

  3308.     return ($SQLStmt);

    3309. 

  3309. }

    3310. 

  3310. 

    3311. 

  3311. ///////////////////////////////////////////////////////////////////////////////////////

    3312. 

  3312. // Retourne la requete SQL necessaire pour faire un SELECT

    3313. 

  3313. ///////////////////////////////////////////////////////////////////////////////////////

    3314. 

  3314. function getSQLStmtReqAtelierExpertises($atl_id){

    3315. 

  3315.     $SQLStmt="SELECT expertise.exp_id, expertise.exp_Complete";

    3316. 

  3316.     $SQLStmt.=" FROM atelier_expertise, expertise";

    3317. 

  3317.     $SQLStmt.=" WHERE atelier_expertise.exp_id=expertise.exp_id";

    3318. 

  3318.     $SQLStmt.=" AND atelier_expertise.atl_id = " . $atl_id;

    3319. 

  3319.     return ($SQLStmt);

    3320. 

  3320. }

    3321. 

  3321. 

    3322. 

  3322. ///////////////////////////////////////////////////////////////////////////////////////

    3323. 

  3323. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    3324. 

  3324. ///////////////////////////////////////////////////////////////////////////////////////

    3325. 

  3325. function getSQLStmtReqAtelierLAST(){

    3326. 

  3326.     $SQLStmt="SELECT MAX(atl_id) FROM atelier";

    3327. 

  3327.     return $SQLStmt;

    3328. 

  3328. } 

    3329. 

  3329. 

    3330. 

  3330. ///////////////////////////////////////////////////////////////////////////////////////

    3331. 

  3331. // Retourne la requete SQL necessaire pour faire un SELECT

    3332. 

  3332. ///////////////////////////////////////////////////////////////////////////////////////

    3333. 

  3333. function getSQLStmtReqAtelierProjets($atl_id){

    3334. 

  3334.     $SQLStmt="SELECT projet.prj_id, projet.prj_projet";

    3335. 

  3335.     $SQLStmt.=" FROM projet, projet_atelier";

    3336. 

  3336.     $SQLStmt.=" WHERE projet.prj_id = projet_atelier.prj_id";

    3337. 

  3337.     $SQLStmt.=" AND projet_atelier.atl_id = ".$atl_id;

    3338. 

  3338.     $SQLStmt.=" ORDER BY projet.prj_projet";

    3339. 

  3339.     return($SQLStmt);

    3340. 

  3340. }

    3341. 

  3341. 

    3342. 

  3342. function getSQLStmtReqAtelierProjetsAdminProjet($atl_id, $usrid){

    3343. 

  3343.     $subsql = "SELECT prj_id FROM projetAdmin WHERE usr_id = $usrid";

    3344. 

  3344. 

    3345. 

  3345.     $SQLStmt="SELECT projet.prj_id, projet.prj_projet";

    3346. 

  3346.     $SQLStmt.=" FROM projet, projet_atelier";

    3347. 

  3347.     $SQLStmt.=" WHERE projet.prj_id = projet_atelier.prj_id";

    3348. 

  3348.     $SQLStmt.=" AND projet_atelier.atl_id = ".$atl_id;

    3349. 

  3349.     $SQLStmt.=" AND projet.prj_id IN ($subsql)";

    3350. 

  3350.     $SQLStmt.=" ORDER BY projet.prj_projet";

    3351. 

  3351. 

    3352. 

  3352.     return($SQLStmt);

    3353. 

  3353. }

    3354. 

  3354. 

    3355. 

  3355. ///////////////////////////////////////////////////////////////////////////////////////

    3356. 

  3356. // Retourne la requete SQL necessaire pour faire un SELECT

    3357. 

  3357. ///////////////////////////////////////////////////////////////////////////////////////

    3358. 

  3358. function getSQLStmtReqAteliers($mot, $motlnk, $prj_id, $cla_id, $exp_id, $cli_id, $alacarte, $valide, $indx){

    3359. 

  3359.     $SQLStmt="SELECT atelier.atl_id, atl_atelier, atl_description, atl_alacartedisponible, atl_valide, get_projetListe_for_atelier(atelier.atl_id,' + ') as projetListe, COUNT(session.ses_id) as nbSession, SUM(get_nbInscriptionSession(session.ses_id)) as nbInscription";

    3360. 

  3360.     $SQLStmt.=" FROM atelier LEFT JOIN session ON atelier.atl_id = session.atl_id";

    3361. 

  3361.     $SQLStmt.=" WHERE atelier.atl_id = atelier.atl_id";

    3362. 

  3362.     if ($mot!=""){

    3363. 

  3363.         if ($motlnk!="and" && $motlnk!="or"){

    3364. 

  3364.             $motlnk="and"; //valeur par defaut : securite

    3365. 

  3365.         }

    3366. 

  3366.         $arrMot=getArrayFromStringMot($mot);

    3367. 

  3367.         $SQLStmt.=" AND (";

    3368. 

  3368.         for ($i=0; $i<count($arrMot); $i++){

    3369. 

  3369. 			$SQLStmt .= " ( ";

    3370. 

  3370. 			$SQLStmt .= accentInsensitiveLike("atl_atelier", $arrMot[$i]);

    3371. 

  3371. 			$SQLStmt .= " OR " . accentInsensitiveLike("atl_description", $arrMot[$i]);

    3372. 

  3372. 			$SQLStmt .= " ) ";

    3373. 

  3373.             if ($i<count($arrMot)-1){

    3374. 

  3374.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    3375. 

  3375.             }

    3376. 

  3376.         }

    3377. 

  3377.         $SQLStmt.=")";

    3378. 

  3378.     }

    3379. 

  3379.     if (is_numeric($prj_id)){

    3380. 

  3380.         $SQLStmt.=" AND atelier.atl_id IN (";

    3381. 

  3381.             $SQLStmt.=" SELECT atl_id";

    3382. 

  3382.             $SQLStmt.=" FROM projet_atelier";

    3383. 

  3383.             $SQLStmt.=" WHERE prj_id=".$prj_id;

    3384. 

  3384.         $SQLStmt.=")";

    3385. 

  3385.     }

    3386. 

  3386.         if (is_numeric($cla_id)){

    3387. 

  3387.         $SQLStmt.=" AND atelier.atl_id IN (";

    3388. 

  3388.             $SQLStmt.=" SELECT atl_id";

    3389. 

  3389.             $SQLStmt.=" FROM atelier_classe";

    3390. 

  3390.             $SQLStmt.=" WHERE cla_id=".$cla_id;

    3391. 

  3391.         $SQLStmt.=")";

    3392. 

  3392.     }

    3393. 

  3393.     if (is_numeric($exp_id)){

    3394. 

  3394.         $SQLStmt.=" AND atelier.atl_id IN (";

    3395. 

  3395.             $SQLStmt.=" SELECT atl_id";

    3396. 

  3396.             $SQLStmt.=" FROM atelier_expertise";

    3397. 

  3397.             $SQLStmt.=" WHERE exp_id=".$exp_id;

    3398. 

  3398.         $SQLStmt.=")";

    3399. 

  3399.     }

    3400. 

  3400.     if (is_numeric($cli_id)){

    3401. 

  3401.         $SQLStmt.=" AND atelier.atl_id IN (";

    3402. 

  3402.             $SQLStmt.=" SELECT atl_id";

    3403. 

  3403.             $SQLStmt.=" FROM atelier_clientele";

    3404. 

  3404.             $SQLStmt.=" WHERE cli_id=".$cli_id;

    3405. 

  3405.         $SQLStmt.=")";

    3406. 

  3406.     }

    3407. 

  3407.     if ($alacarte!=""){

    3408. 

  3408.         if (!strcasecmp($alacarte,"t")){

    3409. 

  3409.             $SQLStmt.=" AND atl_alacarteDisponible ='t'";

    3410. 

  3410.         } else {

    3411. 

  3411.             $SQLStmt.=" AND atl_alacarteDisponible ='f'";

    3412. 

  3412.         }

    3413. 

  3413.     }

    3414. 

  3414.     if ($valide!=""){

    3415. 

  3415.         if (!strcasecmp($valide,"t")){

    3416. 

  3416.             $SQLStmt.=" AND atl_valide='t'";

    3417. 

  3417.         } else {

    3418. 

  3418.             $SQLStmt.=" AND atl_valide='f'";

    3419. 

  3419.         }

    3420. 

  3420.     }

    3421. 

  3421.     $SQLStmt.=" GROUP BY atelier.atl_id, atl_atelier, atl_description, atl_alacartedisponible, atl_valide";

    3422. 

  3422.     if ($indx!=""){

    3423. 

  3423.         if ($indx=="ateliera") {

    3424. 

  3424.             $SQLStmt.=" ORDER BY atl_atelier ASC";

    3425. 

  3425.         } else if ($indx=="atelierd") {

    3426. 

  3426.             $SQLStmt.=" ORDER BY atl_atelier DESC";

    3427. 

  3427.         } else if ($indx=="projeta") {

    3428. 

  3428.             $SQLStmt.=" ORDER BY projetListe ASC";

    3429. 

  3429.         } else if ($indx=="projetd") {

    3430. 

  3430.             $SQLStmt.=" ORDER BY projetListe DESC";

    3431. 

  3431.         } else if ($indx=="nbsessiona") {

    3432. 

  3432.             $SQLStmt.=" ORDER BY nbSession ASC";

    3433. 

  3433.         } else if ($indx=="nbsessiond") {

    3434. 

  3434.             $SQLStmt.=" ORDER BY nbSession DESC";

    3435. 

  3435.         } else if ($indx=="nbinscriptiona") {

    3436. 

  3436.             $SQLStmt.=" ORDER BY nbInscription ASC";

    3437. 

  3437.         } else if ($indx=="nbinscriptiond") {

    3438. 

  3438.             $SQLStmt.=" ORDER BY nbInscription DESC";

    3439. 

  3439.         }

    3440. 

  3440.     }

    3441. 

  3441.     return $SQLStmt;

    3442. 

  3442. }

    3443. 

  3443. 

    3444. 

  3444. function getSQLStmtReqAteliersAdminProjet($mot, $motlnk, $prj_id, $cla_id, $exp_id, $cli_id, $alacarte, $valide, $usrid, $indx){

    3445. 

  3445.     $SQLStmt="SELECT atelier.atl_id, atl_atelier, atl_description, atl_alacartedisponible, atl_valide, get_projetListe_for_atelier(atelier.atl_id,' + ') as projetListe, COUNT(session.ses_id) as nbSession, SUM(get_nbInscriptionSession(session.ses_id)) as nbInscription";

    3446. 

  3446.     $SQLStmt.=" FROM atelier LEFT JOIN session ON atelier.atl_id = session.atl_id";

    3447. 

  3447.     $SQLStmt.=" WHERE atelier.atl_id = atelier.atl_id";

    3448. 

  3448.     if ($mot!=""){

    3449. 

  3449.         if ($motlnk!="and" && $motlnk!="or"){

    3450. 

  3450.             $motlnk="and"; //valeur par defaut : securite

    3451. 

  3451.         }

    3452. 

  3452.         $arrMot=getArrayFromStringMot($mot);

    3453. 

  3453.         $SQLStmt.=" AND (";

    3454. 

  3454.         for ($i=0; $i<count($arrMot); $i++){

    3455. 

  3455. 			$SQLStmt .= accentInsensitiveLike("atl_atelier", $arrMot[$i]);

    3456. 

  3456. 			$SQLStmt .= " OR " . accentInsensitiveLike("atl_description", $arrMot[$i]);

    3457. 

  3457.             if ($i<count($arrMot)-1){

    3458. 

  3458.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    3459. 

  3459.             }

    3460. 

  3460.         }

    3461. 

  3461.         $SQLStmt.=")";

    3462. 

  3462.     }

    3463. 

  3463.     if (is_numeric($prj_id)){

    3464. 

  3464.         $SQLStmt.=" AND atelier.atl_id IN (";

    3465. 

  3465.             $SQLStmt.=" SELECT atl_id";

    3466. 

  3466.             $SQLStmt.=" FROM projet_atelier";

    3467. 

  3467.             $SQLStmt.=" WHERE prj_id=".$prj_id;

    3468. 

  3468.         $SQLStmt.=")";

    3469. 

  3469.     }

    3470. 

  3470.         if (is_numeric($cla_id)){

    3471. 

  3471.         $SQLStmt.=" AND atelier.atl_id IN (";

    3472. 

  3472.             $SQLStmt.=" SELECT atl_id";

    3473. 

  3473.             $SQLStmt.=" FROM atelier_classe";

    3474. 

  3474.             $SQLStmt.=" WHERE cla_id=".$cla_id;

    3475. 

  3475.         $SQLStmt.=")";

    3476. 

  3476.     }

    3477. 

  3477.     if (is_numeric($exp_id)){

    3478. 

  3478.         $SQLStmt.=" AND atelier.atl_id IN (";

    3479. 

  3479.             $SQLStmt.=" SELECT atl_id";

    3480. 

  3480.             $SQLStmt.=" FROM atelier_expertise";

    3481. 

  3481.             $SQLStmt.=" WHERE exp_id=".$exp_id;

    3482. 

  3482.         $SQLStmt.=")";

    3483. 

  3483.     }

    3484. 

  3484.     if (is_numeric($cli_id)){

    3485. 

  3485.         $SQLStmt.=" AND atelier.atl_id IN (";

    3486. 

  3486.             $SQLStmt.=" SELECT atl_id";

    3487. 

  3487.             $SQLStmt.=" FROM atelier_clientele";

    3488. 

  3488.             $SQLStmt.=" WHERE cli_id=".$cli_id;

    3489. 

  3489.         $SQLStmt.=")";

    3490. 

  3490.     }

    3491. 

  3491.     if (is_numeric($usrid)){

    3492. 

  3492.         $SQLStmt.=" AND atelier.atl_id IN (";

    3493. 

  3493.             $SQLStmt.=" SELECT atl_id";

    3494. 

  3494.             $SQLStmt.=" FROM projetadmin JOIN projet_atelier USING (prj_id)";

    3495. 

  3495.             $SQLStmt.=" WHERE usr_id = $usrid";

    3496. 

  3496.         $SQLStmt.=")";

    3497. 

  3497.     }

    3498. 

  3498.     if ($alacarte!=""){

    3499. 

  3499.         if (!strcasecmp($alacarte,"t")){

    3500. 

  3500.             $SQLStmt.=" AND atl_alacarteDisponible ='t'";

    3501. 

  3501.         } else {

    3502. 

  3502.             $SQLStmt.=" AND atl_alacarteDisponible ='f'";

    3503. 

  3503.         }

    3504. 

  3504.     }

    3505. 

  3505.     if ($valide!=""){

    3506. 

  3506.         if (!strcasecmp($valide,"t")){

    3507. 

  3507.             $SQLStmt.=" AND atl_valide='t'";

    3508. 

  3508.         } else {

    3509. 

  3509.             $SQLStmt.=" AND atl_valide='f'";

    3510. 

  3510.         }

    3511. 

  3511.     }

    3512. 

  3512.     $SQLStmt.=" GROUP BY atelier.atl_id, atl_atelier, atl_description, atl_alacartedisponible, atl_valide";

    3513. 

  3513.     if ($indx!=""){

    3514. 

  3514.         if ($indx=="ateliera") {

    3515. 

  3515.             $SQLStmt.=" ORDER BY atl_atelier ASC";

    3516. 

  3516.         } else if ($indx=="atelierd") {

    3517. 

  3517.             $SQLStmt.=" ORDER BY atl_atelier DESC";

    3518. 

  3518.         } else if ($indx=="projeta") {

    3519. 

  3519.             $SQLStmt.=" ORDER BY projetListe ASC";

    3520. 

  3520.         } else if ($indx=="projetd") {

    3521. 

  3521.             $SQLStmt.=" ORDER BY projetListe DESC";

    3522. 

  3522.         } else if ($indx=="nbsessiona") {

    3523. 

  3523.             $SQLStmt.=" ORDER BY nbSession ASC";

    3524. 

  3524.         } else if ($indx=="nbsessiond") {

    3525. 

  3525.             $SQLStmt.=" ORDER BY nbSession DESC";

    3526. 

  3526.         } else if ($indx=="nbinscriptiona") {

    3527. 

  3527.             $SQLStmt.=" ORDER BY nbInscription ASC";

    3528. 

  3528.         } else if ($indx=="nbinscriptiond") {

    3529. 

  3529.             $SQLStmt.=" ORDER BY nbInscription DESC";

    3530. 

  3530.         }

    3531. 

  3531.     }

    3532. 

  3532.     return $SQLStmt;

    3533. 

  3533. }

    3534. 

  3534. 

    3535. 

  3535. ///////////////////////////////////////////////////////////////////////////////////////

    3536. 

  3536. // Retourne la requete SQL necessaire pour faire un SELECT

    3537. 

  3537. ///////////////////////////////////////////////////////////////////////////////////////

    3538. 

  3538. function getSQLStmtReqCedule($ced_id){

    3539. 

  3539.     $SQLStmt="SELECT ced_id, ced_cedule, ceduleur.gab_id, gabarit.gab_gabarit, gabarit.gab_param, gabarit.gab_valide, ced_paramValeur, ced_intervalle, TO_CHAR(ceduleur.ced_dateLast, 'YYYY-MM-DD HH24:MI:SS') AS ced_dateLast, TO_CHAR(ceduleur.ced_dateNext, 'YYYY-MM-DD HH24:MI:SS') AS ced_dateNext, ced_valide, TO_CHAR(ceduleur.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(ceduleur.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    3540. 

  3540.     $SQLStmt.=" FROM ceduleur Left Join gabarit On ceduleur.gab_id = gabarit.gab_id";

    3541. 

  3541.     $SQLStmt.=" Where ceduleur.ced_id = ".$ced_id;

    3542. 

  3542.     return $SQLStmt;

    3543. 

  3543. }

    3544. 

  3544. 

    3545. 

  3545. ///////////////////////////////////////////////////////////////////////////////////////

    3546. 

  3546. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    3547. 

  3547. ///////////////////////////////////////////////////////////////////////////////////////

    3548. 

  3548. function getSQLStmtReqCeduleLAST(){

    3549. 

  3549.     $SQLStmt="SELECT MAX(ced_id) FROM ceduleur";

    3550. 

  3550.     return $SQLStmt;

    3551. 

  3551. } 

    3552. 

  3552. 

    3553. 

  3553. ///////////////////////////////////////////////////////////////////////////////////////

    3554. 

  3554. // Retourne la requete SQL necessaire pour faire un SELECT

    3555. 

  3555. ///////////////////////////////////////////////////////////////////////////////////////

    3556. 

  3556. function getSQLStmtReqCedules($mot, $motlnk, $gabarit, $valide, $gab_valide, $indx){

    3557. 

  3557.     $SQLStmt="SELECT ced_id, ced_cedule, ceduleur.gab_id, gabarit.gab_gabarit, gabarit.gab_param, gabarit.gab_valide, ced_paramValeur, ced_intervalle, ced_valide";

    3558. 

  3558.     $SQLStmt.=" FROM ceduleur LEFT JOIN gabarit ON ceduleur.gab_id = gabarit.gab_id WHERE 1=1";

    3559. 

  3559.     if ($mot!=""){

    3560. 

  3560.         if ($motlnk!="and" && $motlnk!="or"){

    3561. 

  3561.             $motlnk="and"; //valeur par defaut : securite

    3562. 

  3562.         }

    3563. 

  3563.         $arrMot=getArrayFromStringMot($mot);

    3564. 

  3564.         $SQLStmt.=" AND (";

    3565. 

  3565.         for ($i=0; $i<count($arrMot); $i++){

    3566. 

  3566.             $SQLStmt.="(ced_cedule ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    3567. 

  3567.             $SQLStmt.=" OR gabarit.gab_gabarit ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    3568. 

  3568.             if ($i<count($arrMot)-1){

    3569. 

  3569.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    3570. 

  3570.             }

    3571. 

  3571.         }

    3572. 

  3572.         $SQLStmt.=")";

    3573. 

  3573.     }

    3574. 

  3574.     if (is_numeric($gabarit)){

    3575. 

  3575.           $SQLStmt.=" AND gabarit.gab_id = ".$gabarit;

    3576. 

  3576.     }

    3577. 

  3577.     if ($valide!=""){

    3578. 

  3578.         if (!strcasecmp($valide,"t")){

    3579. 

  3579.             $SQLStmt.=" AND ced_valide='t'";

    3580. 

  3580.         } else {

    3581. 

  3581.             $SQLStmt.=" AND ced_valide='f'";

    3582. 

  3582.         }

    3583. 

  3583.     }

    3584. 

  3584. 	if ($gab_valide!=""){

    3585. 

  3585.         if (!strcasecmp($gab_valide,"t")){

    3586. 

  3586.             $SQLStmt.=" AND gab_valide='t'";

    3587. 

  3587.         } else {

    3588. 

  3588.             $SQLStmt.=" AND gab_valide='f'";

    3589. 

  3589.         }

    3590. 

  3590.     }

    3591. 

  3591.     if ($indx!=""){

    3592. 

  3592.         if ($indx=="cedulea") {

    3593. 

  3593.             $SQLStmt.=" ORDER BY ced_cedule ASC, gab_gabarit ASC";

    3594. 

  3594.         } else if ($indx=="ceduled") {

    3595. 

  3595.             $SQLStmt.=" ORDER BY ced_cedule DESC, gab_gabarit DESC";

    3596. 

  3596.         } else if ($indx=="gabarita") {

    3597. 

  3597.             $SQLStmt.=" ORDER BY gab_gabarit ASC, ced_cedule ASC";

    3598. 

  3598.         } else if ($indx=="gabaritd") {

    3599. 

  3599.             $SQLStmt.=" ORDER BY gab_gabarit DESC, ced_cedule DESC";

    3600. 

  3600.         } else if ($indx=="intervallea") {

    3601. 

  3601.             $SQLStmt.=" ORDER BY ced_intervalle ASC, ced_cedule ASC";

    3602. 

  3602.         } else if ($indx=="intervalled") {

    3603. 

  3603.             $SQLStmt.=" ORDER BY ced_intervalle DESC, ced_cedule DESC";

    3604. 

  3604.         }

    3605. 

  3605.     }

    3606. 

  3606.     return $SQLStmt;

    3607. 

  3607. }

    3608. 

  3608. 

    3609. 

  3609. ///////////////////////////////////////////////////////////////////////////////////////

    3610. 

  3610. // Retourne la requete SQL necessaire pour faire un SELECT

    3611. 

  3611. ///////////////////////////////////////////////////////////////////////////////////////

    3612. 

  3612. function getSQLStmtReqGabaritBalises($gab_id){

    3613. 

  3613.     $SQLStmt="SELECT gb_id, gb_balise, gb_champ, gb_description";

    3614. 

  3614.     $SQLStmt.=" FROM gabaritBalise";

    3615. 

  3615.     $SQLStmt.=" WHERE gb_id = gb_id";

    3616. 

  3616.     if (is_numeric($gab_id)){

    3617. 

  3617.         $SQLStmt.=" AND gab_id = ".$gab_id;

    3618. 

  3618.     }

    3619. 

  3619.     $SQLStmt.=" ORDER BY gb_balise";

    3620. 

  3620.     return ($SQLStmt);

    3621. 

  3621. }

    3622. 

  3622. 

    3623. 

  3623. ///////////////////////////////////////////////////////////////////////////////////////

    3624. 

  3624. // Retourne la requete SQL necessaire pour faire un SELECT

    3625. 

  3625. ///////////////////////////////////////////////////////////////////////////////////////

    3626. 

  3626. function getSQLStmtReqGabarit($gab_id){

    3627. 

  3627.     $SQLStmt="SELECT gab_id, gab_gabarit, gab_system, gab_description, gab_requeteSQL, gab_param, gab_TO, gab_CC, gab_BCC, gab_objet, gab_body, gab_valide, gab_multicourriel, TO_CHAR(gabarit.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(gabarit.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    3628. 

  3628.     $SQLStmt.=" FROM gabarit";

    3629. 

  3629.     $SQLStmt.=" WHERE gab_id = ".$gab_id;

    3630. 

  3630.     return ($SQLStmt);

    3631. 

  3631. }

    3632. 

  3632. 

    3633. 

  3633. ///////////////////////////////////////////////////////////////////////////////////////

    3634. 

  3634. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    3635. 

  3635. ///////////////////////////////////////////////////////////////////////////////////////

    3636. 

  3636. function getSQLStmtReqGabaritGabaritLAST(){

    3637. 

  3637.     $SQLStmt="SELECT MAX(gab_id) FROM gabarit";

    3638. 

  3638.     return $SQLStmt;

    3639. 

  3639. } 

    3640. 

  3640. 

    3641. 

  3641. ///////////////////////////////////////////////////////////////////////////////////////

    3642. 

  3642. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    3643. 

  3643. ///////////////////////////////////////////////////////////////////////////////////////

    3644. 

  3644. function getSQLStmtReqGabaritLAST(){

    3645. 

  3645.     $SQLStmt="SELECT MAX(gab_id) FROM gabarit";

    3646. 

  3646.     return $SQLStmt;

    3647. 

  3647. } 

    3648. 

  3648. 

    3649. 

  3649. ///////////////////////////////////////////////////////////////////////////////////////

    3650. 

  3650. // Retourne la requete SQL necessaire pour faire un SELECT

    3651. 

  3651. ///////////////////////////////////////////////////////////////////////////////////////

    3652. 

  3652. function getSQLStmtReqGabaritParam($gab_id){

    3653. 

  3653.     $SQLStmt="SELECT gab_id, gab_gabarit, gab_param";

    3654. 

  3654.     $SQLStmt.=" FROM gabarit";

    3655. 

  3655.     $SQLStmt.=" WHERE gab_id = ".$gab_id;

    3656. 

  3656.     return ($SQLStmt);

    3657. 

  3657. }

    3658. 

  3658. 

    3659. 

  3659. ///////////////////////////////////////////////////////////////////////////////////////

    3660. 

  3660. // Retourne la requete SQL necessaire pour faire un SELECT

    3661. 

  3661. ///////////////////////////////////////////////////////////////////////////////////////

    3662. 

  3662. function getSQLStmtReqGabarits($mot, $motlnk, $parent, $system, $valide, $indx){

    3663. 

  3663.     $SQLStmt="SELECT gabarit.gab_id, gab_gabarit, gab_system, gab_valide, COUNT(gabaritBalise.gb_id) AS nbBalise";

    3664. 

  3664.     $SQLStmt.=" FROM gabarit LEFT JOIN gabaritBalise ON gabarit.gab_id = gabaritBalise.gab_id";

    3665. 

  3665.     $SQLStmt.=" WHERE gabarit.gab_id = gabarit.gab_id";

    3666. 

  3666.     if ($mot!=""){

    3667. 

  3667.         if ($motlnk!="and" && $motlnk!="or"){

    3668. 

  3668.             $motlnk="and"; //valeur par defaut : securite

    3669. 

  3669.         }

    3670. 

  3670.         $arrMot=getArrayFromStringMot($mot);

    3671. 

  3671.         $SQLStmt.=" AND (";

    3672. 

  3672.         for ($i=0; $i<count($arrMot); $i++){

    3673. 

  3673.             $SQLStmt.="(gab_gabarit ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    3674. 

  3674.             $SQLStmt.=" OR gab_description ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    3675. 

  3675.             if ($i<count($arrMot)-1){

    3676. 

  3676.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    3677. 

  3677.             }

    3678. 

  3678.         }

    3679. 

  3679.         $SQLStmt.=")";

    3680. 

  3680.     }

    3681. 

  3681.     if ($system!=""){

    3682. 

  3682.         if (!strcasecmp($system,"t")){

    3683. 

  3683.             $SQLStmt.=" AND gab_system='t'";

    3684. 

  3684.         } else {

    3685. 

  3685.             $SQLStmt.=" AND gab_system='f'";

    3686. 

  3686.         }

    3687. 

  3687.     }

    3688. 

  3688.     if ($valide!=""){

    3689. 

  3689.         if (!strcasecmp($valide,"t")){

    3690. 

  3690.             $SQLStmt.=" AND gab_valide='t'";

    3691. 

  3691.         } else {

    3692. 

  3692.             $SQLStmt.=" AND gab_valide='f'";

    3693. 

  3693.         }

    3694. 

  3694.     }

    3695. 

  3695.     $SQLStmt.=" GROUP BY gabarit.gab_id, gab_gabarit, gab_system, gab_valide";

    3696. 

  3696.     if ($indx!=""){

    3697. 

  3697.         if ($indx=="gabarita") {

    3698. 

  3698.             $SQLStmt.=" ORDER BY gab_gabarit ASC";

    3699. 

  3699.         } else if ($indx=="gabaritd") {

    3700. 

  3700.             $SQLStmt.=" ORDER BY gab_gabarit DESC";

    3701. 

  3701.         } else if ($indx=="balisea") {

    3702. 

  3702.             $SQLStmt.=" ORDER BY nbBalise ASC, gab_gabarit ASC";

    3703. 

  3703.         } else if ($indx=="balised") {

    3704. 

  3704.             $SQLStmt.=" ORDER BY nbBalise DESC, gab_gabarit DESC";

    3705. 

  3705.         }

    3706. 

  3706.     }

    3707. 

  3707.     return $SQLStmt;

    3708. 

  3708. }

    3709. 

  3709. 

    3710. 

  3710. ///////////////////////////////////////////////////////////////////////////////////////

    3711. 

  3711. // Retourne la requete SQL necessaire pour faire un SELECT

    3712. 

  3712. ///////////////////////////////////////////////////////////////////////////////////////

    3713. 

  3713. function getSQLStmtReqInscription($usr_id, $ses_id){

    3714. 

  3714. 	return"Select insSes.usr_id, uusager.usr_nom, uusager.usr_prenom, uusager.usr_email, lieu.li_id,

    3715. 

  3715. 				lieu.li_lieu, insSes.ses_id, session.ses_code, session.atl_id, atelier.atl_atelier, session.prj_id, projet.prj_projet,

    3716. 

  3716. 				TO_CHAR( insSes.is_datesoumission, 'YYYY-MM-DD HH24:MI:SS' ) AS is_datesoumission, is_ipsoumission, insSes.ie_id,

    3717. 

  3717. 				insEt.ie_etat, insEt.ie_OK, insSes.is_majpar_usr_id, ausager.usr_nom, ausager.usr_prenom, ausager.usr_email

    3718. 

  3718. 			From inscriptionSession insSes

    3719. 

  3719. 				Left Join usager uusager On insSes.usr_id = uusager.usr_id

    3720. 

  3720. 				Left Join lieu On insSes.lieu_id_ainscription = lieu.li_id

    3721. 

  3721. 				Left Join usager ausager On insSes.is_majpar_usr_id = ausager.usr_id

    3722. 

  3722. 				Left Join inscriptionEtat insEt On insSes.ie_id = insEt.ie_id

    3723. 

  3723. 				Left Join session On insSes.ses_id = session.ses_id

    3724. 

  3724. 				Left Join atelier On session.atl_id = atelier.atl_id

    3725. 

  3725. 				Left Join projet On session.prj_id = projet.prj_id

    3726. 

  3726. 			Where insSes.usr_id = '".$usr_id."' And insSes.ses_id = '".$ses_id."'";

    3727. 

  3727. }

    3728. 

  3728. 

    3729. 

  3729. ///////////////////////////////////////////////////////////////////////////////////////

    3730. 

  3730. // Retourne la requete SQL necessaire pour faire un SELECT

    3731. 

  3731. ///////////////////////////////////////////////////////////////////////////////////////

    3732. 

  3732. function getSQLStmtReqUsagerAdminLieuOK($usr_id, $adminlieu_id){

    3733. 

  3733.     $SQLStmt="SELECT usr_id";

    3734. 

  3734.     $SQLStmt.=" FROM usager";

    3735. 

  3735.     $SQLStmt.=" WHERE usr_id = ".$usr_id;

    3736. 

  3736.     if (is_numeric($adminlieu_id)) {

    3737. 

  3737.         $SQLStmt.=" AND usager.li_id IN (";

    3738. 

  3738.             $SQLStmt.=" SELECT li_id";

    3739. 

  3739.             $SQLStmt.=" FROM lieuadmin";

    3740. 

  3740.             $SQLStmt.=" WHERE usr_id=".$adminlieu_id;

    3741. 

  3741.         $SQLStmt.=")";

    3742. 

  3742.     }

    3743. 

  3743.     return $SQLStmt;

    3744. 

  3744. }

    3745. 

  3745. 

    3746. 

  3746. ///////////////////////////////////////////////////////////////////////////////////////

    3747. 

  3747. // Retourne la requete SQL necessaire pour faire un SELECT

    3748. 

  3748. ///////////////////////////////////////////////////////////////////////////////////////

    3749. 

  3749. function getSQLStmtReqInscriptionsFromSeance($seance){

    3750. 

  3750.     $SQLStmt="SELECT inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom";

    3751. 

  3751.     $SQLStmt.=" FROM inscriptionSession, usager, inscriptionEtat";

    3752. 

  3752.     $SQLStmt.=" WHERE inscriptionSession.usr_id = usager.usr_id";

    3753. 

  3753.     $SQLStmt.=" AND inscriptionSession.ie_id = inscriptionEtat.ie_id";

    3754. 

  3754.     $SQLStmt.=" AND inscriptionEtat.ie_OK = 't'";

    3755. 

  3755.     if (is_numeric($seance)){

    3756. 

  3756.         $SQLStmt.=" AND inscriptionSession.ses_id = (";

    3757. 

  3757.             $SQLStmt.=" SELECT ses_id";

    3758. 

  3758.             $SQLStmt.=" FROM seance";

    3759. 

  3759.             $SQLStmt.=" WHERE sea_id = ".$seance;

    3760. 

  3760.         $SQLStmt.=")";

    3761. 

  3761.     }

    3762. 

  3762.     $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    3763. 

  3763.     return $SQLStmt;

    3764. 

  3764. }

    3765. 

  3765. 

    3766. 

  3766. //Retourne toutes les inscriptions selon les critaires, sauf la valid� qui n'est pas v�rifier.

    3767. 

  3767. function getSQLStmtReqInscriptions($mot, $motlnk, $session, $etat, $projet, $lieu, $arrFicheID, $nbjourstart, $indx){

    3768. 

  3768. 	return getSQLStmtReqInscriptionsFull($mot, $motlnk, $session, $etat, "", $projet, $lieu, $arrFicheID, $nbjourstart, $indx);

    3769. 

  3769. }

    3770. 

  3770. 

    3771. 

  3771. 

    3772. 

  3772. ///////////////////////////////////////////////////////////////////////////////////////

    3773. 

  3773. // Retourne la requete SQL necessaire pour faire un SELECT

    3774. 

  3774. ///////////////////////////////////////////////////////////////////////////////////////

    3775. 

  3775. function getSQLStmtReqInscriptionsFull($mot, $motlnk, $session, $etat, $ie_ok, $projet, $lieu, $arrFicheID, $nbjourstart, $indx){

    3776. 

  3776.     

    3777. 

  3777. 	$SQLStmt="SELECT inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, TO_CHAR(inscriptionSession.is_datesoumission, 'YYYY-MM-DD HH24:MI:SS') AS is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, usager.usr_fonction";

    3778. 

  3778.     $SQLStmt.=" FROM inscriptionSession, usager, lieu, session LEFT JOIN seance USING (ses_id), atelier, inscriptionEtat";

    3779. 

  3779.     $SQLStmt.=" WHERE inscriptionSession.usr_id = usager.usr_id";

    3780. 

  3780.     $SQLStmt.=" AND inscriptionSession.lieu_id_ainscription = lieu.li_id";

    3781. 

  3781.     $SQLStmt.=" AND inscriptionSession.ses_id = session.ses_id";

    3782. 

  3782.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    3783. 

  3783.     $SQLStmt.=" AND inscriptionSession.ie_id = inscriptionEtat.ie_id";

    3784. 

  3784. //	$SQLStmt.=" AND seance.ses_id = session.ses_id";

    3785. 

  3785.     if ($mot!=""){

    3786. 

  3786.         if ($motlnk!="and" && $motlnk!="or"){

    3787. 

  3787.             $motlnk="and"; //valeur par defaut : securite

    3788. 

  3788.         }

    3789. 

  3789.         $arrMot=getArrayFromStringMot($mot);

    3790. 

  3790.         $SQLStmt.=" AND (";

    3791. 

  3791.         for ($i=0; $i<count($arrMot); $i++){

    3792. 

  3792.             $SQLStmt.="(usr_nom ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    3793. 

  3793.             $SQLStmt.=" OR usr_prenom ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    3794. 

  3794.             if ($i<count($arrMot)-1){

    3795. 

  3795.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    3796. 

  3796.             }

    3797. 

  3797.         }

    3798. 

  3798.         $SQLStmt.=")";

    3799. 

  3799.     }

    3800. 

  3800. 	if (is_array($session)){

    3801. 

  3801. 		$SQLStmt.= " AND (inscriptionSession.ses_id=$session[0]";

    3802. 

  3802. 		for( $i=1; $i<count($session); $i++ ) {

    3803. 

  3803.         	$SQLStmt.=" OR inscriptionSession.ses_id=".$session[$i];

    3804. 

  3804. 		}

    3805. 

  3805. 		$SQLStmt.= ")";

    3806. 

  3806.     }

    3807. 

  3807.     if (is_numeric($session)){

    3808. 

  3808.         $SQLStmt.=" AND inscriptionSession.ses_id=".$session;

    3809. 

  3809.     }

    3810. 

  3810.     if (is_numeric($etat)){

    3811. 

  3811.         $SQLStmt.=" AND inscriptionSession.ie_id=".$etat;

    3812. 

  3812.     }

    3813. 

  3813.     if($ie_ok != ""){

    3814. 

  3814. 		if($ie_ok == "null"){

    3815. 

  3815. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok is null)";

    3816. 

  3816. 		} else {

    3817. 

  3817. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok ='$ie_ok')";

    3818. 

  3818. 		}

    3819. 

  3819. 	}

    3820. 

  3820.     if (is_numeric($projet)){

    3821. 

  3821.         $SQLStmt.=" AND session.prj_id=".$projet;

    3822. 

  3822.     }

    3823. 

  3823.     if (is_numeric($lieu)){

    3824. 

  3824.         $SQLStmt.=" AND lieu.li_id=".$lieu;

    3825. 

  3825.     }

    3826. 

  3826.     if (is_array($arrFicheID)){

    3827. 

  3827.         $SQLStmt.=" AND (inscriptionSession.ses_id <> inscriptionSession.ses_id";

    3828. 

  3828.         for ($i=0; $i<count($arrFicheID); $i++){

    3829. 

  3829.             ereg("^([0-9]+)[.]{1}([0-9]+)$",$arrFicheID[$i],$regs);

    3830. 

  3830.             $usr_id=$regs[1];

    3831. 

  3831.             $ses_id=$regs[2];

    3832. 

  3832.             if ((is_numeric($usr_id))&&(is_numeric($ses_id))){

    3833. 

  3833.                 $SQLStmt.=" OR (inscriptionSession.usr_id=".$usr_id;

    3834. 

  3834.                 $SQLStmt.=" AND inscriptionSession.ses_id=".$ses_id.")";

    3835. 

  3835.             }

    3836. 

  3836.         }

    3837. 

  3837.         $SQLStmt.=" )";

    3838. 

  3838.     }

    3839. 

  3839. 	$SQLStmt .= " GROUP BY inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, usager.usr_fonction";

    3840. 

  3840.     if (is_numeric($nbjourstart)){

    3841. 

  3841.         $SQLStmt.=" HAVING min(seance.sea_dateDebut) BETWEEN CURRENT_DATE AND CURRENT_DATE+". $nbjourstart;

    3842. 

  3842.     }

    3843. 

  3843.     if ($indx!=""){

    3844. 

  3844.         if ($indx=="noma"){

    3845. 

  3845.             $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    3846. 

  3846.         } else if ($indx=="nomd") {

    3847. 

  3847.             $SQLStmt.=" ORDER BY usr_nom DESC, usr_prenom DESC";

    3848. 

  3848.         } else if ($indx=="lieua") {

    3849. 

  3849.             $SQLStmt.=" ORDER BY li_lieu ASC";

    3850. 

  3850.         } else if ($indx=="lieud") {

    3851. 

  3851.             $SQLStmt.=" ORDER BY li_lieu DESC";

    3852. 

  3852.         } else if ($indx=="sessiona") {

    3853. 

  3853.             $SQLStmt.=" ORDER BY ses_code ASC";

    3854. 

  3854.         } else if ($indx=="sessiond") {

    3855. 

  3855.             $SQLStmt.=" ORDER BY ses_code DESC";

    3856. 

  3856.         } else if ($indx=="datea") {

    3857. 

  3857.             $SQLStmt.=" ORDER BY is_datesoumission ASC";

    3858. 

  3858.         } else if ($indx=="dated") {

    3859. 

  3859.             $SQLStmt.=" ORDER BY is_datesoumission DESC";

    3860. 

  3860.         } else if ($indx=="etata") {

    3861. 

  3861.             $SQLStmt.=" ORDER BY ie_OK ASC, ie_etat ASC";

    3862. 

  3862.         } else if ($indx=="etatd") {

    3863. 

  3863.             $SQLStmt.=" ORDER BY ie_OK DESC, ie_etat DESC";

    3864. 

  3864.         } else if ($indx=="usrtitrea") {

    3865. 

  3865.             $SQLStmt.=" ORDER BY usager.usr_fonction ASC";

    3866. 

  3866.         } else if ($indx=="usrtitred") {

    3867. 

  3867.             $SQLStmt.=" ORDER BY usager.usr_fonction DESC";

    3868. 

  3868.         }

    3869. 

  3869.     }

    3870. 

  3870.     return $SQLStmt;

    3871. 

  3871. }

    3872. 

  3872. 

    3873. 

  3873. function getSQLStmtReqInscriptionsAdminProjet($mot, $motlnk, $session, $etat, $projet, $lieu, $arrFicheID, $nbjourstart, $usrid, $indx){

    3874. 

  3874. 	return getSQLStmtReqInscriptionsAdminProjetFull( $mot, $motlnk, $session, $etat, "", $projet, $lieu, $arrFicheID, $nbjourstart, $usrid, $indx );

    3875. 

  3875. }

    3876. 

  3876. 

    3877. 

  3877. 

    3878. 

  3878. function getSQLStmtReqInscriptionsAdminProjetFull( $mot, $motlnk, $session, $etat, $ie_ok, $projet, $lieu, $arrFicheID, $nbjourstart, $usrid, $indx ){

    3879. 

  3879.     $SQLStmt="Select inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, TO_CHAR(inscriptionSession.is_datesoumission, 'YYYY-MM-DD HH24:MI:SS') AS is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, usager.usr_fonction";

    3880. 

  3880.     $SQLStmt .= " From inscriptionSession

    3881. 

  3881. 					Left Join usager On inscriptionSession.usr_id = usager.usr_id

    3882. 

  3882. 					Left Join lieu On inscriptionSession.lieu_id_ainscription = lieu.li_id

    3883. 

  3883. 					Left Join session On inscriptionSession.ses_id = session.ses_id

    3884. 

  3884. 					Left Join seance On session.ses_id = seance.ses_id

    3885. 

  3885. 					Left Join atelier On session.atl_id = atelier.atl_id

    3886. 

  3886. 					Left Join inscriptionEtat On inscriptionSession.ie_id = inscriptionEtat.ie_id";

    3887. 

  3887. 

    3888. 

  3888. 	$where = "";

    3889. 

  3889. 	// Recherche le ou les mots demand�s par l'usager

    3890. 

  3890. 	if( $mot != "" ){

    3891. 

  3891. 		if( strtolower( $motlnk ) != "or" ){

    3892. 

  3892. 			$motlnk="and"; //valeur par defaut : securite

    3893. 

  3893. 		}

    3894. 

  3894. 

    3895. 

  3895. 		$arrMot = getArrayFromStringMot($mot);

    3896. 

  3896. 		if( count( $arrMot ) > 0 ){

    3897. 

  3897. 			$where = "(";

    3898. 

  3898. 			for( $i = 0; $i < count( $arrMot ); $i++ ){

    3899. 

  3899. 				$where .= accentInsensitiveLike( "usr_nom", $arrMot[$i] );

    3900. 

  3900. 

    3901. 

  3901. 				if( $i < count( $arrMot ) - 1 ){

    3902. 

  3902. 					$where .= " " . $motlnk . " "; //OR ou AND

    3903. 

  3903. 				}

    3904. 

  3904. 			}

    3905. 

  3905. 			$where .= ") And ";

    3906. 

  3906. 		}

    3907. 

  3907. 	}

    3908. 

  3908. 

    3909. 

  3909. 	// Recherche parmi les sessions re�ues si une liste est fournie

    3910. 

  3910. 	if ( is_array( $session ) && count( $session ) > 0 ){

    3911. 

  3911. 		$where .= "( ";

    3912. 

  3912. 		for( $i = 0; $i < count( $session ); $i++ ){

    3913. 

  3913. 			if( $i <> 0 ){

    3914. 

  3914. 				$where .= "Or ";

    3915. 

  3915. 			}

    3916. 

  3916. 			$where .= "inscriptionSession.ses_id = '" . $session[ $i ] . "' ";

    3917. 

  3917. 		}

    3918. 

  3918. 		$where .= ") And ";

    3919. 

  3919. 	} else if( is_numeric( $session ) ){

    3920. 

  3920. 		$where .= "inscriptionSession.ses_id = '" . $session . "' And ";

    3921. 

  3921. 	}

    3922. 

  3922. 	if( is_numeric( $etat ) ){

    3923. 

  3923. 		$where .= "inscriptionSession.ie_id = '" . $etat . "' And ";

    3924. 

  3924. 	}

    3925. 

  3925.     if($ie_ok != ""){

    3926. 

  3926. 		if($ie_ok == "null"){

    3927. 

  3927. 			$where.="inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok is null) AND ";

    3928. 

  3928. 		} else {

    3929. 

  3929. 			$where.="inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok ='$ie_ok') AND ";

    3930. 

  3930. 		}

    3931. 

  3931. 	}

    3932. 

  3932. 	if( is_numeric( $projet ) ){

    3933. 

  3933. 		$where .= "session.prj_id = '" . $projet . "' And ";

    3934. 

  3934. 	}

    3935. 

  3935. 	if( is_numeric( $lieu ) ){

    3936. 

  3936. 		$where .= "lieu.li_id = '" . $lieu . "' And ";

    3937. 

  3937. 	}

    3938. 

  3938. 	if( is_array( $arrFicheID ) && count( $arrFicheID ) > 0 ){

    3939. 

  3939. 		$where .= " ( ";

    3940. 

  3940. 		for( $i = 0; $i < count( $arrFicheID ); $i++ ){

    3941. 

  3941. 			if( $i <> 0 ){

    3942. 

  3942. 				$where .= "Or ";

    3943. 

  3943. 			}

    3944. 

  3944. 			ereg( "^([0-9]+)[.]{1}([0-9]+)$", $arrFicheID[$i], $regs );

    3945. 

  3945. 			$usr_id = $regs[1];

    3946. 

  3946. 			$ses_id = $regs[2];

    3947. 

  3947. 			if( ( is_numeric( $usr_id ) ) && ( is_numeric( $ses_id ) ) ){

    3948. 

  3948. 				$where .= "( inscriptionSession.usr_id = '" . $usr_id . "' And inscriptionSession.ses_id = '" . $ses_id . "' ) ";

    3949. 

  3949. 			}

    3950. 

  3950. 		}

    3951. 

  3951. 		$where .= " ) And ";

    3952. 

  3952. 	}

    3953. 

  3953. 

    3954. 

  3954. 	// Recherche l'admin-projet

    3955. 

  3955. 	$where .= "session.prj_id IN ( SELECT prj_id FROM projetAdmin WHERE usr_id = '" . $usrid . "' )";

    3956. 

  3956. 

    3957. 

  3957. 	$SQLStmt .= " Where " . $where . " GROUP BY inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, usager.usr_fonction";

    3958. 

  3958. 

    3959. 

  3959. 	if( is_numeric( $nbjourstart ) ){

    3960. 

  3960. 		$SQLStmt .= " HAVING min( seance.sea_dateDebut ) BETWEEN CURRENT_DATE AND CURRENT_DATE + " . $nbjourstart;

    3961. 

  3961. 	}

    3962. 

  3962. 	switch( $indx ){

    3963. 

  3963. 		case "noma" :

    3964. 

  3964. 			$SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    3965. 

  3965. 			break;

    3966. 

  3966. 		case "nomd" :

    3967. 

  3967. 			$SQLStmt.=" ORDER BY usr_nom DESC, usr_prenom DESC";

    3968. 

  3968. 			break;

    3969. 

  3969. 		case "lieua" :

    3970. 

  3970. 			$SQLStmt.=" ORDER BY li_lieu ASC";

    3971. 

  3971. 			break;

    3972. 

  3972. 		case "lieud" :

    3973. 

  3973. 			$SQLStmt.=" ORDER BY li_lieu DESC";

    3974. 

  3974. 			break;

    3975. 

  3975. 		case "sessiona" :

    3976. 

  3976. 			$SQLStmt.=" ORDER BY ses_code ASC";

    3977. 

  3977. 			break;

    3978. 

  3978. 		case "sessiond" :

    3979. 

  3979. 			$SQLStmt.=" ORDER BY ses_code DESC";

    3980. 

  3980. 			break;

    3981. 

  3981. 		case "datea" :

    3982. 

  3982. 			$SQLStmt.=" ORDER BY is_datesoumission ASC";

    3983. 

  3983. 			break;

    3984. 

  3984. 		case "dated" :

    3985. 

  3985. 			$SQLStmt.=" ORDER BY is_datesoumission DESC";

    3986. 

  3986. 			break;

    3987. 

  3987. 		case "etata" :

    3988. 

  3988. 			$SQLStmt.=" ORDER BY ie_OK ASC, ie_etat ASC";

    3989. 

  3989. 			break;

    3990. 

  3990. 		case "etatd" :

    3991. 

  3991. 			$SQLStmt.=" ORDER BY ie_OK DESC, ie_etat DESC";

    3992. 

  3992. 			break;

    3993. 

  3993. 		case "usrtitrea" :

    3994. 

  3994. 			$SQLStmt.=" ORDER BY usager.usr_fonction ASC";

    3995. 

  3995. 			break;

    3996. 

  3996. 		case "usrtitred" :

    3997. 

  3997. 			$SQLStmt.=" ORDER BY usager.usr_fonction DESC";

    3998. 

  3998. 			break;

    3999. 

  3999. 	}

    4000. 

  4000. 	return $SQLStmt;

    4001. 

  4001. }

    4002. 

  4002. 

    4003. 

  4003. ///////////////////////////////////////////////////////////////////////////////////////

    4004. 

  4004. // Retourne la requete SQL necessaire pour faire un SELECT

    4005. 

  4005. ///////////////////////////////////////////////////////////////////////////////////////

    4006. 

  4006. function getSQLStmtReqInscriptionsAnimateur($mot, $motlnk, $session, $etat, $svalide, $projet, $lieu, $arrFicheID, $animID, $nbjourstart, $indx){

    4007. 

  4007.     $SQLStmt="SELECT inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, usager.usr_fonction, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, TO_CHAR(inscriptionSession.is_datesoumission, 'YYYY-MM-DD HH24:MI:SS') AS is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison";

    4008. 

  4008.     $SQLStmt.=" FROM inscriptionSession, usager, lieu, session LEFT JOIN seance USING (ses_id), atelier, inscriptionEtat";

    4009. 

  4009.     $SQLStmt.=" WHERE inscriptionSession.usr_id = usager.usr_id";

    4010. 

  4010.     $SQLStmt.=" AND inscriptionSession.lieu_id_ainscription = lieu.li_id";

    4011. 

  4011.     $SQLStmt.=" AND inscriptionSession.ses_id = session.ses_id";

    4012. 

  4012.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    4013. 

  4013.     $SQLStmt.=" AND inscriptionSession.ie_id = inscriptionEtat.ie_id";

    4014. 

  4014. //	$SQLStmt.=" AND seance.ses_id = session.ses_id";

    4015. 

  4015.     if ($mot!=""){

    4016. 

  4016.         if ($motlnk!="and" && $motlnk!="or"){

    4017. 

  4017.             $motlnk="and"; //valeur par defaut : securite

    4018. 

  4018.         }

    4019. 

  4019.         $arrMot=getArrayFromStringMot($mot);

    4020. 

  4020.         $SQLStmt.=" AND (";

    4021. 

  4021.         for ($i=0; $i<count($arrMot); $i++){

    4022. 

  4022.             $SQLStmt.="(usr_nom ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    4023. 

  4023.             $SQLStmt.=" OR usr_prenom ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    4024. 

  4024.             if ($i<count($arrMot)-1){

    4025. 

  4025.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    4026. 

  4026.             }

    4027. 

  4027.         }

    4028. 

  4028.         $SQLStmt.=")";

    4029. 

  4029.     }

    4030. 

  4030. 	if (is_array($session)){

    4031. 

  4031. 		$SQLStmt.= " AND (inscriptionSession.ses_id=$session[0]";

    4032. 

  4032. 		for( $i=1; $i<count($session); $i++ ) {

    4033. 

  4033.         	$SQLStmt.=" OR inscriptionSession.ses_id=".$session[$i];

    4034. 

  4034. 		}

    4035. 

  4035. 		$SQLStmt.= ")";

    4036. 

  4036.     }

    4037. 

  4037.     if (is_numeric($session)){

    4038. 

  4038.         $SQLStmt.=" AND inscriptionSession.ses_id=".$session;

    4039. 

  4039.     }

    4040. 

  4040.     if (is_numeric($etat)){

    4041. 

  4041.         $SQLStmt.=" AND inscriptionSession.ie_id=".$etat;

    4042. 

  4042.     }

    4043. 

  4043. 	if($svalide != ""){

    4044. 

  4044. 		if($svalide == "null"){

    4045. 

  4045. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok is null)";

    4046. 

  4046. 		} else {

    4047. 

  4047. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok ='$svalide')";

    4048. 

  4048. 		}

    4049. 

  4049. 	}

    4050. 

  4050.     if (is_numeric($projet)){

    4051. 

  4051.         $SQLStmt.=" AND session.prj_id=".$projet;

    4052. 

  4052.     }

    4053. 

  4053.     if (is_numeric($lieu)){

    4054. 

  4054.         $SQLStmt.=" AND lieu.li_id=".$lieu;

    4055. 

  4055.     }

    4056. 

  4056.     if (is_array($arrFicheID)){

    4057. 

  4057.         $SQLStmt.=" AND (inscriptionSession.ses_id <> inscriptionSession.ses_id";

    4058. 

  4058.         for ($i=0; $i<count($arrFicheID); $i++){

    4059. 

  4059.             ereg("^([0-9]+)[.]{1}([0-9]+)$",$arrFicheID[$i],$regs);

    4060. 

  4060.             $usr_id=$regs[1];

    4061. 

  4061.             $ses_id=$regs[2];

    4062. 

  4062.             if ((is_numeric($usr_id))&&(is_numeric($ses_id))){

    4063. 

  4063.                 $SQLStmt.=" OR (inscriptionSession.usr_id=".$usr_id;

    4064. 

  4064.                 $SQLStmt.=" AND inscriptionSession.ses_id=".$ses_id.")";

    4065. 

  4065.             }

    4066. 

  4066.         }

    4067. 

  4067.         $SQLStmt.=" )";

    4068. 

  4068.     }

    4069. 

  4069. 	// specifique pour Animateur

    4070. 

  4070.     if (is_numeric($animID)){

    4071. 

  4071.         $SQLStmt.=" AND inscriptionSession.ses_id IN (";

    4072. 

  4072.             $SQLStmt.=" SELECT ses_id";

    4073. 

  4073.             $SQLStmt.=" FROM animation";

    4074. 

  4074.             $SQLStmt.=" WHERE usr_id=".$animID;

    4075. 

  4075.         $SQLStmt.=")";

    4076. 

  4076.     }

    4077. 

  4077. 	$SQLStmt .= " GROUP BY inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, usager.usr_fonction, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison";

    4078. 

  4078.     if (is_numeric($nbjourstart)){

    4079. 

  4079.         $SQLStmt.=" HAVING min(seance.sea_dateDebut) BETWEEN CURRENT_DATE AND CURRENT_DATE+". $nbjourstart;

    4080. 

  4080.     }

    4081. 

  4081.     if ($indx!=""){

    4082. 

  4082.         if ($indx=="noma"){

    4083. 

  4083.             $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    4084. 

  4084.         } else if ($indx=="nomd") {

    4085. 

  4085.             $SQLStmt.=" ORDER BY usr_nom DESC, usr_prenom DESC";

    4086. 

  4086.         } else if ($indx=="fonctiona") {

    4087. 

  4087.             $SQLStmt.=" ORDER BY usr_fonction ASC";

    4088. 

  4088.         } else if ($indx=="fonctiond") {

    4089. 

  4089.             $SQLStmt.=" ORDER BY usr_fonction DESC";

    4090. 

  4090.         } else if ($indx=="lieua") {

    4091. 

  4091.             $SQLStmt.=" ORDER BY li_lieu ASC";

    4092. 

  4092.         } else if ($indx=="lieud") {

    4093. 

  4093.             $SQLStmt.=" ORDER BY li_lieu DESC";

    4094. 

  4094.         } else if ($indx=="sessiona") {

    4095. 

  4095.             $SQLStmt.=" ORDER BY ses_code ASC";

    4096. 

  4096.         } else if ($indx=="sessiond") {

    4097. 

  4097.             $SQLStmt.=" ORDER BY ses_code DESC";

    4098. 

  4098.         } else if ($indx=="datea") {

    4099. 

  4099.             $SQLStmt.=" ORDER BY is_datesoumission ASC";

    4100. 

  4100.         } else if ($indx=="dated") {

    4101. 

  4101.             $SQLStmt.=" ORDER BY is_datesoumission DESC";

    4102. 

  4102.         } else if ($indx=="etata") {

    4103. 

  4103.             $SQLStmt.=" ORDER BY ie_OK ASC, ie_etat ASC";

    4104. 

  4104.         } else if ($indx=="etatd") {

    4105. 

  4105.             $SQLStmt.=" ORDER BY ie_OK DESC, ie_etat DESC";

    4106. 

  4106.         }

    4107. 

  4107.     }

    4108. 

  4108.     return $SQLStmt;

    4109. 

  4109. }

    4110. 

  4110. 

    4111. 

  4111. ///////////////////////////////////////////////////////////////////////////////////////

    4112. 

  4112. // Retourne la requete SQL necessaire pour faire un SELECT

    4113. 

  4113. ///////////////////////////////////////////////////////////////////////////////////////

    4114. 

  4114. function getSQLStmtReqInscriptionsArraySesBefore($usr_id, $arrnSesID){

    4115. 

  4115.     $SQLStmt="SELECT inscriptionSession.ses_id, inscriptionSession.ie_id, inscriptionEtat.ie_count, inscriptionEtat.ie_OK";

    4116. 

  4116.     $SQLStmt.=" FROM inscriptionSession, inscriptionEtat";

    4117. 

  4117.     $SQLStmt.=" WHERE inscriptionSession.ie_id = inscriptionEtat.ie_id";

    4118. 

  4118.     if (count($arrnSesID)>0){

    4119. 

  4119.         $SQLStmt.=" AND (inscriptionSession.ses_id <> inscriptionSession.ses_id";

    4120. 

  4120.         for ($i=0; $i<count($arrnSesID); $i++){

    4121. 

  4121.             $ses_id = $arrnSesID[$i];

    4122. 

  4122.             if ((is_numeric($usr_id))&&(is_numeric($ses_id))){

    4123. 

  4123.                 $SQLStmt.=" OR (inscriptionSession.usr_id=".$usr_id;

    4124. 

  4124.                 $SQLStmt.=" AND inscriptionSession.ses_id=".$ses_id.")";

    4125. 

  4125.             }

    4126. 

  4126.         }

    4127. 

  4127.         $SQLStmt.=" )";

    4128. 

  4128.     }

    4129. 

  4129.     return $SQLStmt;

    4130. 

  4130. }

    4131. 

  4131. 

    4132. 

  4132. ///////////////////////////////////////////////////////////////////////////////////////

    4133. 

  4133. // Retourne la requete SQL necessaire pour faire un SELECT

    4134. 

  4134. ///////////////////////////////////////////////////////////////////////////////////////

    4135. 

  4135. function getSQLStmtReqInscriptionsArrayUsrBefore($ses_id, $arrnUsrID){

    4136. 

  4136.     $SQLStmt="SELECT inscriptionSession.usr_id, inscriptionSession.ie_id, inscriptionEtat.ie_count";

    4137. 

  4137.     $SQLStmt.=" FROM inscriptionSession, inscriptionEtat";

    4138. 

  4138.     $SQLStmt.=" WHERE inscriptionSession.ie_id = inscriptionEtat.ie_id";

    4139. 

  4139.     if (count($arrnUsrID)>0){

    4140. 

  4140.         $SQLStmt.=" AND (inscriptionSession.ses_id <> inscriptionSession.ses_id";

    4141. 

  4141.         for ($i=0; $i<count($arrnUsrID); $i++){

    4142. 

  4142.             $usr_id = $arrnUsrID[$i];

    4143. 

  4143.             if ((is_numeric($usr_id))&&(is_numeric($ses_id))){

    4144. 

  4144.                 $SQLStmt.=" OR (inscriptionSession.usr_id=".$usr_id;

    4145. 

  4145.                 $SQLStmt.=" AND inscriptionSession.ses_id=".$ses_id.")";

    4146. 

  4146.             }

    4147. 

  4147.         }

    4148. 

  4148.         $SQLStmt.=" )";

    4149. 

  4149.     }

    4150. 

  4150.     return $SQLStmt;

    4151. 

  4151. }

    4152. 

  4152. 

    4153. 

  4153. function getSQLStmtReqInscriptionsLimited($mot, $motlnk, $session, $etat, $projet, $lieu, $arrFicheID, $adminlieu, $nbjourstart, $indx)

    4154. 

  4154. {

    4155. 

  4155. 	return getSQLStmtReqInscriptionsLimitedFull($mot, $motlnk, $session, $etat,"", $projet, $lieu, $arrFicheID, $adminlieu, $nbjourstart, $indx);

    4156. 

  4156. }

    4157. 

  4157. 

    4158. 

  4158. ///////////////////////////////////////////////////////////////////////////////////////

    4159. 

  4159. // Retourne la requete SQL necessaire pour faire un SELECT

    4160. 

  4160. ///////////////////////////////////////////////////////////////////////////////////////

    4161. 

  4161. function getSQLStmtReqInscriptionsLimitedFull($mot, $motlnk, $session, $etat,$ie_ok, $projet, $lieu, $arrFicheID, $adminlieu, $nbjourstart, $indx){

    4162. 

  4162.     $SQLStmt="SELECT inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, TO_CHAR(inscriptionSession.is_datesoumission, 'YYYY-MM-DD HH24:MI:SS') AS is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, prochaineseance(inscriptionSession.ses_id) AS dateSeance, usager.usr_fonction";

    4163. 

  4163.     $SQLStmt.=" FROM inscriptionSession, usager, lieu, session LEFT JOIN seance USING (ses_id), atelier, inscriptionEtat";

    4164. 

  4164.     $SQLStmt.=" WHERE inscriptionSession.usr_id = usager.usr_id";

    4165. 

  4165.     $SQLStmt.=" AND inscriptionSession.lieu_id_ainscription = lieu.li_id";

    4166. 

  4166.     $SQLStmt.=" AND inscriptionSession.ses_id = session.ses_id";

    4167. 

  4167.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    4168. 

  4168.     $SQLStmt.=" AND inscriptionSession.ie_id = inscriptionEtat.ie_id";

    4169. 

  4169. //  $SQLStmt.=" AND seance.ses_id = session.ses_id";

    4170. 

  4170.     if ($mot!=""){

    4171. 

  4171.         if ($motlnk!="and" && $motlnk!="or"){

    4172. 

  4172.             $motlnk="and"; //valeur par defaut : securite

    4173. 

  4173.         }

    4174. 

  4174.         $arrMot=getArrayFromStringMot($mot);

    4175. 

  4175.         $SQLStmt.=" AND (";

    4176. 

  4176.         for ($i=0; $i<count($arrMot); $i++){

    4177. 

  4177.             $SQLStmt.="(usr_nom ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    4178. 

  4178.             $SQLStmt.=" OR usr_prenom ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    4179. 

  4179.             if ($i<count($arrMot)-1){

    4180. 

  4180.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    4181. 

  4181.             }

    4182. 

  4182.         }

    4183. 

  4183.         $SQLStmt.=")";

    4184. 

  4184.     }

    4185. 

  4185. 	if (is_array($session)){

    4186. 

  4186. 		$SQLStmt.= " AND (inscriptionSession.ses_id=$session[0]";

    4187. 

  4187. 		for( $i=1; $i<count($session); $i++ ) {

    4188. 

  4188.         	$SQLStmt.=" OR inscriptionSession.ses_id=".$session[$i];

    4189. 

  4189. 		}

    4190. 

  4190. 		$SQLStmt.= ")";

    4191. 

  4191.     }

    4192. 

  4192.     if (is_numeric($session)){

    4193. 

  4193.         $SQLStmt.=" AND inscriptionSession.ses_id=".$session;

    4194. 

  4194.     }

    4195. 

  4195.     if($ie_ok != "" && $ie_ok != "tout"){

    4196. 

  4196. 		if($ie_ok == "null"){

    4197. 

  4197. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok is null)";

    4198. 

  4198. 		} else {

    4199. 

  4199. 			$SQLStmt.=" AND inscriptionSession.ie_id IN(SELECT ie_id from inscriptionEtat where ie_ok ='$ie_ok')";

    4200. 

  4200. 		}

    4201. 

  4201. 	}

    4202. 

  4202.     if (is_numeric($etat)){

    4203. 

  4203.         $SQLStmt.=" AND inscriptionSession.ie_id=".$etat;

    4204. 

  4204.     }

    4205. 

  4205.     if (is_numeric($projet)){

    4206. 

  4206.         $SQLStmt.=" AND session.prj_id=".$projet;

    4207. 

  4207.     }

    4208. 

  4208.     if (is_numeric($lieu)){

    4209. 

  4209.         $SQLStmt.=" AND lieu.li_id=".$lieu;

    4210. 

  4210.     }

    4211. 

  4211.     if (is_array($arrFicheID)){

    4212. 

  4212.         $SQLStmt.=" AND (inscriptionSession.ses_id <> inscriptionSession.ses_id";

    4213. 

  4213.         for ($i=0; $i<count($arrFicheID); $i++){

    4214. 

  4214.             ereg("^([0-9]+)[.]{1}([0-9]+)$",$arrFicheID[$i],$regs);

    4215. 

  4215.             $usr_id=$regs[1];

    4216. 

  4216.             $ses_id=$regs[2];

    4217. 

  4217.             if ((is_numeric($usr_id))&&(is_numeric($ses_id))){

    4218. 

  4218.                 $SQLStmt.=" OR (inscriptionSession.usr_id=".$usr_id;

    4219. 

  4219.                 $SQLStmt.=" AND inscriptionSession.ses_id=".$ses_id.")";

    4220. 

  4220.             }

    4221. 

  4221.         }

    4222. 

  4222.         $SQLStmt.=" )";

    4223. 

  4223.     }

    4224. 

  4224.     // specifique pour LIMITED

    4225. 

  4225.     if (is_numeric($adminlieu)){

    4226. 

  4226.         $SQLStmt.=" AND usager.li_id IN (";

    4227. 

  4227.             $SQLStmt.=" SELECT li_id";

    4228. 

  4228.             $SQLStmt.=" FROM lieuadmin";

    4229. 

  4229.             $SQLStmt.=" WHERE usr_id=".$adminlieu;

    4230. 

  4230.         $SQLStmt.=")";

    4231. 

  4231.     }

    4232. 

  4232. 	$SQLStmt .= " GROUP BY inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_id, lieu.li_lieu, inscriptionSession.ses_id, session.ses_code, session.atl_id, atl_atelier, is_datesoumission, is_ipsoumission, inscriptionSession.ie_id, inscriptionEtat.ie_etat, inscriptionEtat.ie_count, inscriptionEtat.ie_OK, is_majpar_usr_id, is_etatupdateraison, dateSeance, usager.usr_fonction";

    4233. 

  4233.     if (is_numeric($nbjourstart)){

    4234. 

  4234.         $SQLStmt.=" HAVING min(seance.sea_dateDebut) BETWEEN CURRENT_DATE AND CURRENT_DATE+". $nbjourstart;

    4235. 

  4235.     }

    4236. 

  4236.     if ($indx!=""){

    4237. 

  4237.         if ($indx=="noma"){

    4238. 

  4238.             $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    4239. 

  4239.         } else if ($indx=="nomd") {

    4240. 

  4240.             $SQLStmt.=" ORDER BY usr_nom DESC, usr_prenom DESC";

    4241. 

  4241.         } else if ($indx=="lieua") {

    4242. 

  4242.             $SQLStmt.=" ORDER BY li_lieu ASC";

    4243. 

  4243.         } else if ($indx=="lieud") {

    4244. 

  4244.             $SQLStmt.=" ORDER BY li_lieu DESC";

    4245. 

  4245.         } else if ($indx=="sessiona") {

    4246. 

  4246.             $SQLStmt.=" ORDER BY ses_code ASC";

    4247. 

  4247.         } else if ($indx=="sessiond") {

    4248. 

  4248.             $SQLStmt.=" ORDER BY ses_code DESC";

    4249. 

  4249.         } else if ($indx=="datea") {

    4250. 

  4250.             $SQLStmt.=" ORDER BY dateSeance ASC";

    4251. 

  4251.         } else if ($indx=="dated") {

    4252. 

  4252.             $SQLStmt.=" ORDER BY dateSeance DESC";

    4253. 

  4253.         } else if ($indx=="etata") {

    4254. 

  4254.             $SQLStmt.=" ORDER BY ie_OK ASC, ie_etat ASC";

    4255. 

  4255.         } else if ($indx=="etatd") {

    4256. 

  4256.             $SQLStmt.=" ORDER BY ie_OK DESC, ie_etat DESC";

    4257. 

  4257.         } else if ($indx=="usrtitrea") {

    4258. 

  4258.             $SQLStmt.=" ORDER BY usager.usr_fonction ASC";

    4259. 

  4259.         } else if ($indx=="usrtitred") {

    4260. 

  4260.             $SQLStmt.=" ORDER BY usager.usr_fonction DESC";

    4261. 

  4261.         }

    4262. 

  4262.     }

    4263. 

  4263.     return $SQLStmt;

    4264. 

  4264. }

    4265. 

  4265. ///////////////////////////////////////////////////////////////////////////////////////

    4266. 

  4266. // Retourne la requete SQL necessaire pour faire un SELECT

    4267. 

  4267. ///////////////////////////////////////////////////////////////////////////////////////

    4268. 

  4268. function getSQLStmtReqLieu($li_id){

    4269. 

  4269.     $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_trajetURL, li_telephone, li_ldap, li_valide, TO_CHAR(lieu.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(lieu.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation, lt_id";

    4270. 

  4270.     $SQLStmt.=" FROM lieu";

    4271. 

  4271.     $SQLStmt.=" WHERE li_id = ".$li_id;

    4272. 

  4272.     return ($SQLStmt);

    4273. 

  4273. }

    4274. 

  4274. 

    4275. 

  4275. ///////////////////////////////////////////////////////////////////////////////////////

    4276. 

  4276. // Retourne la requete SQL necessaire pour faire un SELECT

    4277. 

  4277. ///////////////////////////////////////////////////////////////////////////////////////

    4278. 

  4278. function getSQLStmtReqLieuType($lt_id){

    4279. 

  4279.     $SQLStmt="SELECT lt_type FROM lieutype";

    4280. 

  4280.     $SQLStmt.=" WHERE lieu.lt_id =".$lt_id;

    4281. 

  4281.     return ($SQLStmt);

    4282. 

  4282. } 

    4283. 

  4283.  

    4284. 

  4284. 

    4285. 

  4285. ///////////////////////////////////////////////////////////////////////////////////////

    4286. 

  4286. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    4287. 

  4287. ///////////////////////////////////////////////////////////////////////////////////////

    4288. 

  4288. function getSQLStmtReqLieuLAST(){

    4289. 

  4289.     $SQLStmt="SELECT MAX(li_id) FROM lieu";

    4290. 

  4290.     return $SQLStmt;

    4291. 

  4291. }

    4292. 

  4292. 

    4293. 

  4293. ///////////////////////////////////////////////////////////////////////////////////////

    4294. 

  4294. // Retourne la requete SQL necessaire pour faire un SELECT

    4295. 

  4295. ///////////////////////////////////////////////////////////////////////////////////////

    4296. 

  4296. function getSQLStmtReqLieuFromNo($li_no){

    4297. 

  4297.     $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_trajetURL, li_telephone, li_valide, TO_CHAR(lieu.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(lieu.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    4298. 

  4298.     $SQLStmt.=" FROM lieu";

    4299. 

  4299.     $SQLStmt.=" WHERE li_id = li_id";

    4300. 

  4300.     if ($li_no!=""){

    4301. 

  4301.         $SQLStmt.=" AND li_no = '".$li_no."'";

    4302. 

  4302.     }else{

    4303. 

  4303.         $SQLStmt.=" AND li_no IS NULL";

    4304. 

  4304.     }

    4305. 

  4305.     return ($SQLStmt);

    4306. 

  4306. } 

    4307. 

  4307. 

    4308. 

  4308. // 2008/03 rechercher un lieu de la table �lieu� d'apr�s son num�ro OU sa description

    4309. 

  4309. function getSQLStmtReqLieuFromNoOuDescr($li_no, $li_lieu){

    4310. 

  4310.     $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_trajetURL, li_telephone, li_valide, TO_CHAR(lieu.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(lieu.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    4311. 

  4311.     $SQLStmt.=" FROM lieu";

    4312. 

  4312.     $SQLStmt.=" WHERE li_id = li_id";

    4313. 

  4313.     if ($li_no!=""){

    4314. 

  4314.         $SQLStmt.=" AND li_no = '".$li_no."'";

    4315. 

  4315.     }elseif ($li_lieu!=""){

    4316. 

  4316.         $SQLStmt.=" AND li_lieu = '".addslashes($li_lieu)."'";

    4317. 

  4317.     }else{

    4318. 

  4318.         $SQLStmt.=" AND li_no IS NULL";

    4319. 

  4319.     }

    4320. 

  4320.     $SQLStmt.=" LIMIT 1";

    4321. 

  4321.     return ($SQLStmt);

    4322. 

  4322. } 

    4323. 

  4323. 

    4324. 

  4324. ///////////////////////////////////////////////////////////////////////////////////////

    4325. 

  4325. // Retourne la requete SQL necessaire pour faire un SELECT

    4326. 

  4326. ///////////////////////////////////////////////////////////////////////////////////////

    4327. 

  4327. function getSQLStmtReqLieuxInscriptions($adminlieu_id, $valide, $indx){

    4328. 

  4328.     $SQLStmt="SELECT lieu.li_id, li_lieu, li_valide, count(inscriptionSession.ie_id) as nbInscription, (SELECT count(*) FROM inscriptionSession is2, usager u2 WHERE is2.ie_id = 1 AND is2.usr_id = u2.usr_id AND u2.li_id = lieu.li_id) as nbInscriptionApprove";

    4329. 

  4329.     $SQLStmt.=" FROM lieu LEFT JOIN inscriptionSession ON lieu.li_id = inscriptionSession.lieu_id_ainscription LEFT JOIN usager ON usager.usr_id = inscriptionSession.usr_id";

    4330. 

  4330.     $SQLStmt.=" WHERE lieu.li_id = lieu.li_id";

    4331. 

  4331.     if (is_numeric($adminlieu_id)){

    4332. 

  4332.         $SQLStmt.=" AND lieu.li_id IN (";

    4333. 

  4333.             $SQLStmt.=" SELECT li_id";

    4334. 

  4334.             $SQLStmt.=" FROM lieuadmin";

    4335. 

  4335.             $SQLStmt.=" WHERE usr_id=".$adminlieu_id;

    4336. 

  4336.         $SQLStmt.=")";

    4337. 

  4337.     }

    4338. 

  4338.     if ($valide!=""){

    4339. 

  4339.         if (!strcasecmp($valide,"t")){

    4340. 

  4340.             $SQLStmt.=" AND li_valide='t'";

    4341. 

  4341.         }

    4342. 

  4342.         else{

    4343. 

  4343.             $SQLStmt.=" AND li_valide='f'";

    4344. 

  4344.         }

    4345. 

  4345.     }

    4346. 

  4346.     $SQLStmt.=" GROUP BY lieu.li_id, li_lieu, li_valide";

    4347. 

  4347.     if ($indx!=""){

    4348. 

  4348.         if ($indx=="lieua"){

    4349. 

  4349.             $SQLStmt.=" ORDER BY li_lieu ASC";

    4350. 

  4350.         }

    4351. 

  4351.         elseif ($indx=="lieud"){

    4352. 

  4352.             $SQLStmt.=" ORDER BY li_lieu DESC";

    4353. 

  4353.         }

    4354. 

  4354.         elseif ($indx=="adressea"){

    4355. 

  4355.             $SQLStmt.=" ORDER BY li_adresse ASC";

    4356. 

  4356.         }

    4357. 

  4357.         elseif ($indx=="adressed"){

    4358. 

  4358.             $SQLStmt.=" ORDER BY li_adresse DESC";

    4359. 

  4359.         }

    4360. 

  4360.         elseif ($indx=="trajeta"){

    4361. 

  4361.             $SQLStmt.=" ORDER BY li_trajet ASC";

    4362. 

  4362.         }

    4363. 

  4363.         elseif ($indx=="trajetd"){

    4364. 

  4364.             $SQLStmt.=" ORDER BY li_trajet DESC";

    4365. 

  4365.         }

    4366. 

  4366.         else

    4367. 

  4367.         {

    4368. 

  4368.         	$SQLStmt.=" ORDER BY li_lieu ASC";		// ordre alphabetique de nom par defaut

    4369. 

  4369.         }

    4370. 

  4370.     }

    4371. 

  4371.     return $SQLStmt;

    4372. 

  4372. }

    4373. 

  4373. 

    4374. 

  4374. ///////////////////////////////////////////////////////////////////////////////////////

    4375. 

  4375. // Retourne la requete SQL necessaire pour faire un SELECT

    4376. 

  4376. ///////////////////////////////////////////////////////////////////////////////////////

    4377. 

  4377. function getSQLStmtReqLieuAdminlieu( $li_id ){

    4378. 

  4378. 	return "Select la.usr_id, la.la_responsable, u.usr_nom, u.usr_prenom, l.li_no

    4379. 

  4379. 				From lieuAdmin la

    4380. 

  4380. 				Left Join usager u On la.usr_id = u.usr_id

    4381. 

  4381. 				Left Join lieu l On u.li_id = l.li_id

    4382. 

  4382. 				Where la.li_id = '" . $li_id . "'

    4383. 

  4383. 				Order By u.usr_nom, u.usr_prenom";

    4384. 

  4384. }

    4385. 

  4385. 

    4386. 

  4386. ///////////////////////////////////////////////////////////////////////////////////////

    4387. 

  4387. // Retourne la requete SQL necessaire pour faire un SELECT

    4388. 

  4388. ///////////////////////////////////////////////////////////////////////////////////////

    4389. 

  4389. function getSQLStmtReqLieuAdminLieuOK($li_id, $adminlieu_id){

    4390. 

  4390.     $SQLStmt="SELECT li_id";

    4391. 

  4391.     $SQLStmt.=" FROM lieuAdmin";

    4392. 

  4392.     $SQLStmt.=" WHERE li_id = ".$li_id;

    4393. 

  4393.     if (is_numeric($adminlieu_id)){

    4394. 

  4394.         $SQLStmt.=" AND usr_id=".$adminlieu_id;

    4395. 

  4395.     }

    4396. 

  4396.     return $SQLStmt;

    4397. 

  4397. }

    4398. 

  4398. 

    4399. 

  4399. ///////////////////////////////////////////////////////////////////////////////////////

    4400. 

  4400. // Retourne la requete SQL necessaire pour faire un SELECT

    4401. 

  4401. ///////////////////////////////////////////////////////////////////////////////////////

    4402. 

  4402. function getSQLStmtReqLieuTechnicien($li_id){

    4403. 

  4403.     $SQLStmt="SELECT lieuSupport.usr_id, lieuSupport.ls_responsable, usager.usr_nom, usager.usr_prenom";

    4404. 

  4404.     $SQLStmt.=" FROM lieuSupport, usager";

    4405. 

  4405.     $SQLStmt.=" WHERE lieuSupport.usr_id = usager.usr_id";

    4406. 

  4406.     $SQLStmt.=" AND lieuSupport.li_id = ".$li_id;

    4407. 

  4407.     $SQLStmt.=" ORDER BY usager.usr_nom, usager.usr_prenom";

    4408. 

  4408.     return ($SQLStmt);

    4409. 

  4409. }

    4410. 

  4410. 

    4411. 

  4411. ///////////////////////////////////////////////////////////////////////////////////////

    4412. 

  4412. // Retourne la requete SQL necessaire pour faire un SELECT

    4413. 

  4413. ///////////////////////////////////////////////////////////////////////////////////////

    4414. 

  4414. function getSQLStmtReqLieux( $mot, $motlnk, $adminlieu_id, $tech_id, $lieu_type, $valide, $indx ){

    4415. 

  4415. 	$SQLStmt = "Select li_id, li_lieu, li_no, li_adresse, li_trajet, li_valide";

    4416. 

  4416. 	$SQLStmt .= " From lieu";

    4417. 

  4417. 	$SQLStmt .= " Where li_id = li_id";

    4418. 

  4418. 

    4419. 

  4419. 	if( $mot != "" ){

    4420. 

  4420. 		if( $motlnk != strtolower( "or" ) ){

    4421. 

  4421. 			$motlnk = "And"; //valeur par defaut : securite

    4422. 

  4422. 		}

    4423. 

  4423. 

    4424. 

  4424. 		$arrMot = getArrayFromStringMot( $mot );

    4425. 

  4425. 		$SQLStmt .= " And ( ";

    4426. 

  4426. 		for( $i = 0; $i < count( $arrMot ); $i++ ){

    4427. 

  4427. 			$SQLStmt .= "( li_lieu Ilike '%" . fixPGQuote( $arrMot[$i] ) . "%'";

    4428. 

  4428. 			$SQLStmt .= " Or li_adresse Ilike '%" . fixPGQuote( $arrMot[ $i ] ) . "%')";

    4429. 

  4429. 			if( $i < count( $arrMot ) - 1 ){

    4430. 

  4430. 				$SQLStmt .= " " . $motlnk . " "; //OR ou AND

    4431. 

  4431. 			}

    4432. 

  4432. 		}

    4433. 

  4433. 		$SQLStmt .= ")";

    4434. 

  4434. 	}

    4435. 

  4435. 	if( is_numeric( $lieu_type ) ){

    4436. 

  4436. 		$SQLStmt .= ' And lt_id = ' . $lieu_type;

    4437. 

  4437. 	}

    4438. 

  4438. 	

    4439. 

  4439. 	if( is_numeric( $adminlieu_id ) ){

    4440. 

  4440. 		$SQLStmt .= " And li_id In ( Select li_id From lieuadmin Where usr_id = " . $adminlieu_id . " )";

    4441. 

  4441. 	}

    4442. 

  4442. 

    4443. 

  4443. 	if( is_numeric( $tech_id ) ){

    4444. 

  4444. 		$SQLStmt .= " And li_id In ( Select li_id From lieusupport Where usr_id = " . $tech_id . " )";

    4445. 

  4445. 	}

    4446. 

  4446. 

    4447. 

  4447. 	if( $valide != "" ){

    4448. 

  4448. 		if( $valide == "t" ){

    4449. 

  4449. 			$SQLStmt .= " And li_valide = 't'";

    4450. 

  4450. 		} else {

    4451. 

  4451. 			$SQLStmt .= " And li_valide = 'f'";

    4452. 

  4452. 		}

    4453. 

  4453. 	}

    4454. 

  4454. 

    4455. 

  4455. 	switch( $indx ){

    4456. 

  4456. 		case "lieua" :

    4457. 

  4457. 			$SQLStmt .= " Order By li_lieu ASC";

    4458. 

  4458. 			break;

    4459. 

  4459. 		case "lieud" :

    4460. 

  4460. 			$SQLStmt .= " Order By li_lieu DESC";

    4461. 

  4461. 			break;

    4462. 

  4462. 		case "adressea" :

    4463. 

  4463. 			$SQLStmt .= " Order By li_adresse ASC";

    4464. 

  4464. 			break;

    4465. 

  4465. 		case "adressed" :

    4466. 

  4466. 			$SQLStmt .= " Order By li_adresse DESC";

    4467. 

  4467. 			break;

    4468. 

  4468. 		case "trajeta" :

    4469. 

  4469. 			$SQLStmt .= " Order By li_trajet ASC";

    4470. 

  4470. 			break;

    4471. 

  4471. 		case "trajetd" :

    4472. 

  4472. 			$SQLStmt .= " Order By li_trajet DESC";

    4473. 

  4473. 			break;

    4474. 

  4474. 		case "lieunoa" :

    4475. 

  4475. 			$SQLStmt .= " Order By li_no ASC";

    4476. 

  4476. 			break;

    4477. 

  4477. 		case "lieunod" :

    4478. 

  4478. 			$SQLStmt .= " Order By li_no DESC";

    4479. 

  4479. 			break;

    4480. 

  4480. 		default :

    4481. 

  4481. 			// ordre alphabetique de nom par defaut

    4482. 

  4482. 			$SQLStmt .= " Order By li_lieu ASC";

    4483. 

  4483. 			break;

    4484. 

  4484. 	}

    4485. 

  4485. 	return $SQLStmt;

    4486. 

  4486. }

    4487. 

  4487. 

    4488. 

  4488. ///////////////////////////////////////////////////////////////////////////////////////

    4489. 

  4489. // Retourne la requete SQL necessaire pour faire un SELECT

    4490. 

  4490. ///////////////////////////////////////////////////////////////////////////////////////

    4491. 

  4491. function getSQLStmtReqPresences($sea_id){

    4492. 

  4492.     /*$SQLStmt="SELECT presence.usr_id, usr_nom, usr_prenom, pr_presence";

    4493. 

  4493.     $SQLStmt.=" FROM presence, usager";

    4494. 

  4494.     $SQLStmt.=" WHERE presence.usr_id = usager.usr_id";

    4495. 

  4495.     $SQLStmt.=" AND sea_id = ".$sea_id;*/

    4496. 

  4496.     $SQLStmt.="SELECT inscriptionSession.usr_id, usager.usr_nom, usager.usr_prenom, pr_presence";

    4497. 

  4497.     $SQLStmt.=" FROM inscriptionSession, inscriptionEtat, usager LEFT JOIN (";

    4498. 

  4498.         $SQLStmt.= " SELECT presence.usr_id,pr_presence";

    4499. 

  4499.         $SQLStmt.= " FROM presence";

    4500. 

  4500.         if (is_numeric($sea_id)){

    4501. 

  4501.             $SQLStmt.= " WHERE sea_id =".$sea_id;

    4502. 

  4502.         }

    4503. 

  4503.         $SQLStmt.= ") PRES ON usager.usr_id = PRES.usr_id";

    4504. 

  4504.     $SQLStmt.=" WHERE inscriptionSession.usr_id = usager.usr_id";

    4505. 

  4505.     $SQLStmt.=" AND inscriptionSession.ie_id = inscriptionEtat.ie_id";

    4506. 

  4506.     $SQLStmt.=" AND inscriptionEtat.ie_OK = 't'";

    4507. 

  4507.     if (is_numeric($sea_id)){

    4508. 

  4508.         $SQLStmt.=" AND inscriptionSession.ses_id = (";

    4509. 

  4509.             $SQLStmt.=" SELECT ses_id";

    4510. 

  4510.             $SQLStmt.=" FROM seance";

    4511. 

  4511.             $SQLStmt.=" WHERE sea_id = ".$sea_id;

    4512. 

  4512.         $SQLStmt.=")";

    4513. 

  4513.     }

    4514. 

  4514.     $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    4515. 

  4515.     return($SQLStmt);

    4516. 

  4516. }

    4517. 

  4517. 

    4518. 

  4518. ///////////////////////////////////////////////////////////////////////////////////////

    4519. 

  4519. // Retourne la requete SQL necessaire pour faire un SELECT

    4520. 

  4520. ///////////////////////////////////////////////////////////////////////////////////////

    4521. 

  4521. function getSQLStmtReqProjet($prj_id){

    4522. 

  4522.     $SQLStmt="SELECT prj_projet, prj_description, prj_prefixe, prj_url, prj_datedebut, prj_datefin, prj_datelimite, prj_fraisglobaux, projet.pt_id, projetType.pt_type, prj_valide, TO_CHAR(projet.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(projet.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation";

    4523. 

  4523.     $SQLStmt.=" FROM projet, projetType";

    4524. 

  4524.     $SQLStmt.=" WHERE projet.pt_id = projetType.pt_id";

    4525. 

  4525.     $SQLStmt.=" AND prj_id = ".$prj_id;

    4526. 

  4526.     return($SQLStmt);

    4527. 

  4527. }

    4528. 

  4528. 

    4529. 

  4529. function getSQLStmtReqProjetAdminprojet($prj_id){

    4530. 

  4530.     $SQLStmt="SELECT projetAdmin.usr_id, projetAdmin.pa_responsable, usager.usr_nom, usager.usr_prenom";

    4531. 

  4531.     $SQLStmt.=" FROM projetAdmin, usager";

    4532. 

  4532.     $SQLStmt.=" WHERE projetAdmin.usr_id = usager.usr_id";

    4533. 

  4533.     $SQLStmt.=" AND projetAdmin.prj_id = ".$prj_id;

    4534. 

  4534.     $SQLStmt.=" ORDER BY usager.usr_nom, usager.usr_prenom";

    4535. 

  4535.     return ($SQLStmt);

    4536. 

  4536. }

    4537. 

  4537. 

    4538. 

  4538. function getSQLStmtReqAdminProjetSessions( $usrid ) {

    4539. 

  4539.     return "SELECT ses_id FROM projetAdmin JOIN session USING ( prj_id ) WHERE usr_id = '" . $usrid . "'";

    4540. 

  4540. }

    4541. 

  4541. 

    4542. 

  4542. function getSQLStmtReqAdminProjetSeances($usrid)

    4543. 

  4543. {

    4544. 

  4544.     $sql = "SELECT sea_id FROM projetAdmin JOIN session USING (prj_id)";

    4545. 

  4545.     $sql .= " JOIN seance USING (ses_id)";

    4546. 

  4546.     $sql .= " WHERE usr_id = $usrid";

    4547. 

  4547. 

    4548. 

  4548.     return $sql;

    4549. 

  4549. }

    4550. 

  4550. 

    4551. 

  4551. ///////////////////////////////////////////////////////////////////////////////////////

    4552. 

  4552. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    4553. 

  4553. ///////////////////////////////////////////////////////////////////////////////////////

    4554. 

  4554. function getSQLStmtReqProjetLAST(){

    4555. 

  4555.     $SQLStmt="SELECT MAX(prj_id) FROM projet";

    4556. 

  4556.     return $SQLStmt;

    4557. 

  4557. } 

    4558. 

  4558. 

    4559. 

  4559. ///////////////////////////////////////////////////////////////////////////////////////

    4560. 

  4560. // Retourne la requete SQL necessaire pour faire un SELECT

    4561. 

  4561. ///////////////////////////////////////////////////////////////////////////////////////

    4562. 

  4562. function getSQLStmtReqProjets($mot, $motlnk, $type, $dateOK, $valide, $indx){

    4563. 

  4563.     $SQLStmt="SELECT projet.prj_id, prj_projet, prj_datedebut, prj_datefin, prj_datelimite, projet.pt_id, projetType.pt_type, prj_valide, COUNT(session.ses_id) as nbSession, SUM(get_nbInscriptionSession(session.ses_id)) as nbInscription";

    4564. 

  4564.     $SQLStmt.=" FROM projet LEFT JOIN session ON projet.prj_id = session.prj_id, projetType";

    4565. 

  4565.     $SQLStmt.=" WHERE projet.pt_id = projetType.pt_id";

    4566. 

  4566.     if ($mot!=""){

    4567. 

  4567.         if ($motlnk!="and" && $motlnk!="or"){

    4568. 

  4568.             $motlnk="and"; //valeur par defaut : securite

    4569. 

  4569.         }

    4570. 

  4570.         $arrMot=getArrayFromStringMot($mot);

    4571. 

  4571.         $SQLStmt.=" AND (";

    4572. 

  4572.         for ($i=0; $i<count($arrMot); $i++){

    4573. 

  4573.             $SQLStmt.="(prj_projet ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    4574. 

  4574.             $SQLStmt.=" OR pt_type ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    4575. 

  4575.             if ($i<count($arrMot)-1){

    4576. 

  4576.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    4577. 

  4577.             }

    4578. 

  4578.         }

    4579. 

  4579.         $SQLStmt.=")";

    4580. 

  4580.     }

    4581. 

  4581.     if ($dateOK!=""){

    4582. 

  4582.         if (!strcasecmp($dateOK,"t")){

    4583. 

  4583.             $SQLStmt.=" AND (prj_dateFin >= CURRENT_DATE OR prj_dateFin IS NULL)";

    4584. 

  4584.         }

    4585. 

  4585.         else{

    4586. 

  4586.             $SQLStmt.=" AND (prj_dateFin < CURRENT_DATE)";

    4587. 

  4587.         }

    4588. 

  4588.     }

    4589. 

  4589.     if ($valide!=""){

    4590. 

  4590.         if (!strcasecmp($valide,"t")){

    4591. 

  4591.             $SQLStmt.=" AND prj_valide='t'";

    4592. 

  4592.         } else {

    4593. 

  4593.             $SQLStmt.=" AND prj_valide='f'";

    4594. 

  4594.         }

    4595. 

  4595.     }

    4596. 

  4596.     if (is_numeric($type)){

    4597. 

  4597.         $SQLStmt.=" AND projet.pt_id=".$type;

    4598. 

  4598.     }

    4599. 

  4599.     $SQLStmt.=" GROUP BY projet.prj_id, prj_projet, prj_datedebut, prj_datefin, prj_datelimite, projet.pt_id, projetType.pt_type, prj_valide";

    4600. 

  4600.     if ($indx!=""){

    4601. 

  4601.         if ($indx=="projeta"){

    4602. 

  4602.             $SQLStmt.=" ORDER BY prj_projet ASC";

    4603. 

  4603.         } else if ($indx=="projetd") {

    4604. 

  4604.             $SQLStmt.=" ORDER BY prj_projet DESC";

    4605. 

  4605.         } else if ($indx=="typea") {

    4606. 

  4606.             $SQLStmt.=" ORDER BY pt_type ASC";

    4607. 

  4607.         } else if ($indx=="typed") {

    4608. 

  4608.             $SQLStmt.=" ORDER BY pt_type DESC";

    4609. 

  4609.         } else if ($indx=="datea") {

    4610. 

  4610.             $SQLStmt.=" ORDER BY prj_dateDebut ASC, prj_dateFin ASC";

    4611. 

  4611.         } else if ($indx=="dated") {

    4612. 

  4612.             $SQLStmt.=" ORDER BY prj_dateDebut DESC, prj_dateFin DESC";

    4613. 

  4613.         } else if ($indx=="nbsessiona") {

    4614. 

  4614.             $SQLStmt.=" ORDER BY nbSession ASC";

    4615. 

  4615.         } else if ($indx=="nbsessiond") {

    4616. 

  4616.             $SQLStmt.=" ORDER BY nbSession DESC";

    4617. 

  4617.         } else if ($indx=="nbinscriptiona") {

    4618. 

  4618.             $SQLStmt.=" ORDER BY nbInscription ASC";

    4619. 

  4619.         } else if ($indx=="nbinscriptiond") {

    4620. 

  4620.             $SQLStmt.=" ORDER BY nbInscription DESC";

    4621. 

  4621.         }

    4622. 

  4622.     }

    4623. 

  4623.     return $SQLStmt;

    4624. 

  4624. }

    4625. 

  4625. 

    4626. 

  4626. ///////////////////////////////////////////////////////////////////////////////////////

    4627. 

  4627. // Retourne la requete SQL necessaire pour faire un SELECT

    4628. 

  4628. ///////////////////////////////////////////////////////////////////////////////////////

    4629. 

  4629. function getSQLStmtReqProjetsComplets($mot, $motlnk, $type, $dateOK, $valide, $indx){

    4630. 

  4630.     $SQLStmt="SELECT projet.prj_id, prj_projet, prj_description, prj_url, prj_datedebut, prj_datefin, prj_datelimite, projet.pt_id, projetType.pt_type, prj_valide, COUNT(session.ses_id) as nbSession, SUM(get_nbInscriptionSession(session.ses_id)) as nbInscription";

    4631. 

  4631.     $SQLStmt.=" FROM projet LEFT JOIN session ON projet.prj_id = session.prj_id, projetType";

    4632. 

  4632.     $SQLStmt.=" WHERE projet.pt_id = projetType.pt_id";

    4633. 

  4633.     if ($mot!=""){

    4634. 

  4634.         if ($motlnk!="and" && $motlnk!="or"){

    4635. 

  4635.             $motlnk="and"; //valeur par defaut : securite

    4636. 

  4636.         }

    4637. 

  4637.         $arrMot=getArrayFromStringMot($mot);

    4638. 

  4638.         $SQLStmt.=" AND (";

    4639. 

  4639. 		

    4640. 

  4640.         for ($i=0; $i<count($arrMot); $i++){

    4641. 

  4641.             $SQLStmt.="(prj_projet ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    4642. 

  4642.             $SQLStmt.=" OR pt_type ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    4643. 

  4643.             if ($i<count($arrMot)-1){

    4644. 

  4644.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    4645. 

  4645.             }

    4646. 

  4646.         }

    4647. 

  4647.         $SQLStmt.=")";

    4648. 

  4648.     }

    4649. 

  4649.     if ($dateOK!=""){

    4650. 

  4650.         if (!strcasecmp($dateOK,"t")){

    4651. 

  4651.             $SQLStmt.=" AND (prj_dateFin >= CURRENT_DATE OR prj_dateFin IS NULL)";

    4652. 

  4652.         }

    4653. 

  4653.         else{

    4654. 

  4654.             $SQLStmt.=" AND (prj_dateFin < CURRENT_DATE)";

    4655. 

  4655.         }

    4656. 

  4656.     }

    4657. 

  4657.     if ($valide!=""){

    4658. 

  4658.         if (!strcasecmp($valide,"t")){

    4659. 

  4659.             $SQLStmt.=" AND prj_valide='t'";

    4660. 

  4660.         }

    4661. 

  4661.         else{

    4662. 

  4662.             $SQLStmt.=" AND prj_valide='f'";

    4663. 

  4663.         }

    4664. 

  4664.     }

    4665. 

  4665.     if (is_numeric($type)){

    4666. 

  4666.         $SQLStmt.=" AND projet.pt_id=".$type;

    4667. 

  4667.     }

    4668. 

  4668.     $SQLStmt.=" GROUP BY projet.prj_id, prj_projet, prj_description, prj_url, prj_datedebut, prj_datefin, prj_datelimite, projet.pt_id, projetType.pt_type, prj_valide";

    4669. 

  4669.     if ($indx!=""){

    4670. 

  4670.         if ($indx=="projeta"){

    4671. 

  4671.             $SQLStmt.=" ORDER BY prj_projet ASC";

    4672. 

  4672.         }

    4673. 

  4673.         elseif ($indx=="projetd"){

    4674. 

  4674.             $SQLStmt.=" ORDER BY prj_projet DESC";

    4675. 

  4675.         }

    4676. 

  4676.         elseif ($indx=="typea"){

    4677. 

  4677.             $SQLStmt.=" ORDER BY pt_type ASC";

    4678. 

  4678.         }

    4679. 

  4679.         elseif ($indx=="typed"){

    4680. 

  4680.             $SQLStmt.=" ORDER BY pt_type DESC";

    4681. 

  4681.         }

    4682. 

  4682.         elseif ($indx=="datea"){

    4683. 

  4683.             $SQLStmt.=" ORDER BY prj_dateDebut ASC, prj_dateFin ASC";

    4684. 

  4684.         }

    4685. 

  4685.         elseif ($indx=="dated"){

    4686. 

  4686.             $SQLStmt.=" ORDER BY prj_dateDebut DESC, prj_dateFin DESC";

    4687. 

  4687.         }

    4688. 

  4688.         elseif ($indx=="nbsessiona"){

    4689. 

  4689.             $SQLStmt.=" ORDER BY nbSession ASC";

    4690. 

  4690.         }

    4691. 

  4691.         elseif ($indx=="nbsessiond"){

    4692. 

  4692.             $SQLStmt.=" ORDER BY nbSession DESC";

    4693. 

  4693.         }

    4694. 

  4694.         elseif ($indx=="nbinscriptiona"){

    4695. 

  4695.             $SQLStmt.=" ORDER BY nbInscription ASC";

    4696. 

  4696.         }

    4697. 

  4697.         elseif ($indx=="nbinscriptiond"){

    4698. 

  4698.             $SQLStmt.=" ORDER BY nbInscription DESC";

    4699. 

  4699.         }

    4700. 

  4700.     }

    4701. 

  4701.     return $SQLStmt;

    4702. 

  4702. }

    4703. 

  4703. 

    4704. 

  4704. ///////////////////////////////////////////////////////////////////////////////////////

    4705. 

  4705. // Retourne la requete SQL necessaire pour faire un SELECT

    4706. 

  4706. ///////////////////////////////////////////////////////////////////////////////////////

    4707. 

  4707. function getSQLStmtReqSeance($sea_id){

    4708. 

  4708.     $SQLStmt="SELECT get_seanceCode(sea_id), session.ses_id, session.ses_code, session.ses_annule, session.ses_valide, projet.prj_id, projet.prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, TO_CHAR(seance.sea_dateDebut, 'YYYY-MM-DD HH24:MI:SS') AS sea_dateDebut, TO_CHAR(seance.sea_dateFin, 'YYYY-MM-DD HH24:MI:SS') AS sea_dateFin, sea_duree, seance.li_id, li_lieu, sea_lieudetail, sea_materiel, sea_materielanimation, sea_fraisanimation, sea_fraisproduction, sea_fraisliberation, sea_fraislocation, sea_fraisautre, (sea_fraisanimation+sea_fraisproduction+sea_fraisliberation+sea_fraislocation+sea_fraisautre) AS fraisTotal, sea_note, sea_commentaire, sea_annule, sea_annuleraison, sea_valide, TO_CHAR(seance.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(seance.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation, get_nbInscriptionSessionOK(seance.ses_id) AS nbInscription, get_nbPresence(seance.sea_id)";

    4709. 

  4709.     $SQLStmt.=" FROM seance LEFT JOIN lieu ON seance.li_id = lieu.li_id, session, atelier, projet";

    4710. 

  4710.     $SQLStmt.=" WHERE seance.ses_id = session.ses_id";

    4711. 

  4711.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    4712. 

  4712.     $SQLStmt.=" AND session.prj_id = projet.prj_id";

    4713. 

  4713.     $SQLStmt.=" AND seance.sea_id = ".$sea_id;

    4714. 

  4714.     return ($SQLStmt);

    4715. 

  4715. }

    4716. 

  4716. 

    4717. 

  4717. ///////////////////////////////////////////////////////////////////////////////////////

    4718. 

  4718. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    4719. 

  4719. ///////////////////////////////////////////////////////////////////////////////////////

    4720. 

  4720. function getSQLStmtReqSeanceLAST(){

    4721. 

  4721.     $SQLStmt="SELECT MAX(sea_id) FROM seance";

    4722. 

  4722.     return $SQLStmt;

    4723. 

  4723. } 

    4724. 

  4724. 

    4725. 

  4725. ///////////////////////////////////////////////////////////////////////////////////////

    4726. 

  4726. // Retourne la requete SQL necessaire pour faire un SELECT

    4727. 

  4727. ///////////////////////////////////////////////////////////////////////////////////////

    4728. 

  4728. function getSQLStmtReqSeances($prj_id, $atl_id, $ses_id, $sea_annule, $valide, $arrFicheID, $indx, $usr_id = null){

    4729. 

  4729.     $SQLStmt="SELECT seance.sea_id, get_seanceCode(seance.sea_id), session.ses_id, session.ses_code, session.ses_annule, session.ses_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, projet.prj_id, projet.prj_projet, projet.prj_valide, TO_CHAR(seance.sea_dateDebut, 'YYYY-MM-DD HH24:MI:SS') AS sea_dateDebut, TO_CHAR(seance.sea_dateFin, 'YYYY-MM-DD HH24:MI:SS') AS sea_dateFin, sea_duree, seance.li_id, li_lieu, sea_lieudetail, sea_annule, sea_annuleraison, sea_valide";

    4730. 

  4730.     if (is_numeric($usr_id)) {

    4731. 

  4731. 		$SQLStmt.=", pr_presence FROM seance LEFT JOIN presence ON (presence.sea_id = seance.sea_id AND presence.usr_id = $usr_id) LEFT JOIN lieu ON seance.li_id = lieu.li_id";	

    4732. 

  4732. 	} else {

    4733. 

  4733. 		$SQLStmt.=" FROM seance LEFT JOIN lieu ON seance.li_id = lieu.li_id";	

    4734. 

  4734. 	}

    4735. 

  4735. 	$SQLStmt.=" LEFT JOIN session ON seance.ses_id = session.ses_id";

    4736. 

  4736. 	$SQLStmt.=" LEFT JOIN atelier ON session.atl_id = atelier.atl_id";

    4737. 

  4737. 	$SQLStmt.=" LEFT JOIN projet ON session.prj_id = projet.prj_id";

    4738. 

  4738.     $SQLStmt.=" WHERE seance.sea_id = seance.sea_id";

    4739. 

  4739.     if (is_numeric($prj_id)){

    4740. 

  4740.         $SQLStmt.=" AND session.prj_id = ".$prj_id;

    4741. 

  4741.     }

    4742. 

  4742.     if (is_numeric($atl_id)){

    4743. 

  4743.         $SQLStmt.=" AND session.atl_id = ".$atl_id;

    4744. 

  4744.     }

    4745. 

  4745.     if (is_numeric($ses_id)){

    4746. 

  4746.         $SQLStmt.=" AND session.ses_id = ".$ses_id;

    4747. 

  4747.     }

    4748. 

  4748.     if ($sea_annule!=""){

    4749. 

  4749.         if (!strcasecmp($sea_annule,"t")){

    4750. 

  4750.             $SQLStmt.=" AND sea_annule='t'";

    4751. 

  4751.         }

    4752. 

  4752.         else{

    4753. 

  4753.             $SQLStmt.=" AND sea_annule='f'";

    4754. 

  4754.         }

    4755. 

  4755.     }

    4756. 

  4756.     if ($valide!=""){

    4757. 

  4757.         if (!strcasecmp($valide,"t")){

    4758. 

  4758.             $SQLStmt.=" AND prj_valide='t'";

    4759. 

  4759.             $SQLStmt.=" AND atl_valide='t'";

    4760. 

  4760.             $SQLStmt.=" AND ses_valide='t'";

    4761. 

  4761.             $SQLStmt.=" AND sea_valide='t'";

    4762. 

  4762.         }

    4763. 

  4763.         else{

    4764. 

  4764.             $SQLStmt.=" AND prj_valide='f'";

    4765. 

  4765.             $SQLStmt.=" AND atl_valide='f'";

    4766. 

  4766.             $SQLStmt.=" AND ses_valide='f'";

    4767. 

  4767.             $SQLStmt.=" AND sea_valide='f'";

    4768. 

  4768.         }

    4769. 

  4769.     }

    4770. 

  4770.     if( is_array( $arrFicheID ) && count( $arrFicheID ) > 0 ){

    4771. 

  4771.         $SQLStmt.=" AND (seance.sea_id <> seance.sea_id";

    4772. 

  4772.         for ($i=0; $i<count($arrFicheID); $i++){

    4773. 

  4773.             if (is_numeric($arrFicheID[$i])){

    4774. 

  4774.                 $SQLStmt.=" OR seance.sea_id=".$arrFicheID[$i];

    4775. 

  4775.             }

    4776. 

  4776.         }

    4777. 

  4777.         $SQLStmt.=" )";

    4778. 

  4778.     }

    4779. 

  4779.     if ($indx!=""){

    4780. 

  4780.         if ($indx=="datea"){

    4781. 

  4781.             $SQLStmt.=" ORDER BY sea_dateDebut ASC, sea_dateFin ASC";

    4782. 

  4782.         }

    4783. 

  4783.         elseif ($indx=="dated"){

    4784. 

  4784.             $SQLStmt.=" ORDER BY sea_dateDebut DESC, sea_dateFin DESC";

    4785. 

  4785.         }

    4786. 

  4786.     }

    4787. 

  4787.     return ($SQLStmt);

    4788. 

  4788. }

    4789. 

  4789. 

    4790. 

  4790. ///////////////////////////////////////////////////////////////////////////////////////

    4791. 

  4791. // Retourne la requete SQL necessaire pour faire un SELECT

    4792. 

  4792. ///////////////////////////////////////////////////////////////////////////////////////

    4793. 

  4793. function getSQLStmtReqSession($ses_id){

    4794. 

  4794.     $SQLStmt = "SELECT projet.prj_id, projet.prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_no, ses_code, ses_notemini, ses_note, ses_commentaire, ses_datelimite, ses_nbmin, ses_nbmax, ses_frais, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, TO_CHAR(session.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(session.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation, count(seance.ses_id) as nbSeance, get_nbInscriptionSession(session.ses_id) as nbInscription, ses_coutParUsager";

    4795. 

  4795.     $SQLStmt.=" FROM session LEFT JOIN seance ON session.ses_id = seance.ses_id, projet, atelier";

    4796. 

  4796.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    4797. 

  4797.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    4798. 

  4798.     $SQLStmt.=" AND session.ses_id = ".$ses_id;

    4799. 

  4799.     $SQLStmt.=" GROUP BY projet.prj_id, projet.prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_no, ses_code, ses_notemini, ses_note, ses_commentaire, ses_datelimite, ses_nbmin, ses_nbmax, ses_frais, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, session.dateupdate, session.datecreation, nbInscription, ses_coutParUsager";

    4800. 

  4800.     return ($SQLStmt);

    4801. 

  4801. }

    4802. 

  4802. 

    4803. 

  4803. ///////////////////////////////////////////////////////////////////////////////////////

    4804. 

  4804. // Retourne la requete SQL necessaire pour faire un SELECT

    4805. 

  4805. ///////////////////////////////////////////////////////////////////////////////////////

    4806. 

  4806. function getSQLStmtReqSessionAnimateur($ses_id){

    4807. 

  4807. $SQLStmt="SELECT animation.usr_id, animation.an_responsable, usager.usr_nom, usager.usr_prenom, usager.usr_email, lieu.li_no ";

    4808. 

  4808.     $SQLStmt.=" FROM animation, usager, lieu";

    4809. 

  4809.     $SQLStmt.=" WHERE animation.usr_id = usager.usr_id";

    4810. 

  4810.     $SQLStmt.=" AND animation.ses_id = ".$ses_id. "AND usager.li_id = lieu.li_id";  // 2007-03-23 demande #37 ajout du lieu

    4811. 

  4811.     $SQLStmt.=" ORDER BY usager.usr_nom, usager.usr_prenom";

    4812. 

  4812.     return ($SQLStmt);

    4813. 

  4813. }

    4814. 

  4814. 

    4815. 

  4815. ///////////////////////////////////////////////////////////////////////////////////////

    4816. 

  4816. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    4817. 

  4817. ///////////////////////////////////////////////////////////////////////////////////////

    4818. 

  4818. function getSQLStmtReqSessionLAST(){

    4819. 

  4819.     $SQLStmt="SELECT MAX(ses_id) FROM session";

    4820. 

  4820.     return $SQLStmt;

    4821. 

  4821. }

    4822. 

  4822. 

    4823. 

  4823. ///////////////////////////////////////////////////////////////////////////////////////

    4824. 

  4824. // Retourne la requete SQL necessaire pour faire un SELECT

    4825. 

  4825. ///////////////////////////////////////////////////////////////////////////////////////

    4826. 

  4826. function getSQLStmtReqSessions( $mot, $motlnk, $prj_id, $atl_id, $cla_id, $exp_id, $cli_id, $ses_annule, $nbjourstart, $datelimiteOK, $nbinsOK, $valide, $arrFicheID, $indx,$dateDebut = "", $dateFin = "" ){

    4827. 

  4827. 	$SQLStmt = "Select ses.ses_id, pro.prj_id, prj_projet, pro.prj_valide, ate.atl_id,

    4828. 

  4828. 				ate.atl_atelier, ate.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbMin,

    4829. 

  4829. 				ses_nbMax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide,	COUNT( sea.sea_id ) As nbSeance,

    4830. 

  4830. 				get_nbInscriptionSession( ses.ses_id ) As nbInscription, TO_CHAR( MIN( sea_dateDebut ), 'YYYY-MM-DD HH24:MI:SS' ) As dSeaDebMin,

    4831. 

  4831. 				TO_CHAR( MAX( sea_dateDebut ), 'YYYY-MM-DD HH24:MI:SS' ) as dSeaDebMax, get_nbInscriptionSessionAValider( ses.ses_id ),

    4832. 

  4832. 				ses_coutParUsager, ses_commentaire

    4833. 

  4833. 			From session ses

    4834. 

  4834. 			Left Join seance sea On ses.ses_id = sea.ses_id

    4835. 

  4835. 			Left Join projet pro On ses.prj_id = pro.prj_id

    4836. 

  4836. 			Left Join projetType prt On pro.pt_id = prt.pt_id

    4837. 

  4837. 			Left Join atelier ate On ses.atl_id = ate.atl_id";

    4838. 

  4838. 

    4839. 

  4839. 	$where = "";

    4840. 

  4840. 

    4841. 

  4841. 	// La recherche peut �tre faite pour chaque mot ou pour le groupe au complet

    4842. 

  4842. 	if( $motlnk != "and" && $motlnk != "or" ){

    4843. 

  4843. 		$motlnk="and"; //valeur par defaut : securite

    4844. 

  4844. 	}

    4845. 

  4845. 

    4846. 

  4846. 	// Cr�� une table des mots recherch�s

    4847. 

  4847. 	$arrMot = getArrayFromStringMot( $mot );

    4848. 

  4848. 	if( count( $arrMot ) > 0 ){

    4849. 

  4849. 		$where .= " ( ";

    4850. 

  4850. 		for( $i = 0; $i < count( $arrMot ); $i++ ){

    4851. 

  4851. 

    4852. 

  4852. 			// V�rifie si le mot est dans la colonne 'ATL_ATELIER'

    4853. 

  4853. 			$where .= accentInsensitiveLike( "atl_atelier", $arrMot[ $i ] );

    4854. 

  4854. 			// Ou, v�rifie si le mot est dans la colonne 'ATL_DESCRIPTION'

    4855. 

  4855. 			$where .= " OR " . accentInsensitiveLike( "atl_description", $arrMot[ $i ] );

    4856. 

  4856. 			// Ou, v�rifie si le mot est dans la colonne 'SES_CODE'

    4857. 

  4857. 			$where .= " OR " . accentInsensitiveLike( "ses_code", $arrMot[ $i ] );

    4858. 

  4858. 

    4859. 

  4859. 			// Ajoute le bon mot selon la requ�te de l'usager

    4860. 

  4860. 			if( $i < ( count( $arrMot ) - 1 ) ){

    4861. 

  4861. 				$where .= ") " . $motlnk . " ("; //OR ou AND

    4862. 

  4862. 			}

    4863. 

  4863. 		}

    4864. 

  4864. 		$where .= " ) ";

    4865. 

  4865. 	}

    4866. 

  4866. 

    4867. 

  4867. 	if( is_numeric( $prj_id ) ){

    4868. 

  4868. 		if( $where != "" ){

    4869. 

  4869. 			$where .= " AND ";

    4870. 

  4870. 		}

    4871. 

  4871. 		$where.="ses.prj_id = " . $prj_id;

    4872. 

  4872. 	}

    4873. 

  4873. 	if( is_numeric( $atl_id ) ){

    4874. 

  4874. 		if( $where != "" ){

    4875. 

  4875. 			$where .= " AND ";

    4876. 

  4876. 		}

    4877. 

  4877. 		$where .= "ses.atl_id = " . $atl_id;

    4878. 

  4878. 	}

    4879. 

  4879. 	if( is_numeric( $cla_id ) ){

    4880. 

  4880. 		if( $where != "" ){

    4881. 

  4881. 			$where .= " AND ";

    4882. 

  4882. 		}

    4883. 

  4883. 		$where .= "ses.atl_id IN ( SELECT atl_id FROM atelier_classe WHERE cla_id = " . $cla_id . " )";

    4884. 

  4884. 	}

    4885. 

  4885. 	if( is_numeric( $exp_id ) ){

    4886. 

  4886. 		if( $where != "" ){

    4887. 

  4887. 			$where .= " AND ";

    4888. 

  4888. 		}

    4889. 

  4889. 		$where .= "ses.atl_id IN ( SELECT atl_id FROM atelier_expertise WHERE exp_id = " . $exp_id . " )";

    4890. 

  4890. 	}

    4891. 

  4891. 	if( is_numeric( $cli_id ) ){

    4892. 

  4892. 		if( $where != "" ){

    4893. 

  4893. 			$where .= " AND ";

    4894. 

  4894. 		}

    4895. 

  4895. 		$where .= "ses.atl_id IN ( SELECT atl_id FROM atelier_clientele WHERE cli_id = " . $cli_id . ")";

    4896. 

  4896. 	}

    4897. 

  4897. 	if( $ses_annule != "" ){

    4898. 

  4898. 		if( strtolower( $ses_annule ) == "t" ){

    4899. 

  4899. 			if( $where != "" ){

    4900. 

  4900. 				$where .= " AND ";

    4901. 

  4901. 			}

    4902. 

  4902. 			$where .= "ses_annule = 't'";

    4903. 

  4903. 		} else {

    4904. 

  4904. 			if( $where != "" ){

    4905. 

  4905. 				$where .= " AND ";

    4906. 

  4906. 			}

    4907. 

  4907. 			$where .= "ses_annule = 'f'";

    4908. 

  4908. 		}

    4909. 

  4909. 	}

    4910. 

  4910. 	if( $datelimiteOK != "" ){

    4911. 

  4911. 		if( !strcasecmp( $datelimiteOK, "t" ) ){

    4912. 

  4912. 			if( $where != "" ){

    4913. 

  4913. 				$where .= " AND ";

    4914. 

  4914. 			}

    4915. 

  4915. 			$where .= "( ses_dateLimite >= CURRENT_DATE OR ses_dateLimite IS NULL )";

    4916. 

  4916. 		} else {

    4917. 

  4917. 			if( $where != "" ){

    4918. 

  4918. 				$where .= " AND ";

    4919. 

  4919. 			}

    4920. 

  4920. 			$where .= "ses_dateLimite < CURRENT_DATE";

    4921. 

  4921. 		}

    4922. 

  4922. 	}

    4923. 

  4923. 

    4924. 

  4924. 	if( $dateDebut != "" ){

    4925. 

  4925. 		if( $where != "" ){

    4926. 

  4926. 			$where .= " AND ";

    4927. 

  4927. 		}

    4928. 

  4928. 		$where .= "sea.sea_datedebut >= '" . $dateDebut . "'";

    4929. 

  4929. 	}

    4930. 

  4930. 

    4931. 

  4931. 	if( $dateFin != "" ){

    4932. 

  4932. 		if( $where != "" ){

    4933. 

  4933. 			$where .= " AND ";

    4934. 

  4934. 		}

    4935. 

  4935. 		$where .= "sea.sea_datedebut <= '" . $dateFin . "'";

    4936. 

  4936. 	}

    4937. 

  4937. 

    4938. 

  4938. 	if( $valide != "" ){

    4939. 

  4939. 		if( $valide == "t" ){

    4940. 

  4940. 			if( $where != "" ){

    4941. 

  4941. 				$where .= " AND ";

    4942. 

  4942. 			}

    4943. 

  4943. 			$where .= "prj_valide = 't' AND atl_valide = 't' AND ses_valide = 't'";

    4944. 

  4944. 		} else if( $valide == "f" ){

    4945. 

  4945. 			if( $where != "" ){

    4946. 

  4946. 				$where .= " AND ";

    4947. 

  4947. 			}

    4948. 

  4948. 			// D�s que l'une de ces 3 entit�s est invalide, la session le devient

    4949. 

  4949. 			$where .= "( prj_valide = 'f' Or atl_valide = 'f' Or ses_valide = 'f' )";

    4950. 

  4950. 		}

    4951. 

  4951. 	}

    4952. 

  4952. 

    4953. 

  4953. 	if( is_array( $arrFicheID ) ){

    4954. 

  4954. 		if( $where != "" ){

    4955. 

  4955. 			$where .= " AND ";

    4956. 

  4956. 		}

    4957. 

  4957. 		$where .= "( ses.ses_id <> ses.ses_id";

    4958. 

  4958. 		foreach( $arrFicheID as $fiche_id ){

    4959. 

  4959. 			if( is_numeric( $fiche_id ) ){

    4960. 

  4960. 				$where .= " OR ses.ses_id=" . $fiche_id;

    4961. 

  4961. 			}

    4962. 

  4962. 		}

    4963. 

  4963. 		$where .= " )";

    4964. 

  4964. 	}

    4965. 

  4965. 

    4966. 

  4966. 	if( $where != "" ){

    4967. 

  4967. 		$where = " WHERE " . $where;

    4968. 

  4968. 	}

    4969. 

  4969. 	$SQLStmt .= $where . " GROUP BY ses.ses_id, pro.prj_id, pro.prj_projet, pro.prj_valide, ate.atl_id, ate.atl_atelier,

    4970. 

  4970. 			ate.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_regionnal, ses_annule, ses_annuleraison,

    4971. 

  4971. 			ses_valide, ses_coutParUsager, ses_commentaire";

    4972. 

  4972. 

    4973. 

  4973. 	if( is_numeric( $nbjourstart ) || $nbinsOK != "" ){

    4974. 

  4974. 		$SQLStmt .= " HAVING true"; // Malheureusement, cette clause ne change rien mais elle rend les prochaines lignes plus facile � b�tire

    4975. 

  4975. 		if( is_numeric( $nbjourstart ) ){

    4976. 

  4976. 			$SQLStmt .= " AND prochaineseance( ses.ses_id ) BETWEEN CURRENT_DATE AND CURRENT_DATE + " . $nbjourstart;

    4977. 

  4977. 		}

    4978. 

  4978. 		if( $nbinsOK != "" ){

    4979. 

  4979. 			if( strtolower( $nbinsOK ) == "t" ){

    4980. 

  4980. 				$SQLStmt .= " AND get_nbInscriptionSession( ses.ses_id ) < ses_nbMax";

    4981. 

  4981. 			} else {

    4982. 

  4982. 				$SQLStmt .= " AND get_nbInscriptionSession( ses.ses_id ) >= ses_nbMax";

    4983. 

  4983. 			}

    4984. 

  4984. 		}

    4985. 

  4985. 	}

    4986. 

  4986. 

    4987. 

  4987. 	// Cast $INDX en string car comparer 0 avec une string retourne toujours vrai

    4988. 

  4988. 	switch( ( string ) $indx ){

    4989. 

  4989. 		case "sessiona" :

    4990. 

  4990. 			$SQLStmt .= " ORDER BY ses_code ASC";

    4991. 

  4991. 			break;

    4992. 

  4992. 		case "sessiond" :

    4993. 

  4993. 			$SQLStmt .= " ORDER BY ses_code DESC";

    4994. 

  4994. 			break;

    4995. 

  4995. 		case "descriptiona" :

    4996. 

  4996. 			$SQLStmt .= " ORDER BY atl_atelier ASC";

    4997. 

  4997. 			break;

    4998. 

  4998. 		case "descriptiond" :

    4999. 

  4999. 			$SQLStmt .= " ORDER BY atl_atelier DESC";

    5000. 

  5000. 			break;

    5001. 

  5001. 		case "dateseaa" :

    5002. 

  5002. 			 $SQLStmt .= " ORDER BY dSeaDebMin ASC";

    5003. 

  5003. 			break;

    5004. 

  5004. 		case "datesead" :

    5005. 

  5005. 			$SQLStmt .= " ORDER BY dSeaDebMin DESC";

    5006. 

  5006. 			break;

    5007. 

  5007. 		case "datelima" :

    5008. 

  5008. 			$SQLStmt .= " ORDER BY ses_datelimite ASC";

    5009. 

  5009. 			break;

    5010. 

  5010. 		case "datelimd" :

    5011. 

  5011. 			$SQLStmt .= " ORDER BY ses_datelimite DESC";

    5012. 

  5012. 			break;

    5013. 

  5013. 		case "nbinscriptiona" :

    5014. 

  5014. 			$SQLStmt .= " ORDER BY nbInscription ASC";

    5015. 

  5015. 			break;

    5016. 

  5016. 		case "nbinscriptiond" :

    5017. 

  5017. 			$SQLStmt .= " ORDER BY nbInscription DESC";

    5018. 

  5018. 			break;

    5019. 

  5019. 		case "couta" :

    5020. 

  5020. 			$SQLStmt .= " ORDER BY ses_coutParUsager ASC";

    5021. 

  5021. 			break;

    5022. 

  5022. 		case "coutd" :

    5023. 

  5023. 			$SQLStmt .= " ORDER BY ses_coutParUsager DESC";

    5024. 

  5024. 			break;

    5025. 

  5025. 		default :

    5026. 

  5026. 			break;

    5027. 

  5027. 	}

    5028. 

  5028. 	

    5029. 

  5029. 	return $SQLStmt;

    5030. 

  5030. }

    5031. 

  5031. ///////////////////////////////////////////////////////////////////////////////////////

    5032. 

  5032. // Retourne la requete SQL necessaire pour faire un SELECT -type multi records

    5033. 

  5033. ///////////////////////////////////////////////////////////////////////////////////////

    5034. 

  5034. function getSQLStmtReqSessionsArray($arrFicheID){

    5035. 

  5035.     $SQLStmt="SELECT session.ses_id, session.prj_id, prj_projet, session.atl_id, atl_atelier, ses_code";

    5036. 

  5036.     $SQLStmt.=" FROM session, projet, projetType, atelier";

    5037. 

  5037.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    5038. 

  5038.     $SQLStmt.=" AND projet.pt_id = projetType.pt_id";

    5039. 

  5039.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    5040. 

  5040.     // seulement ce qui est dans le ficheID

    5041. 

  5041.     $SQLStmt.=" AND (session.ses_id <> session.ses_id";

    5042. 

  5042.     for ($i=0; $i<count($arrFicheID); $i++){

    5043. 

  5043.         if (is_numeric($arrFicheID[$i])){

    5044. 

  5044.             $SQLStmt.=" OR session.ses_id=".$arrFicheID[$i];

    5045. 

  5045.         }

    5046. 

  5046.     }

    5047. 

  5047.     $SQLStmt.=" )";

    5048. 

  5048.     return $SQLStmt;

    5049. 

  5049. }

    5050. 

  5050. 

    5051. 

  5051. ///////////////////////////////////////////////////////////////////////////////////////

    5052. 

  5052. // Retourne la requete SQL necessaire pour faire un SELECT

    5053. 

  5053. ///////////////////////////////////////////////////////////////////////////////////////

    5054. 

  5054. function getSQLStmtReqSessionsCart($arrnCartSesID){

    5055. 

  5055.     $SQLStmt="SELECT session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbMin, ses_nbMax, ses_annule, ses_annuleraison, ses_valide, count(seance.sea_id) as nbSeance, get_nbInscriptionSession(session.ses_id) as nbInscription, TO_CHAR(min(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMin, TO_CHAR(max(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMax";

    5056. 

  5056.     $SQLStmt.=" FROM session LEFT JOIN seance ON session.ses_id = seance.ses_id, projet, projetType, atelier";

    5057. 

  5057.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    5058. 

  5058.     $SQLStmt.=" AND projet.pt_id = projetType.pt_id";

    5059. 

  5059.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    5060. 

  5060.     $SQLStmt.=" AND (session.ses_id <> session.ses_id";

    5061. 

  5061.     for ($i=0; $i<count($arrnCartSesID); $i++){

    5062. 

  5062.         if (is_numeric($arrnCartSesID[$i])){

    5063. 

  5063.             $SQLStmt.=" OR session.ses_id=".$arrnCartSesID[$i];

    5064. 

  5064.         }

    5065. 

  5065.     }

    5066. 

  5066.     $SQLStmt.=" )";

    5067. 

  5067.     $SQLStmt.=" GROUP BY session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_annule, ses_annuleraison, ses_valide";

    5068. 

  5068.     $SQLStmt.=" ORDER BY ses_code ASC";

    5069. 

  5069.     return ($SQLStmt);

    5070. 

  5070. }

    5071. 

  5071. 

    5072. 

  5072. ///////////////////////////////////////////////////////////////////////////////////////

    5073. 

  5073. // Retourne la requete SQL necessaire pour faire un SELECT

    5074. 

  5074. ///////////////////////////////////////////////////////////////////////////////////////

    5075. 

  5075. 

    5076. 

  5076. function getSQLStmtReqSessionsFromAnimateur($mot, $motlnk, $prj_id, $atl_id, $cla_id, $exp_id, $cli_id, $ses_annule, $nbjourstart, $datelimiteOK, $nbinsOK, $valide, $arrFicheID, $userID, $indx, $dateDebut = "", $dateFin = ""){

    5077. 

  5077.     $SQLStmt="SELECT session.ses_id, projet.prj_id, prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbMin, ses_nbMax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, count(seance.sea_id) as nbSeance, get_nbInscriptionSession(session.ses_id) as nbInscription, TO_CHAR(min(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMin, TO_CHAR(max(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMax, get_nbInscriptionSessionAValider(session.ses_id), ses_coutParUsager";

    5078. 

  5078.     $SQLStmt.=" FROM animation JOIN (session LEFT JOIN seance USING (ses_id)) USING (ses_id), projet, projetType, atelier";

    5079. 

  5079.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    5080. 

  5080.     $SQLStmt.=" AND projet.pt_id = projetType.pt_id";

    5081. 

  5081.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    5082. 

  5082.     $SQLStmt.=" AND animation.usr_id = $userID";

    5083. 

  5083.     if ($mot!=""){

    5084. 

  5084.         if ($motlnk!="and" && $motlnk!="or"){

    5085. 

  5085.             $motlnk="and"; //valeur par defaut : securite

    5086. 

  5086.         }

    5087. 

  5087.         $arrMot=getArrayFromStringMot($mot);

    5088. 

  5088.         $SQLStmt.=" AND (";

    5089. 

  5089.         for ($i=0; $i<count($arrMot); $i++){

    5090. 

  5090. 			$SQLStmt .= " ( ";

    5091. 

  5091. 			$SQLStmt .= accentInsensitiveLike("atl_atelier", $arrMot[$i]);

    5092. 

  5092. 			$SQLStmt .= " OR " . accentInsensitiveLike("atl_description", $arrMot[$i]);

    5093. 

  5093. 			$SQLStmt .= " OR " . accentInsensitiveLike("ses_code", $arrMot[$i]);

    5094. 

  5094. 			$SQLStmt .= " ) ";

    5095. 

  5095.             if ($i<count($arrMot)-1){

    5096. 

  5096.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    5097. 

  5097.             }

    5098. 

  5098.         }

    5099. 

  5099.         $SQLStmt.=")";

    5100. 

  5100.     }

    5101. 

  5101.     if (is_numeric($prj_id)){

    5102. 

  5102.         $SQLStmt.=" AND session.prj_id = ".$prj_id;

    5103. 

  5103.     }

    5104. 

  5104.     if (is_numeric($atl_id)){

    5105. 

  5105.         $SQLStmt.=" AND session.atl_id = ".$atl_id;

    5106. 

  5106.     }

    5107. 

  5107.     if (is_numeric($cla_id)){

    5108. 

  5108.         $SQLStmt.=" AND session.atl_id IN (";

    5109. 

  5109.             $SQLStmt.=" SELECT atl_id";

    5110. 

  5110.             $SQLStmt.=" FROM atelier_classe";

    5111. 

  5111.             $SQLStmt.=" WHERE cla_id=".$cla_id;

    5112. 

  5112.         $SQLStmt.=")";

    5113. 

  5113.     }

    5114. 

  5114.     if (is_numeric($exp_id)){

    5115. 

  5115.         $SQLStmt.=" AND session.atl_id IN (";

    5116. 

  5116.             $SQLStmt.=" SELECT atl_id";

    5117. 

  5117.             $SQLStmt.=" FROM atelier_expertise";

    5118. 

  5118.             $SQLStmt.=" WHERE exp_id=".$exp_id;

    5119. 

  5119.         $SQLStmt.=")";

    5120. 

  5120.     }

    5121. 

  5121.     if (is_numeric($cli_id)){

    5122. 

  5122.         $SQLStmt.=" AND session.atl_id IN (";

    5123. 

  5123.             $SQLStmt.=" SELECT atl_id";

    5124. 

  5124.             $SQLStmt.=" FROM atelier_clientele";

    5125. 

  5125.             $SQLStmt.=" WHERE cli_id=".$cli_id;

    5126. 

  5126.         $SQLStmt.=")";

    5127. 

  5127.     }

    5128. 

  5128.     if ($ses_annule!=""){

    5129. 

  5129.         if (!strcasecmp($ses_annule,"t")){

    5130. 

  5130.             $SQLStmt.=" AND ses_annule='t'";

    5131. 

  5131.         }

    5132. 

  5132.         else{

    5133. 

  5133.             $SQLStmt.=" AND ses_annule='f'";

    5134. 

  5134.         }

    5135. 

  5135.     }

    5136. 

  5136.     if ($datelimiteOK!=""){

    5137. 

  5137.         if (!strcasecmp($datelimiteOK,"t")){

    5138. 

  5138.             $SQLStmt.=" AND (ses_dateLimite >= CURRENT_DATE OR ses_dateLimite IS NULL)";

    5139. 

  5139.         }

    5140. 

  5140.         else{

    5141. 

  5141.             $SQLStmt.=" AND ses_dateLimite < CURRENT_DATE";

    5142. 

  5142.         }

    5143. 

  5143.     }

    5144. 

  5144. 	if($dateDebut != ""){

    5145. 

  5145. 		 $SQLStmt.=" AND seance.sea_datedebut >= '$dateDebut'";

    5146. 

  5146. 	}

    5147. 

  5147. 

    5148. 

  5148. 	if($dateFin != ""){

    5149. 

  5149. 		$SQLStmt.=" AND seance.sea_datedebut <= '$dateFin'";

    5150. 

  5150. 	}

    5151. 

  5151.     if ($valide!=""){

    5152. 

  5152.         if (!strcasecmp($valide,"t")){

    5153. 

  5153.             $SQLStmt.=" AND prj_valide='t'";

    5154. 

  5154.             $SQLStmt.=" AND atl_valide='t'";

    5155. 

  5155.             $SQLStmt.=" AND ses_valide='t'";

    5156. 

  5156.         }

    5157. 

  5157.         else{

    5158. 

  5158.             $SQLStmt.=" AND prj_valide='f'";

    5159. 

  5159.             $SQLStmt.=" AND atl_valide='f'";

    5160. 

  5160.             $SQLStmt.=" AND ses_valide='f'";

    5161. 

  5161.         }

    5162. 

  5162.     }

    5163. 

  5163.     if (is_array($arrFicheID)){

    5164. 

  5164.         $SQLStmt.=" AND (session.ses_id <> session.ses_id";

    5165. 

  5165.         for ($i=0; $i<count($arrFicheID); $i++){

    5166. 

  5166.             if (is_numeric($arrFicheID[$i])){

    5167. 

  5167.                 $SQLStmt.=" OR session.ses_id=".$arrFicheID[$i];

    5168. 

  5168.             }

    5169. 

  5169.         }

    5170. 

  5170.         $SQLStmt.=" )";

    5171. 

  5171.     }

    5172. 

  5172.     $SQLStmt.=" GROUP BY session.ses_id, projet.prj_id, projet.prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, ses_coutParUsager";

    5173. 

  5173.     $SQLStmt.=" HAVING true";

    5174. 

  5174.     if (is_numeric($nbjourstart)){

    5175. 

  5175.         $SQLStmt.=" AND prochaineseance(session.ses_id) BETWEEN CURRENT_DATE AND CURRENT_DATE+". $nbjourstart;

    5176. 

  5176.     }

    5177. 

  5177.     if ($nbinsOK!=""){

    5178. 

  5178.         if (!strcasecmp($nbinsOK,"t")){

    5179. 

  5179.             $SQLStmt.=" AND get_nbInscriptionSession(session.ses_id) < ses_nbMax";

    5180. 

  5180.         }

    5181. 

  5181.         else{

    5182. 

  5182.             $SQLStmt.=" AND get_nbInscriptionSession(session.ses_id) >= ses_nbMax";

    5183. 

  5183.         }

    5184. 

  5184.     }

    5185. 

  5185.     if ($indx!=""){

    5186. 

  5186.         if ($indx=="sessiona"){

    5187. 

  5187.             $SQLStmt.=" ORDER BY ses_code ASC";

    5188. 

  5188.         }

    5189. 

  5189.         elseif ($indx=="sessiond"){

    5190. 

  5190.             $SQLStmt.=" ORDER BY ses_code DESC";

    5191. 

  5191.         }

    5192. 

  5192.         elseif ($indx=="dateseaa"){

    5193. 

  5193.             $SQLStmt.=" ORDER BY dSeaDebMin ASC";

    5194. 

  5194.         }

    5195. 

  5195.         elseif ($indx=="datesead"){

    5196. 

  5196.             $SQLStmt.=" ORDER BY dSeaDebMin DESC";

    5197. 

  5197.         }

    5198. 

  5198.         elseif ($indx=="datelima"){

    5199. 

  5199.             $SQLStmt.=" ORDER BY ses_datelimite ASC";

    5200. 

  5200.         }

    5201. 

  5201.         elseif ($indx=="datelimd"){

    5202. 

  5202.             $SQLStmt.=" ORDER BY ses_datelimite DESC";

    5203. 

  5203.         }

    5204. 

  5204.         elseif ($indx=="nbinscriptiona"){

    5205. 

  5205.             $SQLStmt.=" ORDER BY nbInscription ASC";

    5206. 

  5206.         }

    5207. 

  5207.         elseif ($indx=="nbinscriptiond"){

    5208. 

  5208.             $SQLStmt.=" ORDER BY nbInscription DESC";

    5209. 

  5209.         }

    5210. 

  5210.         elseif ($indx=="couta"){

    5211. 

  5211.             $SQLStmt.=" ORDER BY ses_coutParUsager ASC";

    5212. 

  5212.         }

    5213. 

  5213.         elseif ($indx=="coutd"){

    5214. 

  5214.             $SQLStmt.=" ORDER BY ses_coutParUsager DESC";

    5215. 

  5215.         }

    5216. 

  5216.     }

    5217. 

  5217.     return ($SQLStmt);

    5218. 

  5218. }

    5219. 

  5219. 

    5220. 

  5220. 

    5221. 

  5221. function getSQLStmtReqSessionsFromAdminProjet($mot, $motlnk, $prj_id, $atl_id, $cla_id, $exp_id, $cli_id, $ses_annule, $nbjourstart, $datelimiteOK, $nbinsOK, $valide, $arrFicheID, $usrid, $indx,$dateDebut = "", $dateFin = ""){

    5222. 

  5222.     $SQLStmt="SELECT session.ses_id, projet.prj_id, prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbMin, ses_nbMax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, count(seance.sea_id) as nbSeance, get_nbInscriptionSession(session.ses_id) as nbInscription, TO_CHAR(min(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMin, TO_CHAR(max(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMax, get_nbInscriptionSessionAValider(session.ses_id), ses_coutParUsager";

    5223. 

  5223.     $SQLStmt.=" FROM session LEFT JOIN seance ON session.ses_id = seance.ses_id, projet, projetType, atelier";

    5224. 

  5224.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    5225. 

  5225.     $SQLStmt .= " AND session.prj_id IN (";

    5226. 

  5226.     $SQLStmt .= " SELECT prj_id FROM projetAdmin WHERE usr_id = $usrid";

    5227. 

  5227.     $SQLStmt .= ")";

    5228. 

  5228.     $SQLStmt.=" AND projet.pt_id = projetType.pt_id";

    5229. 

  5229.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    5230. 

  5230.     if ($mot!=""){

    5231. 

  5231.         if ($motlnk!="and" && $motlnk!="or"){

    5232. 

  5232.             $motlnk="and"; //valeur par defaut : securite

    5233. 

  5233.         }

    5234. 

  5234.         $arrMot=getArrayFromStringMot($mot);

    5235. 

  5235.         $SQLStmt.=" AND (";

    5236. 

  5236.         for ($i=0; $i<count($arrMot); $i++){

    5237. 

  5237. 			$SQLStmt .= " ( ";

    5238. 

  5238. 			$SQLStmt .= accentInsensitiveLike("atl_atelier", $arrMot[$i]);

    5239. 

  5239. 			$SQLStmt .= " OR " . accentInsensitiveLike("atl_description", $arrMot[$i]);

    5240. 

  5240. 			$SQLStmt .= " OR " . accentInsensitiveLike("ses_code", $arrMot[$i]);

    5241. 

  5241. 			$SQLStmt .= " ) ";

    5242. 

  5242.             if ($i<count($arrMot)-1){

    5243. 

  5243.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    5244. 

  5244.             }

    5245. 

  5245.         }

    5246. 

  5246.         $SQLStmt.=")";

    5247. 

  5247.     }

    5248. 

  5248.     if (is_numeric($prj_id)){

    5249. 

  5249.         $SQLStmt.=" AND session.prj_id = ".$prj_id;

    5250. 

  5250.     }

    5251. 

  5251.     if (is_numeric($atl_id)){

    5252. 

  5252.         $SQLStmt.=" AND session.atl_id = ".$atl_id;

    5253. 

  5253.     }

    5254. 

  5254.     if (is_numeric($cla_id)){

    5255. 

  5255.         $SQLStmt.=" AND session.atl_id IN (";

    5256. 

  5256.             $SQLStmt.=" SELECT atl_id";

    5257. 

  5257.             $SQLStmt.=" FROM atelier_classe";

    5258. 

  5258.             $SQLStmt.=" WHERE cla_id=".$cla_id;

    5259. 

  5259.         $SQLStmt.=")";

    5260. 

  5260.     }

    5261. 

  5261.     if (is_numeric($exp_id)){

    5262. 

  5262.         $SQLStmt.=" AND session.atl_id IN (";

    5263. 

  5263.             $SQLStmt.=" SELECT atl_id";

    5264. 

  5264.             $SQLStmt.=" FROM atelier_expertise";

    5265. 

  5265.             $SQLStmt.=" WHERE exp_id=".$exp_id;

    5266. 

  5266.         $SQLStmt.=")";

    5267. 

  5267.     }

    5268. 

  5268.     if (is_numeric($cli_id)){

    5269. 

  5269.         $SQLStmt.=" AND session.atl_id IN (";

    5270. 

  5270.             $SQLStmt.=" SELECT atl_id";

    5271. 

  5271.             $SQLStmt.=" FROM atelier_clientele";

    5272. 

  5272.             $SQLStmt.=" WHERE cli_id=".$cli_id;

    5273. 

  5273.         $SQLStmt.=")";

    5274. 

  5274.     }

    5275. 

  5275.     if ($ses_annule!=""){

    5276. 

  5276.         if (!strcasecmp($ses_annule,"t")){

    5277. 

  5277.             $SQLStmt.=" AND ses_annule='t'";

    5278. 

  5278.         }

    5279. 

  5279.         else{

    5280. 

  5280.             $SQLStmt.=" AND ses_annule='f'";

    5281. 

  5281.         }

    5282. 

  5282.     }

    5283. 

  5283.     if ($datelimiteOK!=""){

    5284. 

  5284.         if (!strcasecmp($datelimiteOK,"t")){

    5285. 

  5285.             $SQLStmt.=" AND (ses_dateLimite >= CURRENT_DATE OR ses_dateLimite IS NULL)";

    5286. 

  5286.         }

    5287. 

  5287.         else{

    5288. 

  5288.             $SQLStmt.=" AND ses_dateLimite < CURRENT_DATE";

    5289. 

  5289.         }

    5290. 

  5290.     }

    5291. 

  5291. 

    5292. 

  5292. 	

    5293. 

  5293. 	if($dateDebut != ""){

    5294. 

  5294. 		 $SQLStmt.=" AND seance.sea_datedebut >= '$dateDebut'";

    5295. 

  5295. 	}

    5296. 

  5296. 

    5297. 

  5297. 	if($dateFin != ""){

    5298. 

  5298. 		$SQLStmt.=" AND seance.sea_datedebut <= '$dateFin'";

    5299. 

  5299. 	}

    5300. 

  5300. 

    5301. 

  5301. 

    5302. 

  5302.     if ($valide!=""){

    5303. 

  5303.         if (!strcasecmp($valide,"t")){

    5304. 

  5304.             $SQLStmt.=" AND prj_valide='t'";

    5305. 

  5305.             $SQLStmt.=" AND atl_valide='t'";

    5306. 

  5306.             $SQLStmt.=" AND ses_valide='t'";

    5307. 

  5307.         }

    5308. 

  5308.         else{

    5309. 

  5309.             $SQLStmt.=" AND prj_valide='f'";

    5310. 

  5310.             $SQLStmt.=" AND atl_valide='f'";

    5311. 

  5311.             $SQLStmt.=" AND ses_valide='f'";

    5312. 

  5312.         }

    5313. 

  5313.     }

    5314. 

  5314.     if (is_array($arrFicheID)){

    5315. 

  5315.         $SQLStmt.=" AND (session.ses_id <> session.ses_id";

    5316. 

  5316.         for ($i=0; $i<count($arrFicheID); $i++){

    5317. 

  5317.             if (is_numeric($arrFicheID[$i])){

    5318. 

  5318.                 $SQLStmt.=" OR session.ses_id=".$arrFicheID[$i];

    5319. 

  5319.             }

    5320. 

  5320.         }

    5321. 

  5321.         $SQLStmt.=" )";

    5322. 

  5322.     }

    5323. 

  5323.     $SQLStmt.=" GROUP BY session.ses_id, projet.prj_id, projet.prj_projet, projet.prj_valide, atelier.atl_id, atelier.atl_atelier, atelier.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, ses_coutParUsager";

    5324. 

  5324.     $SQLStmt.=" HAVING true";

    5325. 

  5325.     if (is_numeric($nbjourstart)){

    5326. 

  5326.         $SQLStmt.=" AND prochaineseance(session.ses_id) BETWEEN CURRENT_DATE AND CURRENT_DATE+". $nbjourstart;

    5327. 

  5327.     }

    5328. 

  5328.     if ($nbinsOK!=""){

    5329. 

  5329.         if (!strcasecmp($nbinsOK,"t")){

    5330. 

  5330.             $SQLStmt.=" AND get_nbInscriptionSession(session.ses_id) < ses_nbMax";

    5331. 

  5331.         }

    5332. 

  5332.         else{

    5333. 

  5333.             $SQLStmt.=" AND get_nbInscriptionSession(session.ses_id) >= ses_nbMax";

    5334. 

  5334.         }

    5335. 

  5335.     }

    5336. 

  5336.     if ($indx!=""){

    5337. 

  5337.         if ($indx=="sessiona"){

    5338. 

  5338.             $SQLStmt.=" ORDER BY ses_code ASC";

    5339. 

  5339.         }

    5340. 

  5340.         elseif ($indx=="sessiond"){

    5341. 

  5341.             $SQLStmt.=" ORDER BY ses_code DESC";

    5342. 

  5342.         }

    5343. 

  5343.         elseif ($indx=="dateseaa"){

    5344. 

  5344.             $SQLStmt.=" ORDER BY dSeaDebMin ASC";

    5345. 

  5345.         }

    5346. 

  5346.         elseif ($indx=="datesead"){

    5347. 

  5347.             $SQLStmt.=" ORDER BY dSeaDebMin DESC";

    5348. 

  5348.         }

    5349. 

  5349.         elseif ($indx=="datelima"){

    5350. 

  5350.             $SQLStmt.=" ORDER BY ses_datelimite ASC";

    5351. 

  5351.         }

    5352. 

  5352.         elseif ($indx=="datelimd"){

    5353. 

  5353.             $SQLStmt.=" ORDER BY ses_datelimite DESC";

    5354. 

  5354.         }

    5355. 

  5355.         elseif ($indx=="nbinscriptiona"){

    5356. 

  5356.             $SQLStmt.=" ORDER BY nbInscription ASC";

    5357. 

  5357.         }

    5358. 

  5358.         elseif ($indx=="nbinscriptiond"){

    5359. 

  5359.             $SQLStmt.=" ORDER BY nbInscription DESC";

    5360. 

  5360.         }

    5361. 

  5361.         elseif ($indx=="couta"){

    5362. 

  5362.             $SQLStmt.=" ORDER BY ses_coutParUsager ASC";

    5363. 

  5363.         }

    5364. 

  5364.         elseif ($indx=="coutd"){

    5365. 

  5365.             $SQLStmt.=" ORDER BY ses_coutParUsager DESC";

    5366. 

  5366.         }

    5367. 

  5367.     }

    5368. 

  5368.     return ($SQLStmt);

    5369. 

  5369. }

    5370. 

  5370. 

    5371. 

  5371. ///////////////////////////////////////////////////////////////////////////////////////

    5372. 

  5372. // Retourne la requete SQL necessaire pour faire un SELECT

    5373. 

  5373. ///////////////////////////////////////////////////////////////////////////////////////

    5374. 

  5374. function getSQLStmtReqSessionsFromAtelier($atl_id){

    5375. 

  5375.     $SQLStmt="SELECT session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_annule, ses_annuleraison, ses_valide, count(seance.ses_id) as nbSeance, get_nbInscriptionSession(session.ses_id) as nbInscription, TO_CHAR(min(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMin, TO_CHAR(max(sea_dateDebut), 'YYYY-MM-DD HH24:MI:SS') as dSeaDebMax";

    5376. 

  5376.     $SQLStmt.=" FROM session LEFT JOIN seance ON session.ses_id = seance.ses_id, projet, projetType, atelier";

    5377. 

  5377.     $SQLStmt.=" WHERE session.prj_id = projet.prj_id";

    5378. 

  5378.     $SQLStmt.=" AND projet.pt_id = projetType.pt_id";

    5379. 

  5379.     $SQLStmt.=" AND session.atl_id = atelier.atl_id";

    5380. 

  5380.     $SQLStmt.=" AND session.atl_id = ".$atl_id;

    5381. 

  5381.     $SQLStmt.=" GROUP BY session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_annule, ses_annuleraison, ses_valide";

    5382. 

  5382.     echo $SQLStmt.=" ORDER BY session.ses_code";

    5383. 

  5383.     return ($SQLStmt);

    5384. 

  5384. }

    5385. 

  5385. 

    5386. 

  5386. ///////////////////////////////////////////////////////////////////////////////////////

    5387. 

  5387. // Retourne la requete SQL necessaire pour faire un SELECT

    5388. 

  5388. ///////////////////////////////////////////////////////////////////////////////////////

    5389. 

  5389. function getSQLStmtReqSessionsPortfolio( $usr_id_INSCRIT, $histo, $order_by = "" ){

    5390. 

  5390. 	$SQLStmt = 'Select session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbMin, ses_nbMax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, Count( seance.sea_id ) as nbSeance, get_nbInscriptionSession( session.ses_id ) as nbInscription, To_Char( Min( sea_dateDebut ), \'YYYY-MM-DD HH24:MI:SS\' ) as dSeaDebMin, To_Char( Max( sea_dateDebut ), \'YYYY-MM-DD HH24:MI:SS\' ) as dSeaDebMax, get_nbPresencePerSessionUser( session.ses_id, inscriptionSession.usr_id ) As nbPresence, inscriptionEtat.ie_OK, atl_valide, prj_valide

    5391. 

  5391. 			FROM session

    5392. 

  5392. 			LEFT JOIN seance ON session.ses_id = seance.ses_id

    5393. 

  5393. 			LEFT JOIN projet ON session.prj_id = projet.prj_id

    5394. 

  5394. 			LEFT JOIN projetType ON projet.pt_id = projetType.pt_id

    5395. 

  5395. 			LEFT JOIN atelier ON session.atl_id = atelier.atl_id

    5396. 

  5396. 			LEFT JOIN inscriptionSession ON session.ses_id = inscriptionSession.ses_id

    5397. 

  5397. 			LEFT JOIN inscriptionEtat ON inscriptionSession.ie_id = inscriptionEtat.ie_id

    5398. 

  5398. 			WHERE inscriptionSession.usr_id = \'' . $usr_id_INSCRIT . '\'

    5399. 

  5399. 			GROUP BY session.ses_id, session.prj_id, prj_projet, projet.pt_id, pt_type, session.atl_id, atl_atelier, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, inscriptionSession.usr_id, inscriptionEtat.ie_OK, atl_valide, prj_valide';

    5400. 

  5400. 

    5401. 

  5401. 	// On retourne soit l'historique future, pass�e ou toute

    5402. 

  5402. 	if( $histo == 'futur' ){

    5403. 

  5403. 		$SQLStmt .= ' HAVING ( max( sea_dateFin ) >= CURRENT_DATE OR min( sea_dateDebut ) IS NULL )';

    5404. 

  5404. 	} elseif( $histo == 'termine' ){

    5405. 

  5405. 		$SQLStmt .= ' HAVING inscriptionEtat.ie_OK = \'t\' AND max( sea_dateFin ) < CURRENT_DATE';

    5406. 

  5406. 	}

    5407. 

  5407. 

    5408. 

  5408. 	switch( $order_by ) {

    5409. 

  5409. 		case 'sessiona' :

    5410. 

  5410. 			$SQLStmt .= ' Order By ses_code Asc';

    5411. 

  5411. 			break;

    5412. 

  5412. 		case 'sessiond' :

    5413. 

  5413. 			$SQLStmt .= ' Order By ses_code Desc';

    5414. 

  5414. 			break;

    5415. 

  5415. 		case 'dateseaa' :

    5416. 

  5416. 			$SQLStmt .= ' Order By dSeaDebMin Asc';

    5417. 

  5417. 			break;

    5418. 

  5418. 		case 'datesead' :

    5419. 

  5419. 			$SQLStmt .= ' Order By dSeaDebMin Desc';

    5420. 

  5420. 			break;

    5421. 

  5421. 		case 'datelima' :

    5422. 

  5422. 			$SQLStmt .= ' Order By ses_datelimite Asc';

    5423. 

  5423. 			break;

    5424. 

  5424. 		case 'datelimd' :

    5425. 

  5425. 			$SQLStmt .= ' Order By ses_datelimite Desc';

    5426. 

  5426. 			break;

    5427. 

  5427. 		case 'nbinscriptiona' :

    5428. 

  5428. 			$SQLStmt .= ' Order By nbInscription Asc';

    5429. 

  5429. 			break;

    5430. 

  5430. 		case 'nbinscriptiond' :

    5431. 

  5431. 			$SQLStmt .= ' Order By nbInscription Desc';

    5432. 

  5432. 			break;

    5433. 

  5433. 		case 'couta' :

    5434. 

  5434. 			$SQLStmt .= ' Order By ses_coutParUsager Asc';

    5435. 

  5435. 			break;

    5436. 

  5436. 		case 'coutd' :

    5437. 

  5437. 			$SQLStmt .= ' Order By ses_coutParUsager Desc';

    5438. 

  5438. 			break;

    5439. 

  5439. 		default :

    5440. 

  5440. 			$SQLStmt .= ' Order By dSeaDebMin Desc, ses_code Asc';

    5441. 

  5441. 	}

    5442. 

  5442. 	return $SQLStmt;

    5443. 

  5443. }

    5444. 

  5444. 

    5445. 

  5445. function getSQLStmtReqSousHierarchies($branchID, $treeID) {

    5446. 

  5446. 	$sql = "SELECT node, etiquette FROM nodes";

    5447. 

  5447. 	if (is_numeric($branchID)) {

    5448. 

  5448. 		$sql .= " WHERE parent = $branchID";

    5449. 

  5449. 	}

    5450. 

  5450. 	else {

    5451. 

  5451. 		$sql .= " WHERE parent IS NULL";

    5452. 

  5452. 	}

    5453. 

  5453. 	$sql .= " AND tr_id = $treeID";

    5454. 

  5454. 	

    5455. 

  5455. 	return $sql;

    5456. 

  5456. }

    5457. 

  5457. 

    5458. 

  5458. ///////////////////////////////////////////////////////////////////////////////////////

    5459. 

  5459. // Retourne la requete SQL necessaire pour faire un SELECT -type 1 record

    5460. 

  5460. ///////////////////////////////////////////////////////////////////////////////////////

    5461. 

  5461. function getSQLStmtReqUsager($usr_id){

    5462. 

  5462.     $SQLStmt="SELECT usr_nom, usr_prenom, usr_email, usr_URL, usr_telRejoindre, usr_telTravail, usr_telMaison, usr_telCellulaire, usr_telPage, usr_telFax, usr_adresse, usr_ville, usr_codePostal, usr_societe, usr_fonction, usr_nas, usr_dateNaissance, usr_commentaire,  usr_interet, usr_LDAP, usr_login, TO_CHAR(usager.usr_dernieracces, 'YYYY-MM-DD HH24:MI:SS') AS usr_dernieracces, usager.li_id, lieu.li_lieu, usr_enligne, usr_valide, TO_CHAR(usager.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') AS dateUpdate, TO_CHAR(usager.dateCreation, 'YYYY-MM-DD HH24:MI:SS') AS dateCreation, usr_locale";

    5463. 

  5463.     $SQLStmt.=" FROM usager, lieu";

    5464. 

  5464.     $SQLStmt.=" WHERE usager.li_id = lieu.li_id";

    5465. 

  5465.     $SQLStmt.=" AND usr_id = ".$usr_id;

    5466. 

  5466.     return ($SQLStmt);

    5467. 

  5467. }

    5468. 

  5468. 

    5469. 

  5469. ///////////////////////////////////////////////////////////////////////////////////////

    5470. 

  5470. // Retourne la requete SQL necessaire pour faire un SELECT -type:LAST

    5471. 

  5471. ///////////////////////////////////////////////////////////////////////////////////////

    5472. 

  5472. function getSQLStmtReqUsagerLAST(){

    5473. 

  5473.     $SQLStmt="SELECT MAX(usr_id) FROM usager";

    5474. 

  5474.     return $SQLStmt;

    5475. 

  5475. }

    5476. 

  5476. 

    5477. 

  5477. ///////////////////////////////////////////////////////////////////////////////////////

    5478. 

  5478. // Retourne la requete SQL necessaire pour faire un SELECT -type 1 record

    5479. 

  5479. ///////////////////////////////////////////////////////////////////////////////////////

    5480. 

  5480. function getSQLStmtReqUsagerFromLDAP($usr_ldapcode){

    5481. 

  5481.     $SQLStmt="SELECT usr_id";

    5482. 

  5482.     $SQLStmt.=" FROM usager";

    5483. 

  5483.     $SQLStmt.=" WHERE usr_ldapcode = '".fixPGQuote($usr_ldapcode)."'";

    5484. 

  5484.     return ($SQLStmt);

    5485. 

  5485. }

    5486. 

  5486. 

    5487. 

  5487. ///////////////////////////////////////////////////////////////////////////////////////

    5488. 

  5488. // Retourne la requete SQL necessaire pour faire un SELECT -type 1 record

    5489. 

  5489. ///////////////////////////////////////////////////////////////////////////////////////

    5490. 

  5490. function getSQLStmtReqUsagerFromLogin($usr_login){

    5491. 

  5491.     $SQLStmt="SELECT usr_id, usr_ldap";

    5492. 

  5492.     $SQLStmt.=" FROM usager";

    5493. 

  5493.     $SQLStmt.=" WHERE usr_login = '".fixPGQuote($usr_login)."'";

    5494. 

  5494.     return ($SQLStmt);

    5495. 

  5495. }

    5496. 

  5496. 

    5497. 

  5497. ///////////////////////////////////////////////////////////////////////////////////////

    5498. 

  5498. // Retourne la requete SQL necessaire pour faire un SELECT -type 1 record

    5499. 

  5499. ///////////////////////////////////////////////////////////////////////////////////////

    5500. 

  5500. function getSQLStmtReqUsagerFromLoginPsw($usr_login, $usr_psw){

    5501. 

  5501.     $SQLStmt="SELECT usr_id";

    5502. 

  5502.     $SQLStmt.=" FROM usager";

    5503. 

  5503.     $SQLStmt.=" WHERE usr_login = '".fixPGQuote($usr_login)."'";

    5504. 

  5504.     $SQLStmt.=" AND usr_psw = '".fixPGQuote($usr_psw)."'";

    5505. 

  5505.     $SQLStmt.=" AND usr_ldap = 'f'";

    5506. 

  5506.     return ($SQLStmt);

    5507. 

  5507. }

    5508. 

  5508. 

    5509. 

  5509. ///////////////////////////////////////////////////////////////////////////////////////

    5510. 

  5510. // Retourne la requete SQL necessaire pour faire un SELECT -type multi records

    5511. 

  5511. ///////////////////////////////////////////////////////////////////////////////////////

    5512. 

  5512. function getSQLStmtReqUsagers($mot, $motlnk, $ut_id, $li_id, $adminlieu_id, $valide, $arrFicheID, $indx){

    5513. 

  5513.     $SQLStmt="SELECT usr_id, usr_nom, usr_prenom, usr_email, usr_enligne, usr_valide, usager.li_id, lieu.li_lieu, get_usagerTypeListe(usr_id, ' + ') AS usagerTypeListe, usager.usr_ldap";

    5514. 

  5514.     $SQLStmt.=" FROM usager, lieu";

    5515. 

  5515.     $SQLStmt.=" WHERE usr_id = usr_id";

    5516. 

  5516.     $SQLStmt.=" AND usager.li_id = lieu.li_id";

    5517. 

  5517.     if ($mot!=""){

    5518. 

  5518.         if ($motlnk!="and" && $motlnk!="or"){

    5519. 

  5519.             $motlnk="and"; //valeur par defaut : securite

    5520. 

  5520.         }

    5521. 

  5521.         $arrMot=getArrayFromStringMot($mot);

    5522. 

  5522.         $SQLStmt.=" AND (";

    5523. 

  5523.         for ($i=0; $i<count($arrMot); $i++){

    5524. 

  5524.             $SQLStmt.="(usr_nom ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    5525. 

  5525.             $SQLStmt.=" OR usr_prenom ILIKE '%".fixPGQuote($arrMot[$i])."%'";

    5526. 

  5526.             $SQLStmt.=" OR usr_prenom||' '||usr_nom ILIKE '%".fixPGQuote($arrMot[$i])."%')";

    5527. 

  5527.             if ($i<count($arrMot)-1){

    5528. 

  5528.                 $SQLStmt.=" ".$motlnk." "; //OR ou AND

    5529. 

  5529.             }

    5530. 

  5530.         }

    5531. 

  5531.         $SQLStmt.=")";

    5532. 

  5532.     }

    5533. 

  5533.     if (is_numeric($ut_id)){

    5534. 

  5534.         $SQLStmt.=" AND usr_id IN (";

    5535. 

  5535.             $SQLStmt.=" SELECT usr_id";

    5536. 

  5536.             $SQLStmt.=" FROM usager_usagerType";

    5537. 

  5537.             $SQLStmt.=" WHERE ut_id=".$ut_id;

    5538. 

  5538.         $SQLStmt.=")";

    5539. 

  5539.     }

    5540. 

  5540.     if (is_numeric($li_id)){

    5541. 

  5541.         $SQLStmt.=" AND usager.li_id = ".$li_id;

    5542. 

  5542.     }

    5543. 

  5543.     if (is_numeric($adminlieu_id)){

    5544. 

  5544.         $SQLStmt.=" AND usager.li_id IN (";

    5545. 

  5545.             $SQLStmt.=" SELECT li_id";

    5546. 

  5546.             $SQLStmt.=" FROM lieuadmin";

    5547. 

  5547.             $SQLStmt.=" WHERE usr_id=".$adminlieu_id;

    5548. 

  5548.         $SQLStmt.=")";

    5549. 

  5549.     }

    5550. 

  5550.     if ($valide!=""){

    5551. 

  5551.         if (!strcasecmp($valide,"t")){

    5552. 

  5552.             $SQLStmt.=" AND usr_valide='t'";

    5553. 

  5553.         }

    5554. 

  5554.         else{

    5555. 

  5555.             $SQLStmt.=" AND usr_valide='f'";

    5556. 

  5556.         }

    5557. 

  5557.     }

    5558. 

  5558.     if (is_array($arrFicheID)){

    5559. 

  5559.         $SQLStmt.=" AND (usager.usr_id <> usager.usr_id";

    5560. 

  5560.         for ($i=0; $i<count($arrFicheID); $i++){

    5561. 

  5561.             if (is_numeric($arrFicheID[$i])){

    5562. 

  5562.                 $SQLStmt.=" OR usager.usr_id=".$arrFicheID[$i];

    5563. 

  5563.             }

    5564. 

  5564.         }

    5565. 

  5565.         $SQLStmt.=" )";

    5566. 

  5566.     }

    5567. 

  5567.     if ($indx!=""){

    5568. 

  5568.         if ($indx=="noma"){

    5569. 

  5569.             $SQLStmt.=" ORDER BY usr_nom ASC, usr_prenom ASC";

    5570. 

  5570.         }

    5571. 

  5571.         elseif ($indx=="nomd"){

    5572. 

  5572.             $SQLStmt.=" ORDER BY usr_nom DESC, usr_prenom DESC";

    5573. 

  5573.         }

    5574. 

  5574.         elseif ($indx=="lieua"){

    5575. 

  5575.             $SQLStmt.=" ORDER BY li_lieu ASC";

    5576. 

  5576.         }

    5577. 

  5577.         elseif ($indx=="lieud"){

    5578. 

  5578.             $SQLStmt.=" ORDER BY li_lieu DESC";

    5579. 

  5579.         }

    5580. 

  5580.         elseif ($indx=="typea"){

    5581. 

  5581.             $SQLStmt.=" ORDER BY usagerTypeListe ASC";

    5582. 

  5582.         }

    5583. 

  5583.         elseif ($indx=="typed"){

    5584. 

  5584.             $SQLStmt.=" ORDER BY usagerTypeListe DESC";

    5585. 

  5585.         }

    5586. 

  5586.     }

    5587. 

  5587.     return $SQLStmt;

    5588. 

  5588. }

    5589. 

  5589. 

    5590. 

  5590. ///////////////////////////////////////////////////////////////////////////////////////

    5591. 

  5591. // Retourne la requete SQL necessaire pour faire un SELECT -type multi records

    5592. 

  5592. ///////////////////////////////////////////////////////////////////////////////////////

    5593. 

  5593. function getSQLStmtReqUsagersArray($arrFicheID){

    5594. 

  5594.     $SQLStmt="SELECT usr_id, usr_nom, usr_prenom";

    5595. 

  5595.     $SQLStmt.=" FROM usager";

    5596. 

  5596.     $SQLStmt.=" WHERE (usager.usr_id <> usager.usr_id";

    5597. 

  5597.     for ($i=0; $i<count($arrFicheID); $i++){

    5598. 

  5598.         if (is_numeric($arrFicheID[$i])){

    5599. 

  5599.             $SQLStmt.=" OR usager.usr_id=".$arrFicheID[$i];

    5600. 

  5600.         }

    5601. 

  5601.     }

    5602. 

  5602.     $SQLStmt.=" )";

    5603. 

  5603.     return $SQLStmt;

    5604. 

  5604. }

    5605. 

  5605. 

    5606. 

  5606. ///////////////////////////////////////////////////////////////////////////////////////

    5607. 

  5607. // Retourne la requete SQL necessaire pour faire un SELECT -type 1 record

    5608. 

  5608. ///////////////////////////////////////////////////////////////////////////////////////

    5609. 

  5609. function getSQLStmtReqUsagerGeneral($usr_id){

    5610. 

  5610.     $SQLStmt="SELECT usr_nom, usr_prenom, usr_locale";

    5611. 

  5611.     $SQLStmt.=" FROM usager";

    5612. 

  5612.     $SQLStmt.=" WHERE usr_id = " . $usr_id;

    5613. 

  5613.     return ($SQLStmt);

    5614. 

  5614. }

    5615. 

  5615. 

    5616. 

  5616. ///////////////////////////////////////////////////////////////////////////////////////

    5617. 

  5617. // Retourne la requete SQL necessaire pour faire un SELECT

    5618. 

  5618. ///////////////////////////////////////////////////////////////////////////////////////

    5619. 

  5619. function getSQLStmtReqUsagerTypeForSecID($sec_id){

    5620. 

  5620.     $SQLStmt="SELECT usagerType.ut_id, usagerType.ut_type";

    5621. 

  5621.     $SQLStmt.=" FROM usagerType";

    5622. 

  5622.     $SQLStmt.=" WHERE usagerType.sec_id <= " . $sec_id;

    5623. 

  5623.     return ($SQLStmt);

    5624. 

  5624. }

    5625. 

  5625. 

    5626. 

  5626. ///////////////////////////////////////////////////////////////////////////////////////

    5627. 

  5627. // Retourne la requete SQL necessaire pour faire un SELECT

    5628. 

  5628. ///////////////////////////////////////////////////////////////////////////////////////

    5629. 

  5629. function getSQLStmtReqUsagerTypeForUser($usr_id){

    5630. 

  5630.     $SQLStmt="SELECT usagerType.ut_id, usagerType.ut_type, usagerType.sec_id";

    5631. 

  5631.     $SQLStmt.=" FROM usager_usagerType, usagerType";

    5632. 

  5632.     $SQLStmt.=" WHERE usager_usagerType.ut_id=usagerType.ut_id";

    5633. 

  5633.     $SQLStmt.=" AND usr_id = " . $usr_id;

    5634. 

  5634.     return ($SQLStmt);

    5635. 

  5635. }

    5636. 

  5636. 

    5637. 

  5637. ///////////////////////////////////////////////////////////////////////////////////////

    5638. 

  5638. // Retourne la requete SQL necessaire pour faire un SELECT

    5639. 

  5639. ///////////////////////////////////////////////////////////////////////////////////////

    5640. 

  5640. function getSQLStmtReqUsagerTypeLogin($usr_id){

    5641. 

  5641.     $SQLStmt="SELECT usagerType.ut_id, usagerType.sec_id";

    5642. 

  5642.     $SQLStmt.=" FROM usager_usagertype, usagerType";

    5643. 

  5643.     $SQLStmt.=" WHERE usager_usagerType.ut_id = usagerType.ut_id";

    5644. 

  5644.     $SQLStmt.=" AND usr_id = " . $usr_id;

    5645. 

  5645.     return ($SQLStmt);

    5646. 

  5646. }

    5647. 

  5647. 

    5648. 

  5648. ///////////////////////////////////////////////////////////////////////////////////////

    5649. 

  5649. // function getTimeStamp($date, $time)

    5650. 

  5650. // Retourne le timestamp en fonction de la date et l'heure pass�es en param�tres

    5651. 

  5651. //  IN:     $date:      la date

    5652. 

  5652. //          $time:      l'heure

    5653. 

  5653. //  OUT:    (string-timestamp) le timestamp

    5654. 

  5654. ///////////////////////////////////////////////////////////////////////////////////////

    5655. 

  5655. function getTimeStamp($date, $time){

    5656. 

  5656.     if (isDate($date)){

    5657. 

  5657.         $time = str_replace("h",":",$time);

    5658. 

  5658.         if (isTime24($time)){

    5659. 

  5659.             $timestamp = $date." ".$time;

    5660. 

  5660.         }

    5661. 

  5661.         else{

    5662. 

  5662.             $timestamp = $date;

    5663. 

  5663.         }

    5664. 

  5664.     }

    5665. 

  5665.     return($timestamp);

    5666. 

  5666. }

    5667. 

  5667. 

    5668. 

  5668. ///////////////////////////////////////////////////////////////////////////////////////

    5669. 

  5669. // getValFromQueryString($querystring, $var)

    5670. 

  5670. // Retourne la valeur d'une des variables qui se trouve dans le querystring.

    5671. 

  5671. //  IN:     $querystring: le querystring actuel (ex:"mode=display&pg=1&indx=alpha")

    5672. 

  5672. //          $var: variable dans le querystring qu'on veux la valeur (ex: "mode")

    5673. 

  5673. //  OUT:    (string) la valeur de la variable (ex: "display")

    5674. 

  5674. ///////////////////////////////////////////////////////////////////////////////////////

    5675. 

  5675. function getValFromQueryString($querystring, $var){

    5676. 

  5676.     $var=urlencode($var);

    5677. 

  5677.     ereg("(^".$var."=|&".$var."=)([^&|^=|^\?]*)", $querystring, $regs); //regs[2]=valeur de var

    5678. 

  5678.     return(urldecode($regs[2]));

    5679. 

  5679. }

    5680. 

  5680. 

    5681. 

  5681. ///////////////////////////////////////////////////////////////////////////////////////

    5682. 

  5682. // Retourne la nouvelle string avec les limites accept�es.

    5683. 

  5683. ///////////////////////////////////////////////////////////////////////////////////////

    5684. 

  5684. function getWrapString($sIn,$width,$sBreak){

    5685. 

  5685.     if (strlen($sIn)>$width){

    5686. 

  5686.         return(substr($sIn,0,$width-strlen($sBreak)).$sBreak);

    5687. 

  5687.     }

    5688. 

  5688.     else{

    5689. 

  5689.         return($sIn);

    5690. 

  5690.     } 

    5691. 

  5691. } 

    5692. 

  5692. 

    5693. 

  5693. ///////////////////////////////////////////////////////////////////////////////////////

    5694. 

  5694. // function isDate($sInput)

    5695. 

  5695. // Retourne true si le input re�u en param�tre est une date valide. Voici les formats

    5696. 

  5696. // accept�s: yyyy-mm-dd ou yyyy/mm/dd ou dd-mm-yyyy ou dd/mm/yyyy

    5697. 

  5697. //  IN:     $sInput: la date � v�rifier

    5698. 

  5698. //  OUT:    true: date  false: ??

    5699. 

  5699. ///////////////////////////////////////////////////////////////////////////////////////

    5700. 

  5700. function isDate($sInput){

    5701. 

  5701.     // yyyy-mm-dd ou yyyy/mm/dd

    5702. 

  5702.     if (ereg("(^[0-9]{4})"."(/|-)"."([0-9]{2})"."(/|-)"."([0-9]{2}$)", $sInput, $regs)){

    5703. 

  5703.         if (checkdate($regs[3], $regs[5], $regs[1])){

    5704. 

  5704.             return true;

    5705. 

  5705.         }

    5706. 

  5706.     }

    5707. 

  5707.     // dd-mm-yyyy ou dd/mm/yyyy

    5708. 

  5708.     elseif (ereg("(^[0-9]{2})"."(/|-)"."([0-9]{2})"."(/|-)"."([0-9]{4}$)", $sInput, $regs)){

    5709. 

  5709.         if (checkdate($regs[3], $regs[1], $regs[5])){

    5710. 

  5710.             return true;

    5711. 

  5711.         }

    5712. 

  5712.     }

    5713. 

  5713.     return false;

    5714. 

  5714. }

    5715. 

  5715. 

    5716. 

  5716. ///////////////////////////////////////////////////////////////////////////////////////

    5717. 

  5717. // function isEmail($sTemp)

    5718. 

  5718. // Retourne true si le input re�u en param�tre est un email.

    5719. 

  5719. ///////////////////////////////////////////////////////////////////////////////////////

    5720. 

  5720. function isEmail($sTemp){

    5721. 

  5721.     return (ereg('^[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+'. '@'. '[-!#$%&\'*+\\/0-9=?A-Z^_`a-z{|}~]+\.' . '[-!#$%&\'*+\\./0-9=?A-Z^_`a-z{|}~]+$', $sTemp));

    5722. 

  5722. }

    5723. 

  5723. 

    5724. 

  5724. ///////////////////////////////////////////////////////////////////////////////////////

    5725. 

  5725. // function isInscriptionOK($nbInscription, $nbInscriptionMax, $sesAnnule, $dSesLimite)

    5726. 

  5726. // Retourne true si les donn�es nous confirme que la session peut permettre l'inscription d'usager

    5727. 

  5727. //  IN:     $nbInscription          nombre d'inscription actuellement

    5728. 

  5728. //          $nbInscriptionMax       nombre max d'ins que la session peut prendre

    5729. 

  5729. //          $sesAnnule              't' si la session est annul�e

    5730. 

  5730. //          $dSesLimite             date limite pour inscription � la session

    5731. 

  5731. //  OUT:    true: inscription accept�e

    5732. 

  5732. ///////////////////////////////////////////////////////////////////////////////////////

    5733. 

  5733. function isInscriptionOK($nbInscription, $nbInscriptionMax, $sesAnnule, $dSesLimite){

    5734. 

  5734.     if ($nbInscription >= $nbInscriptionMax){

    5735. 

  5735.         //echo "(complet)";

    5736. 

  5736.         return false;

    5737. 

  5737.     }

    5738. 

  5738.     if ($sesAnnule == "t"){

    5739. 

  5739.         //echo "(annule)";

    5740. 

  5740.         return false;

    5741. 

  5741.     }

    5742. 

  5742.     if ( (isDate($dSesLimite)) && (strtotime(date("Y-m-d"))>strtotime($dSesLimite)) ){

    5743. 

  5743.         return false;

    5744. 

  5744.     }

    5745. 

  5745.     return true;

    5746. 

  5746. }

    5747. 

  5747. 

    5748. 

  5748. ///////////////////////////////////////////////////////////////////////////////////////

    5749. 

  5749. // function isTime24($sInput)

    5750. 

  5750. // Retourne true si le input re�u en param�tre est une heure valide. Voici les formats

    5751. 

  5751. // accept�s: hh:mm:ss hh:mm

    5752. 

  5752. //  IN:     $sInput: la date � v�rifier

    5753. 

  5753. //  OUT:    true: heure  false: ??

    5754. 

  5754. ///////////////////////////////////////////////////////////////////////////////////////

    5755. 

  5755. function isTime24($sInput){

    5756. 

  5756.     //hh:mm:ss

    5757. 

  5757.     if (ereg("(^[0-9]{1,2})"."(:)"."([0-9]{1,2})"."(:)"."([0-9]{1,2}$)", $sInput, $regs)){

    5758. 

  5758.         if (($regs[1]<=23) && ($regs[3]<=59) && ($regs[5]<=59)){

    5759. 

  5759.             return true;

    5760. 

  5760.         }

    5761. 

  5761.     }

    5762. 

  5762.     //hh:mm

    5763. 

  5763.     elseif (ereg("(^[0-9]{1,2})"."(:)"."([0-9]{1,2}$)", $sInput, $regs)){

    5764. 

  5764.         if (($regs[1]<=23) && ($regs[3]<=59)){

    5765. 

  5765.             return true;

    5766. 

  5766.         }

    5767. 

  5767.     }

    5768. 

  5768.     return false;

    5769. 

  5769. }

    5770. 

  5770. 

    5771. 

  5771. ///////////////////////////////////////////////////////////////////////////////////////

    5772. 

  5772. // function isTimeStamp($sInput)

    5773. 

  5773. // Retourne true si le input re�u en param�tre est un timestamp valide.

    5774. 

  5774. //  IN:     $sInput: timestamp � v�rifier

    5775. 

  5775. //  OUT:    true: timestamp  false: ??

    5776. 

  5776. ///////////////////////////////////////////////////////////////////////////////////////

    5777. 

  5777. function isTimeStamp($sInput){

    5778. 

  5778.     //vrai timestamp

    5779. 

  5779.     if (ereg("^([^[:space:]]*)"."[[:space:]]"."([^[:space:]]*)$", $sInput, $regs)){

    5780. 

  5780.         if ( (isDate($regs[1])) && (isTime24($regs[2])) ){

    5781. 

  5781.             return true;

    5782. 

  5782.         }

    5783. 

  5783.     }

    5784. 

  5784.     return false;

    5785. 

  5785. }

    5786. 

  5786. 

    5787. 

  5787. ///////////////////////////////////////////////////////////////////////////////////////

    5788. 

  5788. // printResultPage($hlink, $pg, $nbPage, $nbPageMax, $querystring)

    5789. 

  5789. // Retourne les page r�sultante apr�s une recherche.

    5790. 

  5790. //  IN:     $hlink: lien vers laquelle on va pointer (r�sultat)

    5791. 

  5791. //          $pg: num�ro de page actuelle (nombre)

    5792. 

  5792. //          $nbPage: nombre de page de r�sultat de recherche

    5793. 

  5793. //          $nbPageMax: maximum de page � afficher dans la barre de navigation

    5794. 

  5794. //          $querystring: querystring actuel, �a va nous permettre de l'ajouter au lien

    5795. 

  5795. //          $var: variable dans le querystring qu'on veux la valeur (ex: "mode")

    5796. 

  5796. ///////////////////////////////////////////////////////////////////////////////////////

    5797. 

  5797. function getResultPage( $hlink, $class, $htmlHeader, $no_page, $nbPage, $nbPageMax, $querystring ){

    5798. 

  5798. 	$querystring = getQueryStringUpdated( $querystring, "mode", "display");

    5799. 

  5799. 	$output = $htmlHeader;

    5800. 

  5800. 

    5801. 

  5801. 	// Les points de suspensions s'ajoutent quand on coupe la liste en quelque part

    5802. 

  5802. 	$add_suspension = true;

    5803. 

  5803. 

    5804. 

  5804. 	// S'il n'y a pas ass� de pages � afficher � gauche, on en transfert � droite

    5805. 

  5805. 	if( ( $no_page - ceil( $nbPageMax / 2 ) ) < 0 ){

    5806. 

  5806. 		$nb_gauche = ( $no_page % ceil( $nbPageMax / 2 ) ) - 1;

    5807. 

  5807. 		$nb_droite = $nbPageMax - ( $nb_gauche % $nbPageMax );

    5808. 

  5808. 	// La m�me chose mais � l'inverse

    5809. 

  5809. 	} elseif( ( $no_page + floor( $nbPageMax / 2 ) ) > $nbPage ){

    5810. 

  5810. 		$nb_droite = $no_page - $nbPage;

    5811. 

  5811. 		$nb_gauche = $nbPageMax - ( $nb_droite % $nbPageMax );

    5812. 

  5812. 	// Sinon, on divise le nombre plus ou moins �galement

    5813. 

  5813. 	} else {

    5814. 

  5814. 		$nb_gauche = ceil( $nbPageMax / 2 );

    5815. 

  5815. 		$nb_droite = floor( $nbPageMax / 2 );

    5816. 

  5816. 	}

    5817. 

  5817. 

    5818. 

  5818. 	// Si on est plus loin que la page #1, on affiche les fl�ches vers la gauche

    5819. 

  5819. 	if( $no_page > 1 ){

    5820. 

  5820. 		$output .= "<a href='" . $hlink . "?" . getQueryStringUpdated( $querystring, "pg", 1 ) . "'>|&lt;</a>";

    5821. 

  5821. 		$output .= "<a href='" . $hlink . "?" . getQueryStringUpdated( $querystring, "pg", $no_page - 1 ) . "'>&lt;&lt;</a>";

    5822. 

  5822. 	}

    5823. 

  5823. 

    5824. 

  5824. 	// Affiche de toutes les pages

    5825. 

  5825. 	for( $page = 1; $page <= $nbPage; $page++ ){

    5826. 

  5826. 		// Si la page est dans la zone que l'on veut afficher, on l'affiche

    5827. 

  5827. 		if( $page >= $no_page - $nb_gauche && $page <= $no_page + $nb_droite ){

    5828. 

  5828. 			if( $page <> $no_page ){

    5829. 

  5829. 				$output .= "<a href='" . $hlink . "?" . getQueryStringUpdated( $querystring, "pg", $page ) . "'>" . $page . "</a>";

    5830. 

  5830. 			} else {

    5831. 

  5831. 				$output .= "<a class='page_presente'>" . $page . "</a>";

    5832. 

  5832. 			}

    5833. 

  5833. 			$add_suspension = true;

    5834. 

  5834. 		// Sinon, on met des points de suspension

    5835. 

  5835. 		} else {

    5836. 

  5836. 			if( $add_suspension ) {

    5837. 

  5837. 				// Juste une fois

    5838. 

  5838. 				$add_suspension = false;

    5839. 

  5839. 				$output .= "<a>[...]</a>";

    5840. 

  5840. 			}

    5841. 

  5841. 		}

    5842. 

  5842. 	}

    5843. 

  5843. 

    5844. 

  5844. 	// Si on est moins loin que la derni�re page, on affiche les fl�ches vers la droite

    5845. 

  5845. 	if( $no_page < $nbPage ){

    5846. 

  5846. 		$output .= "<a href='" . $hlink . "?" . getQueryStringUpdated( $querystring, "pg", $no_page + 1 ) . "'>&gt;&gt;</a>";

    5847. 

  5847. 		$output .= "<a href='" . $hlink . "?" . getQueryStringUpdated( $querystring, "pg", $nbPage ) . "'>&gt;|</a>";

    5848. 

  5848. 	}

    5849. 

  5849. 

    5850. 

  5850. 	// Ajoute la classe s'il y a lieu

    5851. 

  5851. 	if( $output <> "" && $class <> "" ){

    5852. 

  5852. 		$output = "<span class='" . $class . "'>".$output."</span>";

    5853. 

  5853. 	}

    5854. 

  5854. 

    5855. 

  5855. 	return $output;

    5856. 

  5856. }

    5857. 

  5857. 

    5858. 

  5858. // Fait l'affichage de la fonction "getResultPage"

    5859. 

  5859. function printResultPage( $hlink, $class, $htmlHeader, $no_page, $nbPage, $nbPageMax, $querystring ){

    5860. 

  5860. 	echo getResultPage( $hlink, $class, $htmlHeader, $no_page, $nbPage, $nbPageMax, $querystring );

    5861. 

  5861. }

    5862. 

  5862. 

    5863. 

  5863. ///////////////////////////////////////////////////////////////////////////////////////

    5864. 

  5864. // printResultPageButton( $pg, $nbPage, $nbPageMax, $class=null )

    5865. 

  5865. // Affiche des boutons menant vers d'auters pages de la m�me recherche

    5866. 

  5866. //  IN:   $pg: num�ro de page actuelle (nombre)

    5867. 

  5867. //          $nbPage: nombre de page de r�sultat de recherche

    5868. 

  5868. //          $nbPageMax: maximum de page � afficher dans la barre de navigation

    5869. 

  5869. //          $class: param�tre inutile pour le moment, impl�ment� en vue d'ajouts �ventuels

    5870. 

  5870. ///////////////////////////////////////////////////////////////////////////////////////

    5871. 

  5871. function getResultPageButton( $no_page, $nbPage, $nbPageMax, $class = "" ){

    5872. 

  5872. 	$output = "";

    5873. 

  5873. 

    5874. 

  5874. 	// Les points de suspensions s'ajoutent quand on coupe la liste en quelque part

    5875. 

  5875. 	$add_suspension = true;

    5876. 

  5876. 	// Mani�re que les boutons devront �tre affich�s par sprintf

    5877. 

  5877. 	$gabarit_bouton = '<button type=\'submit\' name=\'pg\' value=\'%1$s\'%3$s><span>%2$s</span></button>';

    5878. 

  5878. 

    5879. 

  5879. 	// S'il n'y a pas ass� de pages � afficher � gauche, on en transfert � droite

    5880. 

  5880. 	if( ( $no_page - ceil( $nbPageMax / 2 ) ) < 0 ){

    5881. 

  5881. 		$nb_gauche = ( $no_page % ceil( $nbPageMax / 2 ) ) - 1;

    5882. 

  5882. 		$nb_droite = $nbPageMax - ( $nb_gauche % $nbPageMax );

    5883. 

  5883. 	// La m�me chose mais � l'inverse

    5884. 

  5884. 	} elseif( ( $no_page + floor( $nbPageMax / 2 ) ) > $nbPage ){

    5885. 

  5885. 		$nb_droite = $no_page - $nbPage;

    5886. 

  5886. 		$nb_gauche = $nbPageMax - ( $nb_droite % $nbPageMax );

    5887. 

  5887. 	// Sinon, on divise le nombre plus ou moins �galement

    5888. 

  5888. 	} else {

    5889. 

  5889. 		$nb_gauche = ceil( $nbPageMax / 2 );

    5890. 

  5890. 		$nb_droite = floor( $nbPageMax / 2 );

    5891. 

  5891. 	}

    5892. 

  5892. 

    5893. 

  5893. 	// Si on est plus loin que la page #1, on affiche les fl�ches vers la gauche

    5894. 

  5894. 	if( $no_page > 1 ){

    5895. 

  5895. 		$output .= sprintf( $gabarit_bouton, "1", "|&lt;", "" );

    5896. 

  5896. 		$output .= sprintf( $gabarit_bouton, ( $no_page - 1 ), "&lt;&lt;", "" );

    5897. 

  5897. 	}

    5898. 

  5898. 

    5899. 

  5899. 	// Affiche de toutes les pages

    5900. 

  5900. 	for( $page = 1; $page <= $nbPage; $page++ ){

    5901. 

  5901. 		// Si la page est dans la zone que l'on veut afficher, on l'affiche

    5902. 

  5902. 		if( $page >= $no_page - $nb_gauche && $page <= $no_page + $nb_droite ){

    5903. 

  5903. 			if( $page <> $no_page ){

    5904. 

  5904. 				$output .= sprintf( $gabarit_bouton, $page, $page, "" );

    5905. 

  5905. 			} else {

    5906. 

  5906. 				$output .= sprintf( $gabarit_bouton, $page, $page, " class='page_presente' disabled='disabled'" );

    5907. 

  5907. 			}

    5908. 

  5908. 			$add_suspension = true;

    5909. 

  5909. 		// Sinon, on met des points de suspension

    5910. 

  5910. 		} else {

    5911. 

  5911. 			if( $add_suspension ) {

    5912. 

  5912. 				// Juste une fois

    5913. 

  5913. 				$add_suspension = false;

    5914. 

  5914. 				$output .= sprintf( $gabarit_bouton, $no_page, "...", " disabled='disabled'" );

    5915. 

  5915. 			}

    5916. 

  5916. 		}

    5917. 

  5917. 	}

    5918. 

  5918. 

    5919. 

  5919. 	// Si on est moins loin que la derni�re page, on affiche les fl�ches vers la droite

    5920. 

  5920. 	if( $no_page < $nbPage ){

    5921. 

  5921. 		$output .= sprintf( $gabarit_bouton, ( $no_page + 1 ), "&gt;&gt;", "" );

    5922. 

  5922. 		$output .= sprintf( $gabarit_bouton, $nbPage, "&gt;|", "" );

    5923. 

  5923. 	}

    5924. 

  5924. 

    5925. 

  5925. 	// Ajoute la classe s'il y a lieu

    5926. 

  5926. 	if( $output <> "" && $class <> "" ){

    5927. 

  5927. 		$output = "<span class='" . $class . "'>" . $output . "</span>";

    5928. 

  5928. 	}

    5929. 

  5929. 

    5930. 

  5930. 	return $output;

    5931. 

  5931. }

    5932. 

  5932. 

    5933. 

  5933. // Fait l'affichage de la fonction "getResultPageButton"

    5934. 

  5934. function printResultPageButton( $pg, $nbPage, $nbPageMax, $class = "" ){

    5935. 

  5935. 	echo getResultPageButton( $pg, $nbPage, $nbPageMax, $class );

    5936. 

  5936. }

    5937. 

  5937. 

    5938. 

  5938. ///////////////////////////////////////////////////////////////////////////////////////

    5939. 

  5939. // printResultSum($pg, $pageSize, $nbRecordTotal)

    5940. 

  5940. // Affiche les pages r�sultantes apr�s une recherche.

    5941. 

  5941. //  IN:     $hlink: lien vers laquelle on va pointer (r�sultat)

    5942. 

  5942. //          $pg: num�ro de page actuelle (nombre)

    5943. 

  5943. //          $nbPage: nombre de page de r�sultat de recherche

    5944. 

  5944. //          $nbPageMax: maximum de page � afficher dans la barre de navigation

    5945. 

  5945. //          $querystring: querystring actuel, �a va nous permettre de l'ajouter au lien

    5946. 

  5946. //          $var: variable dans le querystring qu'on veux la valeur (ex: "mode")

    5947. 

  5947. ///////////////////////////////////////////////////////////////////////////////////////

    5948. 

  5948. function getResultSum( $pg, $pageSize, $nbRecordTotal, $str_affichage = "" ){

    5949. 

  5949. 	if ( $str_affichage == "" ){ $str_affichage = _("resultats %s a %s sur %s"); }

    5950. 

  5950. 	if ( !is_numeric( $pg ) ){ $pg = 1; }

    5951. 

  5951. 	$premier_affiche = ( ( $pg - 1 ) * $pageSize + 1 );

    5952. 

  5952. 	$dernier_affiche = min( ( $pg * $pageSize ), $nbRecordTotal );

    5953. 

  5953. 

    5954. 

  5954. 	return sprintf( $str_affichage, $premier_affiche, $dernier_affiche, $nbRecordTotal );

    5955. 

  5955. }

    5956. 

  5956. 

    5957. 

  5957. function printResultSum( $pg, $pageSize, $nbRecordTotal ){

    5958. 

  5958. 	echo getResultSum( $pg, $pageSize, $nbRecordTotal );

    5959. 

  5959. }

    5960. 

  5960. 

    5961. 

  5961. //getVersionBD

    5962. 

  5962. //retourne la version actuelle de la base de donn�es sous forme de chaine de caract�res

    5963. 

  5963. //OUT : Version actuelle de la BD ou false si un probl�me est rencontr� lors de la v�rification

    5964. 

  5964. //NOTE : Le formulaire appelant doit, au pr�alable, s'�tre connect� � la base de donn�es

    5965. 

  5965. function getVersionBD(){

    5966. 

  5966.   $version = "";

    5967. 

  5967.   $sql = "SELECT no_version from CVS where date_version=(SELECT max(date_version) from cvs);";

    5968. 

  5968.   if ( $result = pg_query($sql) ){

    5969. 

  5969.     $version = pg_fetch_result($result,0,0);

    5970. 

  5970.   }else{

    5971. 

  5971.     $version = false;

    5972. 

  5972.   }

    5973. 

  5973.   return $version;

    5974. 

  5974. }

    5975. 

  5975. 

    5976. 

  5976. ///////////////////////////////////////////////////////////////////////////////////////

    5977. 

  5977. // getSqlStmtModifiedEnvoyerCourrier($origstmt)

    5978. 

  5978. // Retourne une requ�te SQL comprenant seulement des usr_id unique pour envoyer

    5979. 

  5979. // des courriels. N�cessaire pour �viter les duplicatas. Utilise aussi usr_nom et

    5980. 

  5980. // usr_prenom pour les classer en ordre alphab�tique.

    5981. 

  5981. //  IN:     $origstmt: requ�te originale

    5982. 

  5982. // OUT:     $modstmt: requ�te modifi�e

    5983. 

  5983. ///////////////////////////////////////////////////////////////////////////////////////

    5984. 

  5984. function getSQLStmtModifiedEnvoyerCourrier($origstmt){

    5985. 

  5985.     $modstmt="SELECT usr_id, usr_nom, usr_prenom FROM (";

    5986. 

  5986.     $modstmt.=$origstmt;

    5987. 

  5987.     $modstmt.=") AS table_env_cour GROUP BY usr_id, usr_nom, usr_prenom ORDER BY usr_nom ASC, usr_prenom ASC";

    5988. 

  5988.     return $modstmt;

    5989. 

  5989. }

    5990. 

  5990. 

    5991. 

  5991. ///////////////////////////////////////////////////////////////////////////////////////

    5992. 

  5992. // function isSessionOpen()

    5993. 

  5993. // retourne true si une session de fortic est en cours

    5994. 

  5994. //  OUT:    TRUE si session en cours

    5995. 

  5995. ///////////////////////////////////////////////////////////////////////////////////////

    5996. 

  5996. function isSessionOpen(){

    5997. 

  5997.     global $_SESSION;

    5998. 

  5998.     if (is_numeric($_SESSION["FORTIC_nLoggedUsrID"])){

    5999. 

  5999.         return true;

    6000. 

  6000.     }

    6001. 

  6001.     else{

    6002. 

  6002.         return false;

    6003. 

  6003.     }

    6004. 

  6004. }

    6005. 

  6005. 

    6006. 

  6006. ///////////////////////////////////////////////////////////////////////////////////////

    6007. 

  6007. // sessionLogin($nUsrID, $sApplicationKey, $nSessionExpire, $sLogin, $sUsagerTypeIDList, $sSecIDList)

    6008. 

  6008. // m�thode appell�e pour mettre � jour les variables de session lorsque l'usager se log

    6009. 

  6009. //  IN:     $nUsrID: usr_id de l'usager logg�

    6010. 

  6010. //          $sApplicationKey: cl� d'application de fortic (pour �viter que 2 fortic roule en m�me temps)

    6011. 

  6011. //          $sLogin: login du user logg�

    6012. 

  6012. //          $sNom: nom de famille du user logg�

    6013. 

  6013. //          $sPrenom: pr�nom du user logg�

    6014. 

  6014. //          $sUsagerTypeIDList: liste des type d'usager assign� au user

    6015. 

  6015. //          $sSecIDList: liste des id de s�curit� assossi� au type d'usager du user

    6016. 

  6016. ///////////////////////////////////////////////////////////////////////////////////////

    6017. 

  6017. function sessionLogin($nUsrID, $sApplicationKey, $sLogin, $sNom, $sPrenom, $sUsagerTypeIDList, $sSecIDList){

    6018. 

  6018.     global $_SESSION;

    6019. 

  6019.     $_SESSION["FORTIC_nLoggedUsrID"] = $nUsrID;

    6020. 

  6020.     $_SESSION["FORTIC_sApplicationKey"] = $sApplicationKey;

    6021. 

  6021.     $_SESSION["FORTIC_sLogin"] = $sLogin;

    6022. 

  6022.     $_SESSION["FORTIC_sNom"] = $sNom;

    6023. 

  6023.     $_SESSION["FORTIC_sPrenom"] = $sPrenom;

    6024. 

  6024.     $_SESSION["FORTIC_sUsagerTypeIDList"] = $sUsagerTypeIDList;

    6025. 

  6025.     $_SESSION["FORTIC_sSecIDList"] = $sSecIDList;

    6026. 

  6026.     $_SESSION["FORTIC_sCartSesIDList"] = "";

    6027. 

  6027. }

    6028. 

  6028. 

    6029. 

  6029. ///////////////////////////////////////////////////////////////////////////////////////

    6030. 

  6030. // sessionLogout()

    6031. 

  6031. // m�thode appell�e pour lib�rer les variables de session lorsque l'usager se delog

    6032. 

  6032. ///////////////////////////////////////////////////////////////////////////////////////

    6033. 

  6033. function sessionLogout(){

    6034. 

  6034.     global $_SESSION;

    6035. 

  6035.     unset($_SESSION["FORTIC_nLoggedUsrID"]);

    6036. 

  6036.     unset($_SESSION["FORTIC_sApplicationKey"]);

    6037. 

  6037.     unset($_SESSION["FORTIC_sLogin"]);

    6038. 

  6038.     unset($_SESSION["FORTIC_sNom"] );

    6039. 

  6039.     unset($_SESSION["FORTIC_sPrenom"]);

    6040. 

  6040.     unset($_SESSION["FORTIC_sUsagerTypeIDList"]);

    6041. 

  6041.     unset($_SESSION["FORTIC_sSecIDList"]);

    6042. 

  6042.     unset($_SESSION["FORTIC_sCartSesIDList"]);

    6043. 

  6043.     session_unset();

    6044. 

  6044.     session_destroy();

    6045. 

  6045. }

    6046. 

  6046. 

    6047. 

  6047. ///////////////////////////////////////////////////////////////////////////////////////

    6048. 

  6048. // Retourne la requete SQL necessaire pour faire un SELECT

    6049. 

  6049. ///////////////////////////////////////////////////////////////////////////////////////

    6050. 

  6050. function getSQLStmtReqAtelierDetail( $atl_id ){

    6051. 

  6051. 	$SQLStmt = "Select a.atl_atelier, a.atl_description, a.atl_url, a.atl_prealable, a.atl_condition, a.atl_calendrier, a.atl_fraistypique,

    6052. 

  6052. 				a.atl_note, a.atl_commentaire, a.atl_alacartedisponible, 'NON IMPL�MENT�', usager.usr_id, usager.usr_nom, usager.usr_prenom,

    6053. 

  6053. 				usager.usr_email, usager.usr_telRejoindre, a.atl_valide, TO_CHAR(a.dateUpdate, 'YYYY-MM-DD HH24:MI:SS') As dateUpdate,

    6054. 

  6054. 				TO_CHAR(a.dateCreation, 'YYYY-MM-DD HH24:MI:SS') As dateCreation

    6055. 

  6055. 			From atelier a

    6056. 

  6056. 			Left Join usager On a.usr_id = usager.usr_id

    6057. 

  6057. 			Where a.atl_id != '0'";

    6058. 

  6058. 

    6059. 

  6059. 	if( $atl_id != 0 ){

    6060. 

  6060. 		$SQLStmt.=" And a.atl_id = '" . $atl_id . "'";

    6061. 

  6061. 	}

    6062. 

  6062. 

    6063. 

  6063. 	return $SQLStmt;

    6064. 

  6064. }

    6065. 

  6065.  

    6066. 

  6066. 

    6067. 

  6067. ///////////////////////////////////////////////////////////////////////////////////////

    6068. 

  6068. // Retourne la requete SQL necessaire pour faire un SELECT

    6069. 

  6069. ///////////////////////////////////////////////////////////////////////////////////////

    6070. 

  6070. function getSQLStmtReqAtelierOffreService( $prj_id = 0 ){

    6071. 

  6071. 	return "Select distinct a.atl_id, a.atl_atelier, substr( a.atl_atelier, 0, 75 ) as atl_short

    6072. 

  6072. 				From atelier a

    6073. 

  6073. 				Inner Join session s On s.atl_id = a.atl_id

    6074. 

  6074. 				Inner Join projet p On p.prj_id = s.prj_id

    6075. 

  6075. 				Inner Join seance se On s.ses_id = se.ses_id

    6076. 

  6076. 				Where a.atl_valide = 't' And p.pt_id = '1' And p.prj_id = '" . $prj_id . "' And se.sea_datefin > Now()

    6077. 

  6077. 				Order by atl_atelier";

    6078. 

  6078. }

    6079. 

  6079. 

    6080. 

  6080. function getSQLStmtReqAtelierOffreServiceAdminLieu( $prj_id = 0 ){

    6081. 

  6081. 	// Pour �viter que le titre de l'atelier ne sorte de l'en-t�te du catalogue, on en retourne aussi une version de 75 caract�res

    6082. 

  6082. 	return "Select distinct a.atl_id, a.atl_atelier, substr( a.atl_atelier, 0, 75 ) as atl_short

    6083. 

  6083. 			From atelier a

    6084. 

  6084. 			Left join projet_atelier pa On pa.atl_id = a.atl_id

    6085. 

  6085. 			Left Join projet p On p.prj_id = pa.prj_id

    6086. 

  6086. 			Where a.atl_valide = 't' And p.pt_id = '1' And a.atl_alacartedisponible Is True And p.prj_id = '" . $prj_id . "'

    6087. 

  6087. 			Group By atl_atelier, a.atl_id

    6088. 

  6088. 			Order By atl_atelier";

    6089. 

  6089. }

    6090. 

  6090. 

    6091. 

  6091. 

    6092. 

  6092. ///////////////////////////////////////////////////////////////////////////////////////

    6093. 

  6093. // Retourne les projets

    6094. 

  6094. // Ajout� par Olivier Sackhouse le 7 janvier 2008

    6095. 

  6095. ///////////////////////////////////////////////////////////////////////////////////////

    6096. 

  6096. function getSQLStmtReqProjOffreServ($prj_id = 0){

    6097. 

  6097. 	$SQLStmt = "Select projet.prj_id, projet.prj_projet

    6098. 

  6098. 			From projet

    6099. 

  6099. 			Where projet.pt_id = '1' And projet.prj_valide = '1' ";

    6100. 

  6100. 

    6101. 

  6101. 	if( $prj_id != 0 ){

    6102. 

  6102. 		$SQLStmt .= "And projet.prj_id = '" . $prj_id . "' ";

    6103. 

  6103. 	} 

    6104. 

  6104. 

    6105. 

  6105. 	$SQLStmt .= "Order By projet.prj_projet"; 

    6106. 

  6106. 

    6107. 

  6107. 	return $SQLStmt;

    6108. 

  6108. }

    6109. 

  6109. 

    6110. 

  6110. 

    6111. 

  6111. function getSQLStmtReqSessionsOffreServices( $mot, $motlnk, $prj_id, $atl_id, $cla_id, $exp_id, $cli_id, $ses_annule,

    6112. 

  6112. 		$nbjourstart, $datelimiteOK, $nbinsOK, $valide, $arrFicheId, $indx ){

    6113. 

  6113. 	$SQLStmt = "Select ses.ses_id, pro.prj_id, prj_projet, pro.prj_valide, ate.atl_id,

    6114. 

  6114. 				ate.atl_atelier, ate.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbMin,

    6115. 

  6115. 				ses_nbMax, ses_regionnal, ses_annule, ses_annuleraison, ses_valide, COUNT( sea.sea_id ) As nbSeance,

    6116. 

  6116. 				get_nbInscriptionSession( ses.ses_id ) As nbInscription, TO_CHAR( MIN( sea_dateDebut ), 'YYYY-MM-DD HH24:MI:SS' ) As dSeaDebMin,

    6117. 

  6117. 				TO_CHAR( MAX( sea_dateDebut ), 'YYYY-MM-DD HH24:MI:SS' ) As dSeaDebMax, get_nbInscriptionSessionAValider( ses.ses_id ),

    6118. 

  6118. 				ses_coutParUsager, ses_commentaire, 'NON IMPL�MENT�', 'NON IMPL�MENT�', get_nbInscriptionSession( ses.ses_id ) As nbInscription

    6119. 

  6119. 			From session ses

    6120. 

  6120. 			Left Join seance sea On ses.ses_id = sea.ses_id

    6121. 

  6121. 			Left Join projet pro On ses.prj_id = pro.prj_id

    6122. 

  6122. 			Left Join projetType prt On pro.pt_id = prt.pt_id

    6123. 

  6123. 			Left Join atelier ate On ses.atl_id = ate.atl_id";

    6124. 

  6124. 

    6125. 

  6125. 	$where = "";

    6126. 

  6126. 

    6127. 

  6127. 	// La recherche peut �tre faite pour chaque mot ou pour le groupe au complet

    6128. 

  6128. 	if( $motlnk != "and" && $motlnk != "or" ){

    6129. 

  6129. 		$motlnk = "and"; //valeur par defaut : securite

    6130. 

  6130. 	}

    6131. 

  6131. 

    6132. 

  6132. 	// Cr�� une table des mots recherch�s

    6133. 

  6133. 	$arrMot = getArrayFromStringMot( $mot );

    6134. 

  6134. 	$nb_mots = count( $arrMot );

    6135. 

  6135. 	if( $nb_mots > 0 ){

    6136. 

  6136. 		$where .= " ( ";

    6137. 

  6137. 		for( $i = 0; $i < $nb_mots; $i++ ){

    6138. 

  6138. 			// V�rifie si le mot est dans la colonne 'ATL_ATELIER'

    6139. 

  6139. 			$where .= accentInsensitiveLike( "atl_atelier", $arrMot[ $i ] );

    6140. 

  6140. 			// Ou, v�rifie si le mot est dans la colonne 'ATL_DESCRIPTION'

    6141. 

  6141. 			$where .= " OR " . accentInsensitiveLike( "atl_description", $arrMot[ $i ] );

    6142. 

  6142. 			// Ou, v�rifie si le mot est dans la colonne 'SES_CODE'

    6143. 

  6143. 			$where .= " OR " . accentInsensitiveLike( "ses_code", $arrMot[ $i ] );

    6144. 

  6144. 

    6145. 

  6145. 			// Ajoute le bon mot selon la requ�te de l'usager

    6146. 

  6146. 			if( $i < ( $nb_mots - 1 ) ){

    6147. 

  6147. 				$where .= ") " . $motlnk . " ("; //OR ou AND

    6148. 

  6148. 			}

    6149. 

  6149. 		}

    6150. 

  6150. 		$where .= " ) ";

    6151. 

  6151. 	}

    6152. 

  6152. 

    6153. 

  6153. 	if( is_numeric( $prj_id ) ){

    6154. 

  6154. 		if( $where != "" ){

    6155. 

  6155. 			$where .= " AND ";

    6156. 

  6156. 		}

    6157. 

  6157. 		$where .= " ses.prj_id = '" . $prj_id . "'";

    6158. 

  6158. 	}

    6159. 

  6159. 

    6160. 

  6160. 	if( is_numeric( $atl_id ) ){

    6161. 

  6161. 		if( $where != "" ){

    6162. 

  6162. 			$where .= " AND ";

    6163. 

  6163. 		}

    6164. 

  6164. 		$where .= " ses.atl_id = '" . $atl_id . "'";

    6165. 

  6165. 	}

    6166. 

  6166. 

    6167. 

  6167. 	if( is_numeric( $cla_id ) ){

    6168. 

  6168. 		if( $where != "" ){

    6169. 

  6169. 			$where .= " AND ";

    6170. 

  6170. 		}

    6171. 

  6171. 		$where .= " ses.atl_id In ( Select atl_id From atelier_classe Where cla_id = '".$cla_id . "' )";

    6172. 

  6172. 	}

    6173. 

  6173. 

    6174. 

  6174. 	if( is_numeric( $exp_id ) ){

    6175. 

  6175. 		if( $where != "" ){

    6176. 

  6176. 			$where .= " AND ";

    6177. 

  6177. 		}

    6178. 

  6178. 		$where .= " ses.atl_id In ( Select atl_id From atelier_expertise Where exp_id = '".$exp_id . "' )";

    6179. 

  6179. 	}

    6180. 

  6180. 

    6181. 

  6181. 	if( is_numeric( $cli_id ) ){

    6182. 

  6182. 		if( $where != "" ){

    6183. 

  6183. 			$where .= " AND ";

    6184. 

  6184. 		}

    6185. 

  6185. 		$where .= " ses.atl_id In ( Select atl_id From atelier_clientele Where cli_id = '".$cli_id . "' )";

    6186. 

  6186. 	}

    6187. 

  6187. 

    6188. 

  6188. 	if( $ses_annule != "" ){

    6189. 

  6189. 		if( $where != "" ){

    6190. 

  6190. 			$where .= " AND ";

    6191. 

  6191. 		}

    6192. 

  6192. 		if( to_lower( $ses_annule ) == "t" ){

    6193. 

  6193. 			$where.=" ses_annule = 't'";

    6194. 

  6194. 		} else {

    6195. 

  6195. 			$where.=" ses_annule = 'f'";

    6196. 

  6196. 		}

    6197. 

  6197. 	}

    6198. 

  6198. 

    6199. 

  6199. 	if( $datelimiteOK != "" ){

    6200. 

  6200. 		if( $where != "" ){

    6201. 

  6201. 			$where .= " AND ";

    6202. 

  6202. 		}

    6203. 

  6203. 		$where .= " sea.ses_id = ses.ses_id And (sea.sea_datefin > Now() OR sea.sea_datefin is null)";

    6204. 

  6204. 	}

    6205. 

  6205. 

    6206. 

  6206. 	if( $valide != "" ){

    6207. 

  6207. 		if( $where != "" ){

    6208. 

  6208. 			$where .= " AND ";

    6209. 

  6209. 		}

    6210. 

  6210. 		if( to_lower( $valide ) == "t" ){

    6211. 

  6211. 			$where.=" prj_valide = 't' And atl_valide = 't' And ses_valide = 't'";

    6212. 

  6212. 		} else {

    6213. 

  6213. 			$where.=" prj_valide = 'f' And atl_valide = 'f' And ses_valide = 'f'";

    6214. 

  6214. 		}

    6215. 

  6215. 	}

    6216. 

  6216. 

    6217. 

  6217. 	if( count( $arrFicheId ) > 0 ){

    6218. 

  6218. 		if( $where != "" ){

    6219. 

  6219. 			$where .= " AND ";

    6220. 

  6220. 		}

    6221. 

  6221. 		$where .= " ( ses.ses_id <> ses.ses_id";

    6222. 

  6222. 		for( $i=0; $i < count( $arrFicheId ); $i++ ){

    6223. 

  6223. 			if( is_numeric( $arrFicheId[ $i ] ) ){

    6224. 

  6224. 				$where .= " Or ses.ses_id = '" . $arrFicheId[ $i ] . "'";

    6225. 

  6225. 			}

    6226. 

  6226. 		}

    6227. 

  6227. 		$where .= " )";

    6228. 

  6228. 	}

    6229. 

  6229. 

    6230. 

  6230. 	if( $where != "" ){

    6231. 

  6231. 		$where = " WHERE " . $where;

    6232. 

  6232. 	}

    6233. 

  6233. 	$SQLStmt .= $where . " GROUP BY ses.ses_id, pro.prj_id, pro.prj_projet, pro.prj_valide, ate.atl_id, ate.atl_atelier,

    6234. 

  6234. 			ate.atl_valide, ses_code, ses_notemini, ses_datelimite, ses_nbmin, ses_nbmax, ses_regionnal, ses_annule, ses_annuleraison,

    6235. 

  6235. 			ses_valide, ses_coutParUsager, ses_commentaire";

    6236. 

  6236. 

    6237. 

  6237. 	if( is_numeric( $nbjourstart ) || $nbinsOK != "" ){

    6238. 

  6238. 	$SQLStmt .= " Having true"; // Malheureusement, cette clause ne change rien mais elle rend les prochaines lignes plus facile � b�tire

    6239. 

  6239. 		if( is_numeric( $nbjourstart ) ){

    6240. 

  6240. 			$SQLStmt .= " And prochaineseance( ses.ses_id ) BETWEEN CURRENT_DATE And CURRENT_DATE + '" . $nbjourstart . "'";

    6241. 

  6241. 		}

    6242. 

  6242. 		if ( $nbinsOK != "" ){

    6243. 

  6243. 			if( strtolwer( $nbinsOK ) == "t" ){

    6244. 

  6244. 				$SQLStmt .= " And get_nbInscriptionSession( ses.ses_id ) < ses_nbMax";

    6245. 

  6245. 			} else {

    6246. 

  6246. 				$SQLStmt .= " And get_nbInscriptionSession( ses.ses_id ) >= ses_nbMax";

    6247. 

  6247. 			}

    6248. 

  6248. 		}

    6249. 

  6249. 	}

    6250. 

  6250. 

    6251. 

  6251. 	// Cast $INDX en string car comparer 0 avec une string retourne toujours vrai

    6252. 

  6252. 	switch( ( string ) $indx ){

    6253. 

  6253. 		case "sessiona" :

    6254. 

  6254. 			$SQLStmt .= " ORDER BY ses_code ASC";

    6255. 

  6255. 			break;

    6256. 

  6256. 		case "sessiond" :

    6257. 

  6257. 			$SQLStmt .= " ORDER BY ses_code DESC";

    6258. 

  6258. 			break;

    6259. 

  6259. 		case "descriptiona" :

    6260. 

  6260. 			$SQLStmt .= " ORDER BY atl_atelier ASC";

    6261. 

  6261. 			break;

    6262. 

  6262. 		case "descriptiond" :

    6263. 

  6263. 			$SQLStmt .= " ORDER BY atl_atelier DESC";

    6264. 

  6264. 			break;

    6265. 

  6265. 		case "dateseaa" :

    6266. 

  6266. 			 $SQLStmt .= " ORDER BY dSeaDebMin ASC";

    6267. 

  6267. 			break;

    6268. 

  6268. 		case "datesead" :

    6269. 

  6269. 			$SQLStmt .= " ORDER BY dSeaDebMin DESC";

    6270. 

  6270. 			break;

    6271. 

  6271. 		case "datelima" :

    6272. 

  6272. 			$SQLStmt .= " ORDER BY ses_datelimite ASC";

    6273. 

  6273. 			break;

    6274. 

  6274. 		case "datelimd" :

    6275. 

  6275. 			$SQLStmt .= " ORDER BY ses_datelimite DESC";

    6276. 

  6276. 			break;

    6277. 

  6277. 		case "nbinscriptiona" :

    6278. 

  6278. 			$SQLStmt .= " ORDER BY nbInscription ASC";

    6279. 

  6279. 			break;

    6280. 

  6280. 		case "nbinscriptiond" :

    6281. 

  6281. 			$SQLStmt .= " ORDER BY nbInscription DESC";

    6282. 

  6282. 			break;

    6283. 

  6283. 		case "couta" :

    6284. 

  6284. 			$SQLStmt .= " ORDER BY ses_coutParUsager ASC";

    6285. 

  6285. 			break;

    6286. 

  6286. 		case "coutd" :

    6287. 

  6287. 			$SQLStmt .= " ORDER BY ses_coutParUsager DESC";

    6288. 

  6288. 			break;

    6289. 

  6289. 		default :

    6290. 

  6290. 			break;

    6291. 

  6291. 	}

    6292. 

  6292. 

    6293. 

  6293. 	return $SQLStmt;

    6294. 

  6294. }

    6295. 

  6295. 

    6296. 

  6296. function getSQLStmtReqProjOffreServFull(){

    6297. 

  6297. 	return "Select distinct p.prj_id, p.prj_projet, a.atl_id, a.atl_atelier, a.datecreation

    6298. 

  6298. 			From atelier a

    6299. 

  6299. 			Inner Join session s On s.atl_id = a.atl_id

    6300. 

  6300. 			Inner join projet_atelier pa On pa.atl_id = a.atl_id

    6301. 

  6301. 			Inner Join projet p On p.prj_id = pa.prj_id

    6302. 

  6302. 			Inner Join seance se On s.ses_id = se.ses_id

    6303. 

  6303. 			Where a.atl_valide And s.ses_annule Is False And s.ses_valide Is True And p.pt_id = 1 And ((se.sea_datefin > Now()

    6304. 

  6304. 				And se.sea_datedebut > Now()) or (se.sea_datefin is null And se.sea_datedebut is null)) And se.sea_valide Is True

    6305. 

  6305. 				AND (p.prj_dateFin >= CURRENT_DATE OR p.prj_dateFin IS NULL) AND p.prj_valide='t'

    6306. 

  6306. 			Group By p.prj_id, p.prj_projet, a.atl_atelier, a.atl_id, a.datecreation

    6307. 

  6307. 			Order By p.prj_projet, a.atl_atelier";

    6308. 

  6308. }

    6309. 

  6309. 

    6310. 

  6310. function getSQLStmtReqProjOffreServAdminLieu(){

    6311. 

  6311. 	return "Select distinct p.prj_id, p.prj_projet, a.atl_id, a.atl_atelier, a.datecreation

    6312. 

  6312. 			From atelier a

    6313. 

  6313. 			Inner join projet_atelier pa On pa.atl_id = a.atl_id

    6314. 

  6314. 			Inner Join projet p On p.prj_id = pa.prj_id

    6315. 

  6315. 			Where a.atl_valide And p.pt_id = 1 And a.atl_alacartedisponible Is True

    6316. 

  6316. 			Group By p.prj_id, p.prj_projet, a.atl_atelier, a.atl_id, a.datecreation

    6317. 

  6317. 			Order By p.prj_projet, a.atl_atelier";

    6318. 

  6318. }

    6319. 

  6319. 

    6320. 

  6320. 

    6321. 

  6321. ///////////////////////////////////////////////////////////////////////////////////////

    6322. 

  6322. // Retourne la requete SQL necessaire pour les offre de services

    6323. 

  6323. // Ajout� par Olivier Sackhouse le 7 janvier 2008

    6324. 

  6324. ///////////////////////////////////////////////////////////////////////////////////////

    6325. 

  6325. function getSQLStmtReqOffreServByProjId($proj_id){

    6326. 

  6326. 	$SQLStmt = "";

    6327. 

  6327. 

    6328. 

  6328. 	if( is_numeric( $proj_id ) && $proj_id != 0 ){

    6329. 

  6329. 		$SQLStmt = "Select ses_code, atl.atl_atelier, sum( sea_duree ), ses.ses_coutparusager 

    6330. 

  6330. 				From session As ses

    6331. 

  6331. 				Inner Join atelier atl On ses.atl_id = atl.atl_id

    6332. 

  6332. 				Inner Join seance sea On sea.ses_id = ses.ses_id

    6333. 

  6333. 				Where  ses_datelimite < now() And ses.prj_id = '" . $proj_id . "'

    6334. 

  6334. 				Group by ses_code, atl.atl_atelier, ses.ses_coutparusager";

    6335. 

  6335. 	}

    6336. 

  6336. 

    6337. 

  6337. 	return $SQLStmt;

    6338. 

  6338. }

    6339. 

  6339. 

    6340. 

  6340. /**

    6341. 

  6341. * Ajoute la fonction array_intersect_key si elle n'existe pas deja (PHP < 5.1)

    6342. 

  6342. *

    6343. 

  6343. * @param $isec Le tableau contenant les cl�s ma�tres � v�rifier.

    6344. 

  6344. * @param $keys Un tableau contenant les cl�s � comparer.

    6345. 

  6345. * @param ... Un tableau contenant les cl�s � comparer.

    6346. 

  6346. * @return Tableau contenant toutes les entr�es du tableau $isec qui ont des cl�s pr�sentes dans tous les arguments.

    6347. 

  6347. * @author Rod Byrnes -> http://www.php.net/manual/fr/function.array-intersect-key.php#74956

    6348. 

  6348. */

    6349. 

  6349. if( !function_exists( 'array_intersect_key' ) ) {

    6350. 

  6350. 	function array_intersect_key( $isec, $keys ){

    6351. 

  6351. 		$argc = func_num_args();

    6352. 

  6352. 		if( $argc > 2 ) {

    6353. 

  6353. 			for( $i = 1; !empty( $isec ) && $i < $argc; $i++ ) {

    6354. 

  6354. 				$arr = func_get_arg($i);

    6355. 

  6355. 				foreach( array_keys( $isec ) as $key ) {

    6356. 

  6356. 					if( !isset( $arr[ $key ] ) ) {

    6357. 

  6357. 						unset( $isec[ $key ] );

    6358. 

  6358. 					}

    6359. 

  6359. 				}

    6360. 

  6360. 			}

    6361. 

  6361. 			return $isec;

    6362. 

  6362. 		} else {

    6363. 

  6363. 			$res = array();

    6364. 

  6364. 			foreach( array_keys( $isec ) as $key ){

    6365. 

  6365. 				if( isset( $keys[$key] ) ){

    6366. 

  6366. 						$res[$key] = $isec[$key];

    6367. 

  6367. 				}

    6368. 

  6368. 			}

    6369. 

  6369. 			return $res;

    6370. 

  6370. 		}

    6371. 

  6371. 	}

    6372. 

  6372. }

    6373. 

  6373. 

    6374. 

  6374. function tranlateUsagerTypes( &$arrIDTypes, &$arrNomTypes ){

    6375. 

  6375. 	//Mettre les bons noms de type d'usager dans l'array $arrNomTypes

    6376. 

  6376. 	//(Requis pour permettre que les noms des types d'usagers puissent �tre affich�s dans plus d'une langue

    6377. 

  6377. 	for( $index = 0; $index < count( $arrIDTypes ); $index++ ){

    6378. 

  6378. 		switch ( $arrIDTypes[$index] ){

    6379. 

  6379. 			case 1:

    6380. 

  6380. 				$arrNomTypes[ $index ] = _( "Usager" );

    6381. 

  6381. 				break;

    6382. 

  6382. 			case 2:

    6383. 

  6383. 				$arrNomTypes[ $index ] = _( "Technicien" );

    6384. 

  6384. 				break;

    6385. 

  6385. 			case 3:

    6386. 

  6386. 				$arrNomTypes[ $index ] = _( "Animateur(trice)" );

    6387. 

  6387. 				break;

    6388. 

  6388. 			case 4:

    6389. 

  6389. 				$arrNomTypes[ $index ] = _( "Administrateur(trice) - Lieu" );

    6390. 

  6390. 				break;

    6391. 

  6391. 			case 6:

    6392. 

  6392. 				$arrNomTypes[ $index ] = _( "Administrateur(trice) - General" );

    6393. 

  6393. 				break;

    6394. 

  6394. 			case 7:

    6395. 

  6395. 				$arrNomTypes[ $index ] = _( "Superadministrateur(trice)" );

    6396. 

  6396. 				break;

    6397. 

  6397. 			case 8:

    6398. 

  6398. 				$arrNomTypes[ $index ] = _( "Administrateur(trice) - Projet" );

    6399. 

  6399. 				break;

    6400. 

  6400. 		}

    6401. 

  6401. 	}

    6402. 

  6402. }

    6403. 

  6403. 

    6404. 

  6404. //Retourne true si les fichiers gettext (.mo) correspondant � la string Locale re�ue en param�tre sont disponibles

    6405. 

  6405. function isSupportedLocale( $locale ){

    6406. 

  6406. 	return array_key_exists( $locale, getHandledLocalesList() );

    6407. 

  6407. }

    6408. 

  6408. 

    6409. 

  6409. function getHandledLocalesList(){

    6410. 

  6410. 	//Trouver le bon chemin ( relatif ) qui permet d'acc�der � la ressource gettext

    6411. 

  6411. 	global $cfgMODir;

    6412. 

  6412. 	$prefix = "./";

    6413. 

  6413. 	$itt = 5;

    6414. 

  6414. 	while( !file_exists($prefix.$cfgMODir) && $itt > 0 ){

    6415. 

  6415. 		$itt--;

    6416. 

  6416. 		$prefix .= "../";

    6417. 

  6417. 	}

    6418. 

  6418. 	

    6419. 

  6419. 	//Identifier toutes les cha�nes locales support�es par fortic ( c-a-d les noms de tous les dossiers dans le r�pertoire gettext )

    6420. 

  6420. 	$localeStrings = array( );

    6421. 

  6421. 	$locale = getLocalesList();

    6422. 

  6422. 	$dirPath = $prefix.$cfgMODir;

    6423. 

  6423. 	if ($handle = opendir($dirPath)) {

    6424. 

  6424. 		//Lire tous les �l�ments contenus dans le r�pertoire

    6425. 

  6425. 		while (false !== ($file = readdir($handle))) {

    6426. 

  6426. 			//Ne pas traiter la r�f�rence au dossier actuel, celle au dossier parent et celle vers le dossier svn

    6427. 

  6427. 			if ($file != "." && $file != ".." && $file != ".svn" ) {

    6428. 

  6428. 				//V�rification que ce que l'on regarde est un dossier et porte un nom qui est reconnu comme une chaine locale.

    6429. 

  6429. 				if (is_dir("$dirPath/$file") && array_key_exists( $file, $locale ) ) {

    6430. 

  6430. 					$localeStrings[ $file ] = $locale[ $file ];

    6431. 

  6431. 				}

    6432. 

  6432. 			}

    6433. 

  6433. 		}

    6434. 

  6434. 		closedir($handle);

    6435. 

  6435. 	}

    6436. 

  6436. 	return $localeStrings;	

    6437. 

  6437. }

    6438. 

  6438. 

    6439. 

  6439. function getLocalesList(){

    6440. 

  6440. 	$locales = array();

    6441. 

  6441. 	$locales[ "in" ] = "Bahasa Indonesia";

    6442. 

  6442. 	$locales[ "in_ID" ] = "Bahasa Indonesia (Indonesia)";

    6443. 

  6443. 	$locales[ "ms" ] = "Bahasa Melayu";

    6444. 

  6444. 	$locales[ "ms_MY" ] = "Bahasa Melayu (Malaysia)";

    6445. 

  6445. 	$locales[ "ca" ] = "Catal�";

    6446. 

  6446. 	$locales[ "ca_ES" ] = "Catal� (Espanya)";

    6447. 

  6447. 	$locales[ "da" ] = "Dansk";

    6448. 

  6448. 	$locales[ "da_DK" ] = "Dansk (Danmark)";

    6449. 

  6449. 	$locales[ "de" ] = "Deutsch";

    6450. 

  6450. 	$locales[ "de_DE" ] = "Deutsch (Deutschland)";

    6451. 

  6451. 	$locales[ "de_LU" ] = "Deutsch (Luxemburg)";

    6452. 

  6452. 	$locales[ "de_AT" ] = "Deutsch (�sterreich)";

    6453. 

  6453. 	$locales[ "de_CH" ] = "Deutsch (Schweiz)";

    6454. 

  6454. 	$locales[ "et" ] = "Eesti";

    6455. 

  6455. 	$locales[ "et_EE" ] = "Eesti (Eesti)";

    6456. 

  6456. 	$locales[ "en" ] = "English";

    6457. 

  6457. 	$locales[ "en_AU" ] = "English (Australia)";

    6458. 

  6458. 	$locales[ "en_CA" ] = "English (Canada)";

    6459. 

  6459. 	$locales[ "en_IN" ] = "English (India)";

    6460. 

  6460. 	$locales[ "en_IE" ] = "English (Ireland)";

    6461. 

  6461. 	$locales[ "en_MT" ] = "English (Malta)";

    6462. 

  6462. 	$locales[ "en_NZ" ] = "English (New Zealand)";

    6463. 

  6463. 	$locales[ "en_PH" ] = "English (Philippines)";

    6464. 

  6464. 	$locales[ "en_SG" ] = "English (Singapore)";

    6465. 

  6465. 	$locales[ "en_ZA" ] = "English (South Africa)";

    6466. 

  6466. 	$locales[ "en_GB" ] = "English (United Kingdom)";

    6467. 

  6467. 	$locales[ "en_US" ] = "English (United States)";

    6468. 

  6468. 	$locales[ "es" ] = "Espa�ol";

    6469. 

  6469. 	$locales[ "es_AR" ] = "Espa�ol (Argentina)";

    6470. 

  6470. 	$locales[ "es_BO" ] = "Espa�ol (Bolivia)";

    6471. 

  6471. 	$locales[ "es_CL" ] = "Espa�ol (Chile)";

    6472. 

  6472. 	$locales[ "es_CO" ] = "Espa�ol (Colombia)";

    6473. 

  6473. 	$locales[ "es_CR" ] = "Espa�ol (Costa Rica)";

    6474. 

  6474. 	$locales[ "es_EC" ] = "Espa�ol (Ecuador)";

    6475. 

  6475. 	$locales[ "es_SV" ] = "Espa�ol (El Salvador)";

    6476. 

  6476. 	$locales[ "es_ES" ] = "Espa�ol (Espa�a)";

    6477. 

  6477. 	$locales[ "es_US" ] = "Espa�ol (Estados Unidos)";

    6478. 

  6478. 	$locales[ "es_HN" ] = "Espa�ol (Honduras)";

    6479. 

  6479. 	$locales[ "es_MX" ] = "Espa�ol (M�xico)";

    6480. 

  6480. 	$locales[ "es_NI" ] = "Espa�ol (Nicaragua)";

    6481. 

  6481. 	$locales[ "es_PY" ] = "Espa�ol (Paraguay)";

    6482. 

  6482. 	$locales[ "es_PE" ] = "Espa�ol (Per�)";

    6483. 

  6483. 	$locales[ "es_PR" ] = "Espa�ol (Puerto Rico)";

    6484. 

  6484. 	$locales[ "es_DO" ] = "Espa�ol (Rep�blica Dominicana)";

    6485. 

  6485. 	$locales[ "es_UY" ] = "Espa�ol (Uruguay)";

    6486. 

  6486. 	$locales[ "es_VE" ] = "Espa�ol (Venezuela)";

    6487. 

  6487. 	$locales[ "fr" ] = "Fran�ais";

    6488. 

  6488. 	$locales[ "fr_BE" ] = "Fran�ais (Belgique)";

    6489. 

  6489. 	$locales[ "fr_CA" ] = "Fran�ais (Canada)";

    6490. 

  6490. 	$locales[ "fr_FR" ] = "Fran�ais (France)";

    6491. 

  6491. 	$locales[ "fr_LU" ] = "Fran�ais (Luxembourg)";

    6492. 

  6492. 	$locales[ "fr_CH" ] = "Fran�ais (Suisse)";

    6493. 

  6493. 	$locales[ "ga" ] = "Gaeilge";

    6494. 

  6494. 	$locales[ "ga_IE" ] = "Gaeilge (�ire)";

    6495. 

  6495. 	$locales[ "hr" ] = "Hrvatski";

    6496. 

  6496. 	$locales[ "hr_HR" ] = "Hrvatski (Hrvatska)";

    6497. 

  6497. 	$locales[ "is" ] = "�slenska";

    6498. 

  6498. 	$locales[ "is_IS" ] = "�slenska (�sland)";

    6499. 

  6499. 	$locales[ "it" ] = "Italiano";

    6500. 

  6500. 	$locales[ "it_IT" ] = "Italiano (Italia)";

    6501. 

  6501. 	$locales[ "it_CH" ] = "Italiano (Svizzera)";

    6502. 

  6502. 	$locales[ "lv" ] = "Latvie&#x161;u";

    6503. 

  6503. 	$locales[ "lv_LV" ] = "Latvie&#x161;u (Latvija)";

    6504. 

  6504. 	$locales[ "hu" ] = "Magyar";

    6505. 

  6505. 	$locales[ "hu_HU" ] = "Magyar (Magyarorsz�g)";

    6506. 

  6506. 	$locales[ "mt" ] = "Malti";

    6507. 

  6507. 	$locales[ "mt_MT" ] = "Malti (Malta)";

    6508. 

  6508. 	$locales[ "nl" ] = "Nederlands";

    6509. 

  6509. 	$locales[ "nl_BE" ] = "Nederlands (Belgi�)";

    6510. 

  6510. 	$locales[ "nl_NL" ] = "Nederlands (Nederland)";

    6511. 

  6511. 	$locales[ "no" ] = "Norsk";

    6512. 

  6512. 	$locales[ "no_NO" ] = "Norsk (Norge)";

    6513. 

  6513. 	$locales[ "pl" ] = "Polski";

    6514. 

  6514. 	$locales[ "pl_PL" ] = "Polski (Polska)";

    6515. 

  6515. 	$locales[ "pt" ] = "Portugu�s";

    6516. 

  6516. 	$locales[ "pt_PT" ] = "Portugu�s (Portugal)";

    6517. 

  6517. 	$locales[ "pt_BR" ] = "Portugu�s (Brasil)";

    6518. 

  6518. 	$locales[ "tr" ] = "T�rk�e";

    6519. 

  6519. 	$locales[ "tr_TR" ] = "T�rk�e (T�rkiye)";

    6520. 

  6520. 	$locales[ "sq_AL" ] = "Shqipe (Shqip�ria)";

    6521. 

  6521. 	$locales[ "fi" ] = "Suomi";

    6522. 

  6522. 	$locales[ "fi_FI" ] = "Suomi (Suomi)";

    6523. 

  6523. 	$locales[ "sv" ] = "Svenska";

    6524. 

  6524. 	$locales[ "sv_SE" ] = "Svenska (Sverige)";

    6525. 

  6525. 	return $locales;

    6526. 

  6526. }

    6527. 

  6527. 

    6528. 

  6528. /*************************************************************************

    6529. 

  6529.  * Titre :				Fonctions de test

    6530. 

  6530.  * Description :		Une s�ries de fonctions pour tester les diff�rents protocoles et la configuration du server PHP

    6531. 

  6531.  * Auteur :				Richard Rail

    6532. 

  6532.  *************************************************************************/

    6533. 

  6533.  

    6534. 

  6534. /*

    6535. 

  6535. * lister_config_php($droit_ecriture = true, $variables = true, $extension = true) cr�e une liste

    6536. 

  6536. * des configurations du serveur PHP necessaire � Fortic sous le format d'un tableau clef => valeur

    6537. 

  6537. * dont la clef est le nom de la configuration et la valeur est un boolean expriment si la configuration

    6538. 

  6538. * est ad�quate pour le serveur PHP.

    6539. 

  6539. *

    6540. 

  6540. * @param $droit_ecriture - inclure les droits en �criture dans la liste

    6541. 

  6541. * @param $variables - inclure les variables dans la liste

    6542. 

  6542. * @param $extension - inclure les extensions dans la liste

    6543. 

  6543. *

    6544. 

  6544. * @return Array - un tableau clef=>valeur des configuration=>valide

    6545. 

  6545. */

    6546. 

  6546. function lister_config_php($droit_ecriture = true, $variables = true, $extension = true){

    6547. 

  6547. 	$config = array();

    6548. 

  6548. 	if($variables){

    6549. 

  6549. 		$config['phpversion'] = (substr(phpversion(),0,1) >= 5);

    6550. 

  6550. 		

    6551. 

  6551. 		$config['short_open_tag'] = ini_get('short_open_tag') == true;

    6552. 

  6552. 		$config['register_argc_argv'] = ini_get('register_argc_argv') == true;

    6553. 

  6553. 		$config['magic_quotes_gpc'] = ini_get('magic_quotes_gpc') == false;

    6554. 

  6554. 		$config['allow_call_time_pass_reference'] = ini_get('allow_call_time_pass_reference') == true;

    6555. 

  6555. 	}

    6556. 

  6556. 	if($extension){

    6557. 

  6557. 		$extensions = get_loaded_extensions();

    6558. 

  6558. 		$config['php_gettext'] = in_array( 'gettext', $extensions );

    6559. 

  6559. 		$config['php_pgsql'] = in_array( 'pgsql', $extensions );

    6560. 

  6560. 		$config['php_ldap'] = in_array( 'ldap', $extensions );

    6561. 

  6561. 	}

    6562. 

  6562. 	if($droit_ecriture){

    6563. 

  6563. 		$config['ecriture_config'] = is_writable( rechercher_fichier('config') );

    6564. 

  6564. 		$config['ecriture_config_file'] = is_writable( rechercher_fichier('config/config.php') );

    6565. 

  6565. 		$config['ecriture_mise_a_jour'] = is_writable( rechercher_fichier('lib/bd_scripts') );

    6566. 

  6566. 		$config['ecriture_log'] = is_writable( rechercher_fichier('log') );

    6567. 

  6567. 		$config['ecriture_pdf'] = is_writable( rechercher_fichier('pdf') );

    6568. 

  6568. 	}

    6569. 

  6569. 	return $config;

    6570. 

  6570. }

    6571. 

  6571. 

    6572. 

  6572. /*

    6573. 

  6573. * tester_connexion_postgresql($connection_string) teste la connexion au serveur postgresql et retourne

    6574. 

  6574. * un message d'erreur appropri� selon le cas.

    6575. 

  6575. *

    6576. 

  6576. * @param $connection_string - la string de connexion

    6577. 

  6577. *

    6578. 

  6578. * @return Array - retourne un tableau d'erreur

    6579. 

  6579. */

    6580. 

  6580. $resultat_erreur;

    6581. 

  6581. function tester_connexion_postgresql($connection_string){

    6582. 

  6582. 	/* Avant de pleurer, je tien � dire que j'ai fais de longues recherche et en PHP 5, il n'y a pas de moyen avec Pg_connect

    6583. 

  6583. 	* d'avoir un num�rau d'�rreur, donc la seule fa�on de donn�e un resultat de test, c'est faire sois-m�me le reportage

    6584. 

  6584. 	* d'�rreur et de pass�e des expressions r�gulaire pour voir si le message semble a celui d'un erreur X.

    6585. 

  6585. 	*/

    6586. 

  6586. 	$error_reporting_old = error_reporting();

    6587. 

  6587. 	error_reporting(E_WARNING);

    6588. 

  6588. 	set_error_handler("error_handler_conn_postgresql");

    6589. 

  6589. 	

    6590. 

  6590. 	$conn = pg_connect($connection_string); 

    6591. 

  6591. 	

    6592. 

  6592. 	restore_error_handler();

    6593. 

  6593. 	error_reporting($error_reporting_old);

    6594. 

  6594. 	if($conn){

    6595. 

  6595. 		return array('succes' => 'succes');

    6596. 

  6596. 	} else { //S'il y a un erreur la function error_handler_conn_postgresql va avoir mis l'erreur dans resultat_erreur

    6597. 

  6597. 		return $GLOBALS['resultat_erreur'];

    6598. 

  6598. 	}

    6599. 

  6599. }

    6600. 

  6600. /*

    6601. 

  6601. * error_handler_conn_postgresql remplace le 'error handler' par default pour la fonction tester_connexion_postgresql

    6602. 

  6602. */

    6603. 

  6603. function error_handler_conn_postgresql($errorNumber, $errorMessage, $errorFile, $errorLine, $vars){

    6604. 

  6604. 	global $resultat_erreur;

    6605. 

  6605. 	$resultat_erreur = array();		

    6606. 

  6606. 	$pre = '/Unable to connect to PostgreSQL server: ';

    6607. 

  6607. 	if( preg_match($pre.'.*database.*does not exist/',$errorMessage)){

    6608. 

  6608. 		$resultat_erreur['database'] = 'La base de donn�e n\a pas �t� trouv�.';

    6609. 

  6609. 	} else if( preg_match($pre.'.*password authentication failed for user.*/',$errorMessage)){

    6610. 

  6610. 		$resultat_erreur['authentification'] = 'L\'authentification est invalide.';

    6611. 

  6611. 	} else if( preg_match($pre.'.*Connection refused.*/',$errorMessage)){

    6612. 

  6612. 		$resultat_erreur['connexion'] = 'Le serveur est non accesible ou le port n\'est pas en ecoute ou est bloqu�.';

    6613. 

  6613. 	} else if( preg_match($pre.'.*Unknown host.*/',$errorMessage)){

    6614. 

  6614. 		$resultat_erreur['connexion'] = 'Nom de l\'h�te est inconnue';

    6615. 

  6615. 	} else {

    6616. 

  6616. 		$resultat_erreur['erreur'] = $errorMessage;

    6617. 

  6617. 	}

    6618. 

  6618. }

    6619. 

  6619. 

    6620. 

  6620. /*

    6621. 

  6621. * tester_serveur_SMTP($serveur) teste la connexion au serveur SMTP et retourne

    6622. 

  6622. * un message d'erreur appropri� selon le cas.

    6623. 

  6623. *

    6624. 

  6624. * @param $connection_string - la string de connexion

    6625. 

  6625. *

    6626. 

  6626. * @return Array - retourne un tableau d'erreur

    6627. 

  6627. */

    6628. 

  6628. function tester_serveur_SMTP($serveur){

    6629. 

  6629. 	require_once("../lib/php/phpmailer/class.phpmailer.php");

    6630. 

  6630. 	$mail = new PHPMailer();

    6631. 

  6631. 	$mail->SetLanguage("fr","../lib/php/phpmailer/");

    6632. 

  6632. 	$mail->IsSMTP();		

    6633. 

  6633. 	$mail->Host = $serveur;

    6634. 

  6634. 	$mail->From = "noreply@noreply.com";

    6635. 

  6635. 	$mail->AddAddress("noreply@noreply.com");

    6636. 

  6636. 	$mail->FromName = "Test";

    6637. 

  6637. 	$mail->Subject = 'Test';

    6638. 

  6638. 	$mail->Body = 'Test';

    6639. 

  6639. 	$mail->SMTPAuth = false;

    6640. 

  6640. 	if($mail->Send()) {

    6641. 

  6641. 		return array("succes" => 'Le serveur est accessible');

    6642. 

  6642. 	} else {

    6643. 

  6643. 		return array("erreur" => 'Le serveur n\'est pas accessible');

    6644. 

  6644. 	}

    6645. 

  6645. }

    6646. 

  6646. 

    6647. 

  6647. /*

    6648. 

  6648. * tester_ldap($serveur, $port, $bind_rdn, $bind_password, $base_dn, $filtre, $infos)

    6649. 

  6649. * teste la connexion au serveur LDAP et retourne un message d'erreur appropri� selon le cas.

    6650. 

  6650. *

    6651. 

  6651. * @param $serveur - string du serveur � se connecter 

    6652. 

  6652. * @param $port - string du port

    6653. 

  6653. * @param $bind_rdn - string du rdn

    6654. 

  6654. * @param $bind_password - string du mot de passe

    6655. 

  6655. * @param $base_dn - string du dn

    6656. 

  6656. * @param $filtre - string du filtre ldap

    6657. 

  6657. * @param $infos - array d'informations a tester dans ldap

    6658. 

  6658. *

    6659. 

  6659. * @return Array - retourne un tableau d'erreur

    6660. 

  6660. */

    6661. 

  6661. function tester_ldap($serveur, $port, $bind_rdn, $bind_password, $base_dn, $filtre, $infos){

    6662. 

  6662. 	$resultat = null;

    6663. 

  6663. 	//S'il n'y a pas de filtre on va tenter de s'en faire un pour pas que sa plante

    6664. 

  6664. 	if($filtre == ''){

    6665. 

  6665. 		$filtre = explode(',',$bind_rdn);

    6666. 

  6666. 		$filtre = '('.$filtre[0].')';

    6667. 

  6667. 	}

    6668. 

  6668. 	

    6669. 

  6669. 	$error_reporting_old = error_reporting();

    6670. 

  6670. 	error_reporting(0);

    6671. 

  6671. 	$conLDAP = ldap_connect( $serveur, $port );

    6672. 

  6672. 	//Si options LDAP on les appliquent

    6673. 

  6673. 	if ( count($ldap_var["ldap_options"]) > 0) {

    6674. 

  6674. 		OptionConnexion_LDAP($conLDAP);

    6675. 

  6675. 	}

    6676. 

  6676. 	if(ldap_errno($conLDAP) == 0){

    6677. 

  6677. 		ldap_bind($conLDAP, $bind_rdn, $bind_password)

    6678. 

  6678. 		&& ( $arrayRecherche = ldap_search($conLDAP, $base_dn, $filtre) )

    6679. 

  6679. 		&& ( $ldap_info = ldap_get_entries($conLDAP, $arrayRecherche) );

    6680. 

  6680. 	}

    6681. 

  6681. 	

    6682. 

  6682. 	if(ldap_errno($conLDAP) != 0){

    6683. 

  6683. 		switch(ldap_errno($conLDAP)){

    6684. 

  6684. 			case 81: //Can't contact LDAP server

    6685. 

  6685. 				$resultat = array('connexion'=>'Erreur de connection au serveur LDAP');

    6686. 

  6686. 				break;

    6687. 

  6687. 			case 49: //Invalid credentials

    6688. 

  6688. 				$resultat = array('credentials'=>'Erreur de connection au serveur LDAP');

    6689. 

  6689. 				break;

    6690. 

  6690. 			case 87: //Bad search filter

    6691. 

  6691. 				$resultat = array('filtre'=>'Filtre invalide');

    6692. 

  6692. 				break;

    6693. 

  6693. 			case 32: //No such object

    6694. 

  6694. 				$resultat = array('base_dn'=>'La base de recherche est invalide');

    6695. 

  6695. 				break;

    6696. 

  6696. 			default:

    6697. 

  6697. 				$resultat = array('erreur'=>'Erreur inconnue #'.ldap_errno($conLDAP) . ' : ' . ldap_error($conLDAP) . ' |'.$bind_password.'|');

    6698. 

  6698. 				break;

    6699. 

  6699. 		}//switch

    6700. 

  6700. 	} else {

    6701. 

  6701. 		$resultat = array();

    6702. 

  6702. 

    6703. 

  6703. 		// Tentative de rendre l'application compatible avec OpenLDAP

    6704. 

  6704. 		if( $ldap_info[ 'count' ] == 1 ){

    6705. 

  6705. 			$ldap_info = $ldap_info[ 0 ];

    6706. 

  6706. 		}

    6707. 

  6707. 		foreach( $infos as $info ){

    6708. 

  6708. 			if( !in_array($info, $ldap_info) ){

    6709. 

  6709. 				$resultat["$info"] = $info. ' n\'est pas une information valide';

    6710. 

  6710. 			}

    6711. 

  6711. 		}

    6712. 

  6712. 	}

    6713. 

  6713. 	

    6714. 

  6714. 	if(is_array($resultat) && count($resultat) == 0) $resultat = array('succes' => 'succes');

    6715. 

  6715. 	ldap_close( $conLDAP );

    6716. 

  6716. 	error_reporting($error_reporting_old);

    6717. 

  6717. 	return $resultat;

    6718. 

  6718. }

    6719. 

  6719. 

    6720. 

  6720. /*

    6721. 

  6721. * rechercher_fichier($fichier) cherche le fichier $fichier en reculant de plus en plus dans l'arborescence 

    6722. 

  6722. * et arr�te � la racine du serveur PHP 

    6723. 

  6723. *

    6724. 

  6724. * @param $fichier - fichier � trouv� (peut �tre un dossier) 

    6725. 

  6725. *

    6726. 

  6726. * @return string - chemin jusqu'au dossier ( ../../../fichier ) ou FALSE s'il ne le trouve pas

    6727. 

  6727. */

    6728. 

  6728. function rechercher_fichier($fichier){

    6729. 

  6729. 	$env = getenv("SCRIPT_NAME");

    6730. 

  6730. 	//on compte le nombre de dossier entre le script et la racine du serveur

    6731. 

  6731. 	$nb_bon_max = count( explode('/',$env) ) - 1;

    6732. 

  6732. 

    6733. 

  6733. 	while( $nb_bon_max-- >0 ){

    6734. 

  6734. 		if( file_exists($fichier) ) return $fichier;

    6735. 

  6735. 		$fichier = '../' . $fichier;

    6736. 

  6736. 	}

    6737. 

  6737. 	return false;

    6738. 

  6738. }

    6739. 

  6739. 

    6740. 

  6740. }// fin du define PHP_LIBRARY_FORTICFUNCTIONS

    6741. 

  6741. ?>

    6742. 

  6742.