/fortic-php/lib/php/forticFunctions.php
PHP | 6741 lines | 4955 code | 426 blank | 1360 comment | 1013 complexity | 6a6b0c1e47c92f4016271135e094691a MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause
Large files files are truncated, but you can click here to view the full file
- <?php
- if(!defined("PHP_LIBRARY_FORTICFUNCTIONS")){define("PHP_LIBRARY_FORTICFUNCTIONS",1);
- ///////////////////////////////////////////////////////////////////////////////////////
- // nom: forticFunctions.php
- // auteur: Youri Reddy-Girard
- // Modifs: Daniel Cédilotte -- changeUTF16
- // date: 20/10/2002
- // desc: Librairie de fonctions de FORtIC
- //
- // modifié: Sylvie Caron Ajout du type de lieu - réf: demande #31 (améliorations 2005-2006)
- // modifié: R. Franche : mettre "0 dans lt_id dans la fonction addUpdateLieu
- // modifié: Sylvie Caron Ajout du lieu dans la liste des animateurs - réf: demande #37 (améliorations 2006-2007)
- // Fonctions ajoutées: formatNameLieu
- // Fonctions modifiées: getSQLStmtReqLieuAdminlieu, getSQLStmtReqSessionAnimateur
- // 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
- // Fonctions ajoutées: formatSessionCode et formatSessionDescription
- //
- // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $
- // $Id: forticFunctions.php,v 1.140 2008/07/03 18:29:46 stacil Exp $
- // 2007/08/22 R. Franche : correction fonction getSQLStmtInsLieuAdmin, il manquait le return
- // 2008/03/25 R. Franche : lors du login : chercher lieu d'après son numéro OU sa description
- // pour éviter la création de lieu en double
- // 2008/04/25 R. Franche : correction fonction getSQLStmtReqLieuFromNoOuDescr : ajout addslash pour nom de lieu avec quote
- ///////////////////////////////////////////////////////////////////////////////////////
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // ajoutUsagerLDAP($sArrayLDAP, $sUsrLDAPCode)
- // Ajoute l'usager dans Fortic en provenance de LDAP
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $sArrayLDAP: tableau des informations de LDAP
- // $sUsrLDAPCode: code de l'usager LDAP
- // &$nUsrID: retour de l'ID de l'usager Fortic
- // OUT: aucun
- ///////////////////////////////////////////////////////////////////////////////////////
- function ajouterUsagerLDAP($conn, $sArrayLDAP, $sUsrLDAPCode, &$nUsrID)
- {
- // importation des données (LDAP -> USAGER)
- // on ouvre la transaction
- $result = pg_query($conn, "BEGIN;");
- if (!$result){ bugFromPG($conn); }
-
- //Traitement du lieu LDAP vs Fortic
- addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);
-
- //insertion de la fiche du nouvel usager
- $result = pg_query($conn, getSQLStmtInsUsager($sUsrLDAPCode, changeUTF16($sArrayLDAP[0]),
- changeUTF16($sArrayLDAP[1]), $nLieuID));
-
- if (!$result){ bugFromPG($conn); }
-
- //retrouver la fiche qu'on vient de créer
- $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerLAST(), &$nUsrID);
-
- //update de la fiche
- $result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID, changeUTF16($sArrayLDAP[0]),
- changeUTF16($sArrayLDAP[1]),$sArrayLDAP[2], $sArrayLDAP[5],
- changeUTF16($sArrayLDAP[6]), "t", $nLieuID, "t"));
- if (!$result){ bugFromPG($conn); }
-
- // insertion du type d'usager
- $result = pg_query($conn, getSQLStmtInsUsagerUsrType($nUsrID, 1));
- if (!$result){ bugFromPG($conn); }
-
- // on ferme la transaction
- $result = pg_query($conn, "COMMIT;");
- if (!$result){ bugFromPG($conn); }
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // addUpdateLieu($conn, , $nolieuLDAP, $lieuDesc, &$nLieuID)
- // Ajoute ou met à jour un lieu en provenance de d'un usager LDAP
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $nolieuLDAP : numéro du lieu en provenance de LDAP */
- // $lieuDesc : Description du lieu
- // $nLieuID : numéro du lieu dans la bd Fortic
- // OUT: aucun
- ///////////////////////////////////////////////////////////////////////////////////////
- function addUpdateLieu($conn, $nolieuLDAP, $lieuDesc, &$nLieuID){
-
- // Aller chercher dans Fortic le lieu de l'usager LDAP
- // 2008/03 : chercher le lieu d'après non numéro OU sa description pour éviter le création de doubles
- $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuFromNoOuDescr($nolieuLDAP, $lieuDesc),
- &$Li_id, &$Li_lieu, &$Li_no, &$Li_adresse,
- &$Li_trajet, &$Li_trajetURL, &$Li_telephone,
- &$Li_valide, &$Li_dateUpdate, &$Li_dateCreation);
-
- // Si on ne trouve pas le lieu, on le crée
- if($bFicheFound != true) {
- // Si la description du lieu est vide, on met Lieu avec son numéro
- if(isset($lieuDesc) == false || $lieuDesc == "") {
- $lieuDesc = "Lieu_".$nolieuLDAP;
- }
- // Insertion minimum
- $result = pg_query($conn, getSQLStmtInsLieu($lieuDesc));
- if (!$result){ bugFromPG($conn); }
- // Aller chercher la clée de la nouvelle entrée
- $bFicheFound=fillVarFromDBStd($conn, getSQLStmtReqLieuLAST(), &$nLieuID);
- // Compléter les informations du lieu
- $result = pg_query($conn, getSQLStmtUpdLieu($nLieuID, $lieuDesc,
- $nolieuLDAP, "", "", "", "",
- "t","t","0"));
- if (!$result){ bugFromPG($conn); }
- } else {
- // Affecter l'ID du lieu à la variable
- $nLieuID = $Li_id;
- }
- }
-
-
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // addUpdateUsagerFromLDAP($conn, $codeUsager)
- // Ajoute ou met à jour l'usager dans Fortic en provenance de LDAP
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $codeUsager : code de l'usager à ajouter
- // OUT: aucun
- ///////////////////////////////////////////////////////////////////////////////////////
- function addUpdateUsagerFromLDAP($conn, $codeUsager)
- {
- global $ldap_var;
-
- // Connexion au serveur LDAP
- $conLDAP = ldap_connect($ldap_var[db][host], $ldap_var[db][port]);
- if(!$conLDAP) { //Connexion au serveur LDAP non-réussi, on quitteM
- bugFromLDAP($conLDAP);
- } else {
- //Si options LDAP on les appliquent
- if ( count($ldap_var["ldap_options"]) > 0) {
- OptionConnexion_LDAP($conLDAP);
- }
- }
- // Filtre pour rechercher seulement le code d'usager
- $filtre ="(&(".$ldap_var[db][searchKey]."=".$codeUsager.")".$filtre.$ldap_var[db][filter].")";
- //Recherche l'info complete de l'usager dans la base ldap
- $codeRetour = Recherche_LDAP($conLDAP,$filtre, &$sArrayRechLdap);
-
- //Vérifie le code de retour pour savoir si l'usager existe dans l'annuaire
- if ($codeRetour >= 0) {
- $sArrayLDAP = array(trim($sArrayRechLdap[0][0]), // Nom
- trim($sArrayRechLdap[0][1]), //Prénom
- trim($sArrayRechLdap[0][2]), //Email
- trim($sArrayRechLdap[0][3]), //lieuID
- trim($sArrayRechLdap[0][4]), //lieuDescr
- trim($sArrayRechLdap[0][5]), //Téléphone
- trim($sArrayRechLdap[0][6])); //Fonction
-
- //vérifie si l'usager existe déjà dans la base Fortic sinon on l'ajoute
- $bUserFound=fillVarFromDBStd($conn, getSQLStmtReqUsagerFromLogin($codeUsager),
- &$nUsrID, &$sLDAP);
- if ($bUserFound){ // l'usager existe déjà dans FORTIC, met à jour
- //Traitement du lieu LDAP vs Fortic
- addUpdateLieu($conn, $sArrayLDAP[3], $sArrayLDAP[4], &$nLieuID);
- // Mise à jour de l'usager
- $result = pg_query($conn, getSQLStmtUpdUsagerLDAP($nUsrID,
- changeUTF16($sArrayLDAP[0]),
- changeUTF16($sArrayLDAP[1]),
- $sArrayLDAP[2], $sArrayLDAP[5],
- changeUTF16($sArrayLDAP[6]), "t",
- $nLieuID, "t"));
- } else { //Nouvel usager on l'ajoute
- ajouterUsagerLDAP($conn, $sArrayLDAP, $codeUsager, &$nUsrID);
- }
- }
- }
-
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // bugFromLdap($conn)
- // méthode appellée losrqu'on a un problème avec l'exécution d'une requête ou à établir
- // la connexion avec le serveur LDAP.
- ///////////////////////////////////////////////////////////////////////////////////////
- function bugFromLDAP($conn){
- echo _("Probleme avec la connexion LDAP");
- //echo pg_last_error($conn);
- //on quitte tous les script (pas de niasage)
- exit;
- }
-
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage,
- // &$arrnUsrLogin, &$arrUsrNom, &$arrUsrPrenom,
- // &$arrUsrLieuID, &$arrUsrLieu, &$arrUsrFonction)
- // remplit les tableaux de variables reçus en paramètre avec les valeurs contenus dans un
- // Array de SESSION "UsagerLieuLDAP"(provenant d'une requête LDAP)
- // De plus ce type de requête tient compte de la notion des pages. On peut donc
- // se positionner sur la Xe page de résultat directement
- // ATTENTION : Cette fonction est très spécifique et remplit toujours le même
- // nombre de tableau et dans un ordre très spécifique.
- // IN:
- // $pg: quelle page on veut se positionner
- // $pgSize: la grandeur des page (nb d'enregistrement par page)
- // $nbRecordTotal: nb d'entrée dans le tableau de SESSION
- // $arrUsrLogin: 1er tableau à remplir
- // $arrUsrNom: 2e tableau à remplir
- // $arr...: Xe tableau à remplir
- // OUT: -1: erreur lors de l'exécution de la requête
- // (int >= 0): nb de rangées résultantes de la requête
- ///////////////////////////////////////////////////////////////////////////////////////
- function fillArrFromArray( $pg, $pgSize, $nbRecordTotal, $nbPage, &$arrnUsrLogin,
- &$arrUsrNom, &$arrUsrPrenom,&$arrUsrLieuID, &$arrUsrLieu,
- &$arrUsrFonction){
-
- $nbPage = ceil($nbRecordTotal/$pgSize);
- if ($nbRecordTotal>0){
- $offset = ($pg-1)*$pgSize;
- $limit = $offset + $pgSize;
- $nbRow = min($nbRecordTotal,$limit)- $offset;
- for($iRow=0; $iRow<$nbRow; $iRow++,$offset++){
- $arrnUsrLogin[$iRow] = $_SESSION["UsagerLieuLDAP"][5][$offset];
- $arrUsrNom[$iRow] = $_SESSION["UsagerLieuLDAP"][0][$offset];
- $arrUsrPrenom[$iRow] = $_SESSION["UsagerLieuLDAP"][1][$offset];
- $arrUsrLieuID[$iRow] = $_SESSION["UsagerLieuLDAP"][2][$offset];
- $arrUsrLieu[$iRow] = $_SESSION["UsagerLieuLDAP"][3][$offset];
- $arrUsrFonction[$iRow] = $_SESSION["UsagerLieuLDAP"][4][$offset];
- }
- return ($nbRow);
- }
- else{
- return (0);
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fillUsrFromLDAPServer($login, $mdp, &$bLoginValide, &$sArrayLDAP)
- // remplit le usr_id de l'usager en fonction de ce qu'on trouvé dans ldap qui avait
- // le même login et mot de passe que celui fournit en paramètre
- // IN: $login: nom d'usager
- // $mdp: mot de passe
- // &$bLoginValide : si on a de quoi de valide sur ldap, on met true ici
- // &$sArrayLDAP : informations extraites du serveur LDAP
- // OUT: 1: user retrouvé dans ldap
- // 0: user non retrouvé dans ldap
- ///////////////////////////////////////////////////////////////////////////////////////
- function fillUsrFromLDAPServer( $login, $mdp, &$bLoginValide, &$sArrayLDAP ){
- global $ldap_var;
- $OkLDAP = 0;
- $bLoginValide = false;
-
- // Connexion au serveur LDAP
- $conLDAP = ldap_connect( $ldap_var[ 'db' ][ 'host' ], $ldap_var[ 'db' ][ 'port' ] );
-
- //Connexion au serveur LDAP. Si non-réussi, on quitte
- if( $conLDAP !== false ) {
- //Si options LDAP on les appliquent
- if ( count($ldap_var["ldap_options"]) > 0) {
- OptionConnexion_LDAP($conLDAP);
- }
- // Filtre pour rechercher seulement le code d'usager
- $filtre = "(&(" . $ldap_var[ "db" ][ "searchKey" ] . "=" . $login. ")" . $ldap_var[ "db" ][ "filter" ] . ")";
-
- //Recherche l'usager dans la base ldap
- $codeRetour = Recherche_LDAP( $conLDAP, $filtre, &$sArrayRechLdap );
- $sArrayRechLdap = $sArrayRechLdap[ 0 ];
-
- //Vérifie le code de retour pour savoir si l'usager existe dans l'annuaire
- if( $codeRetour >= 0 ) {
- $OkLDAP = 1;
- if( $codeRetour > 0 ) {
- //Récuppère le dn pour permettre de faire le nouveau bind
- $dn = $sArrayRechLdap[ 7 ];
- //Si pas de mot de passe fournit on en génère un bidon pour être certain de ne pas faire un bind anonyme
- if( $mdp == "" ){
- $mdp = crypt( microtime() );
- }
-
- // Si l'authentification a réussie, retourne les infos de l'usager ainsi qu'un code de retour valide
- if( @ldap_bind( $conLDAP, $dn, $mdp ) ){
- //if( ldap_compare( $conLDAP, $dn, "userpassword", $mdp ) ){
- $sArrayLDAP = array( trim( $sArrayRechLdap[ 0 ] ), trim( $sArrayRechLdap[ 1 ] ), trim( $sArrayRechLdap[ 2 ] ),
- trim( $sArrayRechLdap[ 3 ] ), trim( $sArrayRechLdap[ 4 ] ), trim( $sArrayRechLdap[ 5 ] ), trim( $sArrayRechLdap[ 6 ] ) );
- $bLoginValide = true;
- }
- }
- }
-
- ldap_unbind( $conLDAP );
- }
-
- return $OkLDAP;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // OptionConnexion_LDAP
- // Affecte les options de connexion à l'annaire LDAP s'il y a lieu
- // IN: $conLDAP :Connexion au serveur ldap
- // OUT: -----
- ///////////////////////////////////////////////////////////////////////////////////////
- function OptionConnexion_LDAP( $conLDAP){
- global $ldap_var;
-
- for( $i=0; is_array($ldap_var["ldap_options"]) && $i < count($ldap_var["ldap_options"]); $i++ ) {
- if( isset( $ldap_var["ldap_options"][$i] ) && strpos( $ldap_var["ldap_options"][$i], ";" ) ) {
- $param = explode(";",$ldap_var["ldap_options"][$i]);
- ldap_set_option($conLDAP, constant($param[0]) ,$param[1]);
- }
- }
- }
- ///////////////////////////////////////////////////////////////////////////////////////
- // Recherche_LDAP
- // Recherche des informations selon le filtre spécifié
- // IN: $conLDAP :Connexion au serveur ldap
- // $filtre : filtre de recherche
- // &$sArrayLDAP : informations extraites du serveur LDAP
- // OUT: nb: nb. user retrouvé dans ldap
- // 0: user non retrouvé dans ldap
- // -1: connexion impossible
- ///////////////////////////////////////////////////////////////////////////////////////
- function Recherche_LDAP( $conLDAP, $filtre, $sArrayLDAP ){
- global $ldap_var;
- $codeRetour = 0;
-
- // La connexion au serveur LDAP est établit on fait un premier bind
- if( isset( $ldap_var[ 'db' ][ 'bind_dn' ] ) ) {
- //Si aucun code de bind n'est défini on fait un alors un bind anonyme
- $bindLDAP = ldap_bind( $conLDAP, $ldap_var[ 'db' ][ 'bind_dn' ], $ldap_var[ 'db' ][ 'bind_pwd' ] );
- } else {
- // Sinon on fait une connexion avec un usager ayant les droits nécessaires dans l'annuaire
- $bindLDAP = ldap_bind( $conLDAP );
- }
-
- // Bind au serveur LDAP non-réussi, on quitte
- if( !$bindLDAP ) {
- $codeRetour = -1;
- } else {
- // Liste des variables à retourner lors du search
- $restrictions = array( $ldap_var[ 'info' ][ 'nom' ], $ldap_var[ 'info' ][ 'prenom' ], $ldap_var[ 'info' ][ 'email' ],
- $ldap_var[ 'info' ][ 'lieuID' ], $ldap_var[ 'info' ][ 'lieuDescr' ], $ldap_var[ 'info' ][ 'telephone' ],
- $ldap_var[ 'info' ][ 'fonction' ], $ldap_var[ 'db' ][ 'searchKey' ] );
-
- // Cherche le dn de l'usager et met les enregistrements dans un tableau pour le traitement
- $arrayRecherche = ldap_search( $conLDAP, $ldap_var[ 'db' ][ 'searchBase' ], $filtre, $restrictions );
- $info = ldap_get_entries($conLDAP, $arrayRecherche);
- $codeRetour = count( $info ) - 1;
-
- // Retourne toutes les informations de l'usager selon l'annuaire
- for( $i = 0; is_array($info) && $i < $codeRetour; $i++) {
- $entree = $info[ $i ];
-
- //Correction si l'usager n'a pas de numéro de téléphone dans ldap
- if ( !isset( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) ||
- !is_array( $entree[ $ldap_var[ 'info' ][ 'telephone'] ] ) ){
- $entree[ $ldap_var[ 'info' ][ 'telephone' ] ] = array( "" );
- }
-
- $sArrayLDAP[ $i ] = array( $entree[ $ldap_var[ 'info' ][ 'nom' ] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'prenom' ] ][ 0 ],
- $entree[ $ldap_var[ 'info' ][ 'email'] ][ 0 ], strtolower( $entree[ $ldap_var[ 'info' ]['lieuID' ] ][ 0 ] ),
- $entree[ $ldap_var[ 'info' ][ 'lieuDescr'] ][ 0 ], $entree[ $ldap_var[ 'info' ][ 'telephone'] ][ 0 ],
- $entree[ $ldap_var[ 'info' ][ 'fonction'] ][ 0 ], $entree[ 'dn' ],
- strtolower( $entree[ $ldap_var[ 'db' ][ 'searchKey' ] ][ 0 ] ) );
- }
- }
-
- return $codeRetour;
- }
- ///////////////////////////////////////////////////////////////////////////////////////
- // Recherche_LDAP_Import
- // Recherche des informations selon le filtre spécifié
- // IN: $conLDAP :Connexion au serveur ldap
- // $filtre : filtre de recherche
- // &$sArrayLDAP : informations extraites du serveur LDAP
- // OUT: nb: nb. user retrouvé dans ldap
- // 0: user non retrouvé dans ldap
- // -1: connexion impossible
- ///////////////////////////////////////////////////////////////////////////////////////
- function Recherche_LDAP_Import($conLDAP, $filtre, $sArrayLDAP){
- global $ldap_var;
- $codeRetour = 0;
-
- //La connexion au serveur LDAP est établit on fait un premier bind
- //Si aucun code de bind n'est défini on fait un alors un bind anonyme
- //sinon on fait une connexion avec un usager ayant lesdroits nécessaires dans l'annuaire'
- if(isset($ldap_var[db][bind_dn])) //Le LDAP n'est pas anonyme
- {
- $bindLDAP = ldap_bind($conLDAP, $ldap_var[db][bind_dn],$ldap_var[db][bind_pwd]);
- }
- else //La recherche anonyme est permise
- {
- $bindLDAP = ldap_bind($conLDAP);
- }
-
- if(!$bindLDAP) //Bind au serveur LDAP non-réussi, on quitte
- {
- ldap_unbind($conLDAP); //Déconnexion
- $codeRetour = -1;
- return $codeRetour; //Arrêt COMPLET de l'application (-1)
- }
-
- //Liste des variables à retourner lors du search
- $restrictions = array($ldap_var[info][nom],
- $ldap_var[info][prenom],
- $ldap_var[info][email],
- $ldap_var[info][lieuID],
- $ldap_var[info][lieuDescr],
- $ldap_var[info][telephone],
- $ldap_var[info][fonction],
- $ldap_var[db][searchKey]);
-
- // Aller chercher le dn de l'usager
-
- $arrayRecherche = ldap_search($conLDAP,$ldap_var[db][searchBase],
- $filtre, $restrictions);
-
- // Mettre les enregistrements dans un tableau pour le traitement
- $info = ldap_get_entries($conLDAP, $arrayRecherche);
-
- $codeRetour = count($info) - 1;
-
- for( $i = 0; is_array($info) && $i < (count($info)-1); $i++){
- $arrayNom[$i] = changeUTF16($info[$i][$ldap_var[info][nom]][0]);
- $arrayPrenom[$i] = changeUTF16($info[$i][$ldap_var[info][prenom]][0]);
- $arrayLieuID[$i] = $info[$i][$ldap_var[info][lieuID]][0];
- $arrayLieuDescr[$i] = changeUTF16($info[$i][$ldap_var[info][lieuDescr]][0]);
- $arrayFonction[$i] = changeUTF16($info[$i][$ldap_var[info][fonction]][0]);
- $arrayKey[$i] = $info[$i][$ldap_var[db][searchKey]][0];
- }
-
- $sArrayLDAP[0] = $arrayNom;
- $sArrayLDAP[1] = $arrayPrenom;
- $sArrayLDAP[2] = $arrayLieuID;
- $sArrayLDAP[3] = $arrayLieuDescr;
- $sArrayLDAP[4] = $arrayFonction;
- $sArrayLDAP[5] = $arrayKey;
-
- return $codeRetour;
- }
- ///////////////////////////////////////////////////////////////////////////////////////
- // Retourne la requete SQL necessaire pour faire un SELECT LDAP
- ///////////////////////////////////////////////////////////////////////////////////////
- function getSQLStmtReqLieuxLDAP($mot, $motlnk, $adminlieu_id, $tech_id, $valide, $indx){
- $SQLStmt="SELECT li_id, li_lieu, li_no, li_adresse, li_trajet, li_valide";
- $SQLStmt.=" FROM lieu";
- $SQLStmt.=" WHERE li_id = li_id";
- $SQLStmt.=" AND li_ldap ='t'";
- if ($mot!=""){
- if ($motlnk!="and" && $motlnk!="or"){
- $motlnk="and"; //valeur par defaut : securite
- }
- $arrMot=getArrayFromStringMot($mot);
- $SQLStmt.=" AND (";
- for ($i=0; $i<count($arrMot); $i++){
- $SQLStmt.="(li_lieu ILIKE '%".fixPGQuote($arrMot[$i])."%'";
- $SQLStmt.=" OR li_adresse ILIKE '%".fixPGQuote($arrMot[$i])."%')";
- if ($i<count($arrMot)-1){
- $SQLStmt.=" ".$motlnk." "; //OR ou AND
- }
- }
- $SQLStmt.=")";
- }
- if (is_numeric($adminlieu_id)){
- $SQLStmt.=" AND li_id IN (";
- $SQLStmt.=" SELECT li_id";
- $SQLStmt.=" FROM lieuadmin";
- $SQLStmt.=" WHERE usr_id=".$adminlieu_id;
- $SQLStmt.=")";
- }
- if (is_numeric($tech_id)){
- $SQLStmt.=" AND li_id IN (";
- $SQLStmt.=" SELECT li_id";
- $SQLStmt.=" FROM lieusupport";
- $SQLStmt.=" WHERE usr_id=".$tech_id;
- $SQLStmt.=")";
- }
- if ($valide!=""){
- if (!strcasecmp($valide,"t")){
- $SQLStmt.=" AND li_valide='t'";
- }
- else{
- $SQLStmt.=" AND li_valide='f'";
- }
- }
- if ($indx!=""){
- if ($indx=="lieua"){
- $SQLStmt.=" ORDER BY li_lieu ASC";
- }
- elseif ($indx=="lieud"){
- $SQLStmt.=" ORDER BY li_lieu DESC";
- }
- elseif ($indx=="adressea"){
- $SQLStmt.=" ORDER BY li_adresse ASC";
- }
- elseif ($indx=="adressed"){
- $SQLStmt.=" ORDER BY li_adresse DESC";
- }
- elseif ($indx=="trajeta"){
- $SQLStmt.=" ORDER BY li_trajet ASC";
- }
- elseif ($indx=="trajetd"){
- $SQLStmt.=" ORDER BY li_trajet DESC";
- }
- elseif ($indx=="lieunoa"){
- $SQLStmt.=" ORDER BY li_no ASC";
- }
- elseif ($indx=="lieunod"){
- $SQLStmt.=" ORDER BY li_no DESC";
- }
- else
- {
- $SQLStmt.=" ORDER BY li_lieu ASC"; // ordre alphabetique de nom par defaut
- }
- }
- return $SQLStmt;
- }
-
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // Retourne le filtre necessaire pour faire la recherche LDAP par lieu
- ///////////////////////////////////////////////////////////////////////////////////////
- function getFiltreUsagersLdap($mot, $li_no){
- global $ldap_var;
- $filtre.="(&";
- if ($mot!=""){
- if ($motlnk!="and" && $motlnk!="or"){
- $motlnk="and"; //valeur par defaut : securite
- }
- $arrMot=getArrayFromStringMot($mot);
- for ($i=0; $i<count($arrMot); $i++){
- $rech = verifMot($mot);
- if($rech !="" ){
- $filtre.="(".$ldap_var[info][nom]."=".$rech."*)";
- }
- }
- }
-
- //Lieu recherché
- if ($li_no !=""){
- $filtre.="(".$ldap_var[info][lieuID]."=".$li_no.")";
- }
- //Filtre suplémentaire spécial.
- $filtre .= $ldap_var[db][filter];
- $filtre .=")";
- return $filtre;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // verifMot($input)
- // Enlève les caractères *? de la chaine
- // IN: $input: string qu'on veut vérifier
- // OUT: string épurée
- ///////////////////////////////////////////////////////////////////////////////////////
- function verifMot($input){
-
- $result = strtr($input,"*?","//");
- $result = trim($result);
- return ($result);
- }
- ///////////////////////////////////////////////////////////////////////////////////////
- // TriArrayLDAP($cle)
- // Tri le Array de SESSION "UsagerLieuLDAP"(provenant d'une requête LDAP)
- // IN: $cle: Cle de tri
- // OUT: Array de SESSION trié
- // True cle valide
- ///////////////////////////////////////////////////////////////////////////////////////
- function TriArray($cle){
-
- //Extrait la partie ordre de tri
- $typeTri = substr($cle,-1);
- //Ajuste l'ordre pour un tri descendant ou ascendant par défaut
- if($typeTri == "d" || $typeTri == "D"){
- $ordre = "SORT_DESC";
- }
- else {
- $ordre = "SORT_ASC";
- }
- //Extrait la partie du mot qui indique la cle de tri
- $cleTri = substr($cle,0, -1);
- //Ajuste les clés pour un tri par fonction
- if($cleTri == "type") {
- $cle1 = 4; //Fonction
- $cle2 = 0; //Nom
- $cle3 = 1; //Prenom
- $cle4 = 2; //LieuID
- }
- else if ($cleTri == "lieu") {
- $cle1 = 2; //LieuID
- $cle2 = 0; //Nom
- $cle3 = 1; //Prenom
- $cle4 = 4; //Fonction
-
- }
- else { //Tri par défaut (Nom, Prénom, LieuID, Fonction)
- $cle1 = 0; //Nom
- $cle2 = 1; //Prenom
- $cle3 = 2; //LieuID
- $cle4 = 4; //Fonction
- }
-
- //Tri du tableau complet
- if($typeTri == "d" || $typeTri == "D"){
- array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_DESC,
- $_SESSION["UsagerLieuLDAP"][$cle2], SORT_DESC,
- $_SESSION["UsagerLieuLDAP"][$cle3], SORT_DESC,
- $_SESSION["UsagerLieuLDAP"][$cle4], SORT_DESC,
- $_SESSION["UsagerLieuLDAP"][3],
- $_SESSION["UsagerLieuLDAP"][5]);
- }
- else{
- array_multisort($_SESSION["UsagerLieuLDAP"][$cle1], SORT_ASC,
- $_SESSION["UsagerLieuLDAP"][$cle2], SORT_ASC,
- $_SESSION["UsagerLieuLDAP"][$cle3], SORT_ASC,
- $_SESSION["UsagerLieuLDAP"][$cle4], SORT_ASC,
- $_SESSION["UsagerLieuLDAP"][3],
- $_SESSION["UsagerLieuLDAP"][5]);
- }
- return (true);
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // connextToPG($conn)
- // établit la connexion avec le serveur Postgresql
- ///////////////////////////////////////////////////////////////////////////////////////
- function connectToPG( $conn_str ){
- if( !$conn = pg_connect( $conn_str ) ) { bugFromPG( $conn ); };
- return $conn;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // bugFromPG($conn)
- // méthode appellée losrqu'on a un problème avec l'exécution d'une requête ou à établir
- // la connexion avec le serveur Postgresql.
- ///////////////////////////////////////////////////////////////////////////////////////
- function bugFromPG($conn){
- echo _("Probleme avec la BD PostgreSQL");
- echo pg_last_error($conn);
- //on quitte tous les script (pas de niasage)
- exit;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // changeUTF16($chaine)
- // méthode appellée pour convertir les lignes LDap d'UTF-8 à UTF-16
- //
- // IN: $chaine
- // OUT: retourne la chaine UTF-8 ou ISO-8859-1, convertie en UTF-16
- ///////////////////////////////////////////////////////////////////////////////////////
- function changeUTF16( $chaine ){
- return mb_convert_encoding( $chaine, "ISO-8859-1","UTF-8" )."\n" ;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // Met un space HTML lorsqu'il n'y aucune valeur a afficher
- ///////////////////////////////////////////////////////////////////////////////////////
- function convNoDataToHTMLSpace($value){
- if (($value=="") || (!isset($value))){
- return(" ");
- }
- else{
- return($value);
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fillArrFromDBStd($conn, $sqlstmt, $arrVal0 = NULL, $arrVal1 = NULL, ...)
- // remplit les tableaux de variables reçu en paramètre avec la valeur des
- // rangées retournées par la requête sql fournie en paramètre
- // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
- // que l'odre des champs dans la requête
- // [SUPPORTE 40 tableaux]
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $sqlstmt: requête SQL à exécuter
- // $arrVal1: 1er tableau à remplir
- // $arrVal2: 2e tableau à remplir
- // $arrValX: Xe tableau à remplir
- // OUT: -1: erreur lors de l'exécution de la requête
- // (int): nb de rangées résultantes de la requête
- ///////////////////////////////////////////////////////////////////////////////////////
- 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){
- $nbRow = -1;
-
- // tableau dynamique
- $nbArray = func_num_args() - 2;
- for( $i = 0; $i < $nbArray; $i++ ){
- $name = "arrVal" . $i;
- $args[ $i ] =& $$name;
-
- // S'assure que ce qui sera retourné sera au moins un tableau vide
- if( is_null( $args[ $i ] ) ){
- $args[ $i ] = array();
- }
- }
-
- // bd time
- $result = pg_query( $conn, $sqlstmt );
- if( $result > 0 ){
- $nbRow = pg_num_rows( $result );
- $nbLoop = min( $nbArray, pg_num_fields( $result ) );
-
- for( $iRow = 0; $iRow < $nbRow; $iRow++ ){
- for( $iCol = 0; $iCol < $nbLoop; $iCol++ ){
- $args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );
- }
- }
- pg_free_result( $result );
- }
- return $nbRow;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $arrVal0 = NULL, $arrVal1 = NULL, ...)
- // remplit les tableaux de variables reçus en paramètre avec la valeur des
- // rangées retournées par la requête sql fournie en paramètre. De plus
- // ce type de requête tient compte de la notion des pages. On peut donc
- // se positionner sur la Xe page de résultat directement
- // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
- // que l'odre des champs dans la requête
- // [SUPPORTE 40 tableaux]
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $sqlstmt: requête SQL à exécuter
- // $page_no: quelle page on veut se positionner
- // $pgSize: la grandeur des page (nb d'enregistrement par page)
- // $page_size: nb de page résultant de la requête
- // $nbRecordTotal: nb d'enregistrement résultant de la requête
- // $arrVal1: 1er tableau à remplir
- // $arrVal2: 2e tableau à remplir
- // $arrValX: Xe tableau à remplir
- // OUT: -1: erreur lors de l'exécution de la requête
- // (int >= 0): nb de rangées résultantes de la requête
- ///////////////////////////////////////////////////////////////////////////////////////
- function fillArrFromDBStdWithPg($conn, $sqlstmt, $page_no, $page_size, $nbPage, $nbRecordTotal, $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){
- $retour = -1;
-
- // Création d'un tableau dynamique de pointeurs vers les tableaux de valeurs reçues
- $nbArray = func_num_args()-2;
- for( $i = 0; $i < $nbArray; $i++ ){
- $name = "arrVal" . $i;
- $args[ $i ] = &$$name;
- }
-
- // Fait la requête en ôtant tout ce qui suit "ORDER BY"
- if( $result = pg_query( $conn, eregi_replace( " ORDER BY .*" , "", $sqlstmt ) ) ){
- $retour = 0;
- $nbRecordTotal = pg_num_rows( $result );
- if( $nbRecordTotal > 0 ){
- $nbPage = ceil( $nbRecordTotal / $page_size );
- $limit = $page_size;
- if (isset($page_no) )
- $offset = ( $page_no - 1 ) * $page_size;
- else
- $offset = 0;
-
- // on refait la requête avec des nouveaux paramètres
- $result = pg_query( $conn, $sqlstmt . " LIMIT " . $limit . " OFFSET " . $offset );
- $nbRow = pg_num_rows($result);
- $nbCol = min( $nbArray, pg_num_fields( $result ) );
- for( $iRow = 0; $iRow < $nbRow; $iRow++ ){
- for( $iCol=0; $iCol < $nbCol; $iCol++ ){
- $args[ $iCol ][ $iRow ] = pg_result( $result, $iRow, $iCol );
- }
- }
- pg_free_result( $result ); // Libère la mémoire inutilisée
- $retour = $nbRow;
- }
- }
-
- return $retour;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fillVarFromDBStd($conn, $sqlstmt, &$val1, &$val2, &$val3)
- // remplit les variables reçues en paramètre avec la valeur de la première
- // rangée du résultat de la requête (arrangez vous pour que la requête
- // sql n'ait qu'une seule rangée de résultat)
- // ATTENTION : l'ordre des variables spécifiées en paramètre doit être le même
- // que l'odre des champs dans la requête
- // [SUPPORTE 40 variables]
- // IN: $conn: objet de connexion avec la db (doit être déjà ouvert)
- // $sqlstmt: requête SQL à exécuter
- // $val1: 1ere variable à remplir
- // $val2: 2e variable à remplir
- // $valX: Xe variable à remplir
- ///////////////////////////////////////////////////////////////////////////////////////
- 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){
- // tableau dynamique
- $nbVariable = func_num_args()-2;
- for ($i=0; $i<$nbVariable; $i++){
- $name = "val" . $i;
- $args[$i]=&$$name;
- }
- //echo "fillVarFromDBStd: " . $sqlstmt . "<br>";
- $result = pg_query($conn, $sqlstmt);
- if (!$result){ bugFromPG($conn); }
- if($result>0){
- $nbRow=pg_num_rows($result);
- $nbLoop=min($nbVariable,pg_num_fields($result));
- if($nbRow==1){
- for($iCol=0; $iCol<$nbLoop; $iCol++){
- $args[$iCol]=pg_result($result, 0, $iCol);
- }
- pg_free_result($result);
- return(true);
- }
- pg_free_result($result);
- }
- return(false);
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // fixPGQuote($input)
- // fixe les quote pour que la requête demeure sécuritaire dans postgres..
- // IN: $input: string qu'on veut sécuriser
- // OUT: string sécurisé
- ///////////////////////////////////////////////////////////////////////////////////////
- function fixPGQuote($input){
- // Peut être remplacé par 'pg_escape_string' mais doit être utilisé avec une connexion à Postgres 7.2
- return (addslashes($input));
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // getWordStemRegExp()
- // Retourne une expression reguliere qui permet de reconnaitre le debut d'un mot
- // a l'interieur d'une chaine quelconque.
- // OUT: expression reguliere
- ///////////////////////////////////////////////////////////////////////////////////////
- function getWordStemRegExp(){
- // Tout caractere pouvant se trouver au debut d'un mot.
- return( "[ -.,?!:;([\']" );
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // accentInsensitiveLike()
- // Retourne une chaine pouvant remplacer une expression LIKE ou ILIKE afin
- // d'effectuer un "pattern matching".
- // Les expressions régulières sont beaucoup plus rapides que LIKE ou ILIKE
- // IN: $field_name Nom du champ
- // $field_value Valeur du champ
- // $case_insensitive true si l'on veut que la comparaison ne tienne pas compte
- // de la casse
- // OUT: clause SQL
- ///////////////////////////////////////////////////////////////////////////////////////
- function accentInsensitiveLike($field_name, $field_value, $case_insensitive = true) {
- $regexp_op = ( $case_insensitive == true ) ? "~*" : "~";
-
- // 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
- return "( " . $field_name . " " . $regexp_op . " E'^" . $field_value . "|[^\w]" . $field_value . "' )";
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // flushCourriel()
- // Envoit tous les courriels qui devraient etre envoyes
- ///////////////////////////////////////////////////////////////////////////////////////
- function flushCourriel(){
- //echo "Les courriels n'ont pas été flushés par le fichier 'forticFunctions.php'.";
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // formatCR($sTemp)
- // formate la sortie de manière à remplacer les CR par des <br> (les ENTERS)
- // IN: $sTemp: string à afficher
- // OUT: (string) le résultat du string une fois formaté
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatCR($sTemp){
- return (str_replace("\r","<br/>",$sTemp));
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // Set le format d'affichage pour les dates.
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatDate($dTemp, $format){
- if ( (isDate($dTemp)) || (isTimeStamp($dTemp)) ){
- return date($format,strtotime($dTemp));
- }
- else{
- return $dTemp;
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // Set le format d'affichage pour les dates.
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatDateInterval($dTemp1, $dTemp2, $style, $dateFormat, $timeFormat){
- if ($style=="date"){
- if ( ((isDate($dTemp1))||(isTimeStamp($dTemp1))) && ((isDate($dTemp2))||(isTimeStamp($dTemp2))) ){
- $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
- $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
- if ($sDateTemp1 != $sDateTemp2){
- $output = $sDateTemp1." "._("au")." ".$sDateTemp2;
- }
- else{
- $output = $sDateTemp1;
- }
- }
- elseif( (isDate($dTemp1))||(isTimeStamp($dTemp1)) ){
- $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
- $output = $sDateTemp1." "._("au")." "._("n/a");
- }
- elseif( (isDate($dTemp2))||(isTimeStamp($dTemp2)) ){
- $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
- $output = _("n/a")." "._("au")." ".$sDateTemp2;
- }
- else{
- $output = _("dates indeterminees");
- }
- }
- elseif ($style=="time"){
- if ( (isTimeStamp($dTemp1)) && (isTimeStamp($dTemp2)) ){
- $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
- $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
- $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));
- $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));
- if ($sDateTemp1 == $sDateTemp2){
- $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2;
- }
- else{
- $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." ".$sTimeTemp2." (".$sDateTemp1.")";
- }
- }
- elseif( (isTimeStamp($dTemp1))||(isTimeStamp($dTemp1)) ){
- $sDateTemp1 = date($dateFormat, strtotime($dTemp1));
- $sTimeTemp1 = date($timeFormat, strtotime($dTemp1));
- $output = $sDateTemp1." ".$sTimeTemp1." "._("a")." "._("n/a");
- }
- elseif( (isTimeStamp($dTemp2))||(isTimeStamp($dTemp2)) ){
- $sDateTemp2 = date($dateFormat, strtotime($dTemp2));
- $sTimeTemp2 = date($timeFormat, strtotime($dTemp2));
- $output = _("n/a")." "._("a")." ".$sDateTemp2." ".$sTimeTemp2;
- }
- else{
- $output = _("moment indetermine");
- }
- }
- return $output;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // function formatDateLimite($dTemp, $dTempDisplay, $classOK="", $classNOT="", $classHOPE="")
- // affiche la datelimite en couleur
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatDateLimite( $dTemp, $format, $classOK = "", $classNOT = "", $classHOPE = "" ){
- $output = "";
- $class = "";
- if( isDate( $dTemp ) ){
- $today = strtotime( date( "Y-m-d" ) );
- $limite = strtotime( $dTemp );
-
- // Si la date limite n'est pas arrivé ou qu'elle est aujourd'hui et qu'on ne reçoit pas de classe HOPE
- if( ( $today < $limite || ( $today == $limite && $classHOPE == "" ) ) && $classOK != "" ){
- $class = $classOK;
- // Si la date limite est dépassée
- } elseif( $today > $limite && $classNOT != "" ){
- $class = $classNOT;
- // Si la date limite est aujourd'hui
- } elseif( $today == $limite && $classHOPE != "" ){
- $class = $classHOPE;
- }
-
- $output = formatDate( $dTemp, $format );
- if( $class != "" ){
- $output = "<span class='" . $class . "'>" . $output . "</span>";
- }
- }
- return $output;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // function formatGabaritSub($sInput, $class=NULL)
- // formate la sortie pour qu'on puisse voir si c'est un sous-gabarit
- // IN: $sInput: t ou f : designant si system
- // OUT: (string) ce qu'on affiche sur la page
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatGabaritSub($sInput, $class=NULL){
- $state1=_("sous-gabarit");
- $state2=_("gabarit");
- if ($sInput=="t"){
- if ($class!=""){
- $output="<span class=\"".$class."\">".$state1."</span>";
- }
- else{
- $output=$state1;
- }
- }
- else{
- if ($class!=""){
- $output="<span class=\"".$class."\">".$state2."</span>";
- }
- else{
- $output=$state2;
- }
- }
- return $output;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // function formatGabaritSystem($sInput, $class=NULL)
- // formate la sortie pour qu'on puisse voir si c'est un gabarit system
- // IN: $sInput: t ou f : designant si system
- // OUT: (string) ce qu'on affiche sur la page
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatGabaritSystem($sInput, $class=NULL){
- $state="("._("Systeme").")";
- if ($sInput=="t"){
- if ($class!=""){
- $output="<span class=\"".$class."\">".$state."</span>";
- }
- else{
- $output=$state;
- }
- }
- return $output;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // formatHTML($sTemp)
- // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de
- // mot réservé propore au html.
- // IN: $sTemp: string à afficher
- // OUT: (string) le résultat du string une fois formaté
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatHTML($sTemp){
- return (htmlentities($sTemp));
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // formatJS($sTemp)
- // formate la sortie pour qu'on puisse l'afficher sur du html sans qu'elle n'utilise de
- // mot réservé propore au html.
- // IN: $sTemp: string à afficher
- // OUT: (string) le résultat du string une fois formaté
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatJS($sTemp){
- return (addslashes($sTemp));
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // Set le format d'affichage d'un nom.
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatName($sNom, $sPrenom){
- if (($sNom!="") && ($sPrenom!="")){
- return (strtoupper($sNom).", ".$sPrenom);
- }
- elseif ($sNom!=""){
- return (strtoupper($sNom));
- }
- elseif ($sPrenom!=""){
- return ($sPrenom);
- }
- else{
- return ( _("sans nom") );
- }
- }
-
- //S.C. 2007-03-28 demande #37 Ajout de la fonction formatNameLieu
- ///////////////////////////////////////////////////////////////////////////////////////
- // Set le format d'affichage d'un nom et le # lieu de travail
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatNameLieu($sNom, $sPrenom, $sLieu){
- if (($sNom!="") && ($sPrenom!="") && ($sLieu!="")){
- return (strtoupper($sNom).", ".$sPrenom." (".$sLieu.")");
- }
- if (($sNom!="") && ($sPrenom!="")){
- return (strtoupper($sNom).", ".$sPrenom);
- }
- elseif ($sNom!=""){
- return (strtoupper($sNom));
- }
- elseif ($sPrenom!=""){
- return ($sPrenom);
- }
- elseif ($sLieu!=""){
- return ($sLieu);
- }
- else{
- return ( _("vide") );
- }
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL)
- // formate le nombre d'inscription. Losrque c'est plein, ou pas plein, on a la possibilité
- // de changer le style sheet (couleur ou autres)
- // IN: $nbIns nombre de personne actuellement inscrit
- // $nbMax nombre maximal de personne
- // $classOK class si le nombre de personne permet l'inscription encore
- // $classNOT class si la session est pleine
- // OUT: (string) le résultat du string une fois formaté
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatNbInscription($nbIns, $nbMax, $classOK=NULL, $classNOT=NULL){
- unset($output);
- if (is_numeric($nbIns) && is_numeric($nbMax)){
- if ($nbIns < $nbMax){
- $class = $classOK;
- }
- else{
- $class = $classNOT;
- }
- //output
- if ($class!=""){
- $output = "<span class=\"".$class."\">".$nbIns."/".$nbMax."</span>";
- }
- else{
- $output = $nbIns."/".$nbMax;
- }
- }
- return $output;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // formatNote($sNote $class)
- // Set le format d'affichage pour les notes de sessions
- // IN: $sNote note à écrire
- // $class est-ce qu'il y a une classe auquel on veux lier (CSS)
- // OUT: (string) affichage du code avec l'atelier et le projet
- ///////////////////////////////////////////////////////////////////////////////////////
- function formatNote( $sNote, $class = "" ){
- if ( $sNote != "" ){
- $sNote = "(" . $sNote . ")";
- if ( $class != "" ){
- $sNote = "<span class='" . $class . "'>" . $sNote . "</span>";
- }
- }
-
- return $sNote;
- }
-
- ///////////////////////////////////////////////////////////////////////////////////////
- // formatParamString($sParam, $sParamValeur)
- // Set le format les parametre SQL et leurs valeurs
- // IN: $sParam: string contenant les parametres SQL separes par des virgules
- // $sParameValeur: string contenant les valeurs des parametres SQL separees par des virgules
- // OUT: (string) une bel…
Large files files are truncated, but you can click here to view the full file