<?php

/**
 *  Définition de la classe des champs supplémentaire
 *  Cette classe permet de gérer les champs supplémentaires au niveau de l'entête et des lignes du panier
 */
class CS
{

    /**
     * Définition des attributs des CS
     */
    
    // Attributs de base du CS
    protected $COD_TAB;
 // Table d'appartenance du CS
    protected $NUM_FIX;
 // Numéro du CS sur la table d'appartenance
    protected $NUM_VAR;
 // Numéro d'ordre d'affichage du CS sur la table d'appartenance
    protected $TYPE;
 // Type du CS
    protected $NOM;
 // Nom du CS
    protected $LIBELLE;
 // Libéllé du CS
    protected $VALEUR;
 // Valeur du CS
    protected $TAB_CTRL;
 // Table de contrôle du CS
    protected $TAB_SOUR;
 // Table d'initialisation du CS
    protected $CHP_SOUR;
 // N°CS de la table d'initialisation
    protected $VALUE_SOUR;
 // Valeur d'initialisation du CS
                              
    // Liste des attributs du type flag(F ou T)
    protected $OBLIG;
 // Flag indiquant si la saisie du CS est obligatoire ou non
    protected $NONDISPO;
 // Flag indiquant si le CS est masqué ou non
    protected $MODAPVAL;
 // Flag indiquant si le CS est modifiable après validation du document de rattachement du CS
    protected $NONMODIF;
 // Flag indiquant si le CS est modifiable ou non
    protected $NONDUPLI;
 // Flag indiquant si le CS doit être dupliqué lors de la duplication du document de rattachement du CS
    protected $CONTROLE;
 // Falg indiquant si le CS est soumis à un controle
    protected $CTRL_STD;
 // Si $is_control est à vrai, alors ce flag indiquant si le CS est soumis à un contrôle sur une table standard ou non
    protected $NEG_AUTO;
 // Flag indiquant si la saisie de valeur négative est autorisée
                             
    // Attributs utilisés pour définir le format du CS
    protected $FORMAT;
 // Type de donnée pour la valeur du CS => A (alphanumérique), N (numérique), D (date: selon format), T(Temps : hh:mm:ss), L(logique : 0/1), M(Mémo : référence sur la table mémo)
    protected $ALP_LONG;
 // Valeur maximale du CS
    protected $PE_LONG;
 // Défini la longueur de la partie entière pour les numériques
    protected $PD_LONG;
 // Défini la longueur de la partie décimale pour les numériques

    protected $DEVISE;
    // Dans le cas du format 1 (montant avec devise)
                            
    // Attributs utilisés uniquement si le CS est controlé par rapport à une table non standard. Si $is_control vaut 1 et $is_tab_std_ctrl vaut 0.
    protected $NOM_CODE;
 // Libelle de la colonne correspondant au code de la table de controle
    protected $NOM_LIB;
 // Libelle de la colonne correspondant au libelle de la table de controle
    protected $LIB_LONG;
 // Longueur maximale du libellé
    protected $contexte = '';

    protected $uniqueInfo = '';

    /**
     * Attributs statiques
     */
    // Liste des champs tels qu'ils existent dans la base HAPLUS sous forme de chaine de caractères
    protected static $liste_champ_CS = array(
        'NUM_FIX',
        'COD_TAB',
        'NUM_VAR',
        'TYPE',
        'NOM',
        'OBLIG',
        'NONDISPO',
        'MODAPVAL',
        'NONMODIF',
        'NONDUPLI',
        'LIBELLE',
        'FORMAT',
        'ALP_LONG',
        'PE_LONG',
        'PD_LONG',
        'CONTROLE',
        'CTRL_STD',
        'NOM_CODE',
        'NOM_LIB',
        'LIB_LONG',
        'NEG_AUTO',
        'TAB_DESTI',
        'CHP_DESTI',
        'TAB_SOUR',
        'CHP_SOUR',
        'COD_ENR',
        'VALEUR',
        'DEVISE',
    );

    /**
     * Constructeur des CS
     */
    public function __construct(&$array = array(), $code_table = '', $num_fix = null)
    {
        if ('' != $code_table && null != $num_fix)
            $array = & SqlCs::rqGetInfoCS($code_table, $num_fix)->Trouve1();
    //   print_r($array);
    //   print_r(CS::$liste_champ_CS);
    //   exit;

        if (is_array($array) && count($array) > 0)
            foreach (CS::$liste_champ_CS as & $nom_cs) // Pour chacun des champs composant le CS
                if (array_key_exists($nom_cs, $array)) { // Si le champ est présent dans le tableau
                                                  // Si le format est de type case à cocher alors on convertit la donnée au format 0/1
                    if ('FORMAT' == $nom_cs && 'L' == $array['FORMAT'])
                    {
                        
                        $array['VALEUR'] = BoolSql(array_key_exists('VALEUR', $array) ? $array['VALEUR'] : '');
                    }
                    // On initialise l'attribut correspondant de l'objet
                    $this->{$nom_cs} = & $array[$nom_cs];
                    
                }
    }

    /**
     * Méthodes get and set sur les attributs
     */
    
    // Méthodes GET
    public function &getCOD_TAB()
    {
        return $this->COD_TAB;
    }

    public function &getNUM_FIX()
    {
        return $this->NUM_FIX;
    }

    public function &getNUM_VAR()
    {
        return $this->NUM_VAR;
    }

    public function &getTYPE()
    {
        return $this->TYPE;
    }

    public function &getNOM()
    {
        return $this->NOM;
    }

    public function &getLIBELLE()
    {
        return $this->LIBELLE;
    }

    /**
     * Dossier 24450 Le retour de la donnée doit être avoir les espaces de supprimés en effet la remonté de l'information de numérique contient des espaces avant
     */
    public function &getVALEUR()
    {
        $this->VALEUR = trim($this->VALEUR);
        return $this->VALEUR;
    }

    public function &getTAB_CTRL()
    {
        return $this->TAB_CTRL;
    }

    public function &getTAB_SOUR()
    {
        return $this->TAB_SOUR;
    }

    public function &getCHP_SOUR()
    {
        return $this->CHP_SOUR;
    }

    public function &getVALUE_SOUR()
    {
        return $this->VALUE_SOUR;
    }

    public function &getOBLIG()
    {
        return $this->OBLIG;
    }

    public function &getNONDISPO()
    {
        return $this->NONDISPO;
    }

    public function &getMODAPVAL()
    {
        return $this->MODAPVAL;
    }

    public function &getNONMODIF()
    {
        return $this->NONMODIF;
    }

    public function &getNONDUPLI()
    {
        return $this->NONDUPLI;
    }

    public function &getCONTROLE()
    {
        return $this->CONTROLE;
    }

    public function &getCTRL_STD()
    {
        return $this->CTRL_STD;
    }

    public function &getNEG_AUTO()
    {
        return $this->NEG_AUTO;
    }

    public function &getFORMAT()
    {
        return $this->FORMAT;
    }

    public function &getALP_LONG()
    {
        return $this->ALP_LONG;
    }

    public function &getPE_LONG()
    {
        return $this->PE_LONG;
    }

    public function &getPD_LONG()
    {
        return $this->PD_LONG;
    }

    public function &getDEVISE()
    {
        return $this->DEVISE;
    }

    public function &getNOM_CODE()
    {
        return $this->NOM_CODE;
    }

    public function &getNOM_LIB()
    {
        return $this->NOM_LIB;
    }

    public function &getLIB_LONG()
    {
        return $this->LIB_LONG;
    }

    public function &getContexte()
    {
        return $this->contexte;
    }

    public function &getUniqueInfo()
    {
        return $this->uniqueInfo;
    }

    // Méthodes SET
    public function setCOD_TAB($value)
    {
        $this->COD_TAB = & $value;
    }

    public function setNUM_FIX($value)
    {
        $this->NUM_FIX = & $value;
    }

    public function setNUM_VAR($value)
    {
        $this->NUM_VAR = & $value;
    }

    public function setTYPE($value)
    {
        $this->TYPE = & $value;
    }

    public function setNOM($value)
    {
        $this->NOM = & $value;
    }

    public function setLIBELLE($value)
    {
        $this->LIBELLE = & $value;
    }

    public function setVALEUR($value)
    {
        $this->VALEUR = & $value;
    }

    public function setTAB_CTRL($value)
    {
        $this->TAB_CTRL = & $value;
    }

    public function setTAB_SOUR($value)
    {
        $this->TAB_SOUR = & $value;
    }

    public function setCHP_SOUR($value)
    {
        $this->CHP_SOUR = & $value;
    }

    public function setVALUE_SOUR($value)
    {
        $this->VALUE_SOUR = & $value;
    }

    public function setOBLIG($value)
    {
        $this->OBLIG = & $value;
    }

    public function setNONDISPO($value)
    {
        $this->NONDISPO = & $value;
    }

    public function setMODAPVAL($value)
    {
        $this->MODAPVAL = & $value;
    }

    public function setNONMODIF($value)
    {
        $this->NONMODIF = & $value;
    }

    public function setNONDUPLI($value)
    {
        $this->NONDUPLI = & $value;
    }

    public function setCONTROLE($value)
    {
        $this->CONTROLE = & $value;
    }

    public function setCTRL_STD($value)
    {
        $this->CTRL_STD = & $value;
    }

    public function setNEG_AUTO($value)
    {
        $this->NEG_AUTO = & $value;
    }

    public function setFORMAT($value)
    {
        $this->FORMAT = & $value;
    }

    public function setALP_LONG($value)
    {
        $this->ALP_LONG = & $value;
    }

    public function setPE_LONG($value)
    {
        $this->PE_LONG = & $value;
    }

    public function setPD_LONG($value)
    {
        $this->PD_LONG = & $value;
    }

    public function setDEVISE($value)
    {
        $this->DEVISE = & $value;
    }

    public function setNOM_CODE($value)
    {
        $this->NOM_CODE = & $value;
    }

    public function setNOM_LIB($value)
    {
        $this->NOM_LIB = & $value;
    }

    public function setLIB_LONG($value)
    {
        $this->LIB_LONG = & $value;
    }

    public function setContexte($contexte)
    {
        $this->contexte = $contexte;
    }

    public function setUniqueInfo($uniqueInfo)
    {
        $this->uniqueInfo = $uniqueInfo;
    }

    public function gereDataDonnee($typeElem, $valeurCS)
    {
        if ($array = DOA_Struct::GetListeObjetsPourObjetData($typeElem)) {
            $arraybis = $array[0];
            
            $this->setTYPE($arraybis['TYPE']);
            $this->setLIBELLE($arraybis['LIBELLE']);
            $this->setFORMAT($arraybis['FORMAT']);
            $this->setALP_LONG($arraybis['ALP_LONG']);
            $this->setPE_LONG($arraybis['PE_LONG']);
            $this->setPD_LONG($arraybis['PD_LONG']);
            $this->setCONTROLE($arraybis['CONTROLE']);
            $this->setCTRL_STD($arraybis['CTRL_STD']);
            $this->setNOM_CODE($arraybis['NOM_CODE']);
            $this->setNOM_LIB($arraybis['NOM_LIB']);
            $this->setNEG_AUTO($arraybis['NEG_AUTO']);
            $this->setLIB_LONG($arraybis['LIB_LONG']);
            
            $this->setNONDISPO(false);
            $this->setNONMODIF(false);
            $this->setVALEUR($valeurCS);
            
            $this->ControlValueCS(true, true);
            
            $controleCS = (BoolSql($arraybis['CTRL_STD']) ? 'zoom_CS_TABLE_STD' : 'zoom_TS_DON');
            ;
            
            if ($controleCS === 'zoom_TS_DON')
                $result_ctrl = CS::ControlValueTS($this->getTYPE(), $this->getVALEUR());
            else
                $result_ctrl = CS::ControlValueCS();
            
            return $result_ctrl;
        }
        return null;
    }

    /**
     * Méthodes utilisant des requêtes SQL
     */
    /**
     * Fonction permettant la mise à jour des lignes de CS
     *
     * @param array $array
     *            : Tableau contenant tous les attributs d'un CS
     * @return boolean
     */
    public static function UpdateCS(& $array)
    {
        $retour = true;
        
        if (is_array($array)) {
            $Pile = new PileSql(DB_OXAPROCDB);
            
            foreach ($array as & $ligne) {
                $ligne['VALEUR'] = ReplaceSautLigne($ligne['VALEUR']);    
                if ($ligne['FORMAT'] == 'D') {
                    if (strpos($ligne['VALEUR'], '/') === false) {
                        $dt = DateTime::createFromFormat('Ymd', $ligne['VALEUR']);
                        if ($dt) {
                            $ligne['VALEUR'] = $dt->format('d/m/Y');
                        }
                    }
                }            
                // POur le client N°56 les CS de type lieu et projet ne sont pas enregistré dans les CS mais dans SI_CODE et SCA_CODE de la ligne article
                if (CLT_CHAMPC == $_SESSION['Session_NumClient'] && ($ligne['NUM_FIX'] == 1000 || $ligne['NUM_FIX'] == 2000)) {
                    if ($ligne['NUM_FIX'] == 1000)
                        $reqSql = SqlPanier::MajPanierImput($_SESSION['id_user'], $_SESSION['id_panier'], $ligne['ID_LIGNE'], 'SI_CODE', $ligne['VALEUR']);
                    elseif ($ligne['NUM_FIX'] == 2000)
                        $reqSql = SqlPanier::MajPanierImput($_SESSION['id_user'], $_SESSION['id_panier'], $ligne['ID_LIGNE'], 'SCA_CODE', $ligne['VALEUR']);
                } else if (SqlCs::rqRechCsFixe($_SESSION['id_panier'], $ligne['ID_LIGNE'], $ligne['NUM_FIX'])->Trouve1()) {
                    $reqSql = SqlCs::rqMajCsFixe($ligne['NUM_FIX'], $ligne['ID_LIGNE'], $ligne['COD_TAB'], $ligne['VALEUR']);
                } else
                    $reqSql = SqlCs::rqCreCsFixe($_SESSION['id_panier'], $ligne['NUM_FIX'], $ligne['COD_TAB'], $ligne['ID_LIGNE'], $ligne['VALEUR']);
                
                $Pile->AddRequeteSql($reqSql);
            }
         
            $retour = $Pile->Commit();
        }
        return $retour;
    }

    /**
     * Fonction permettant de récupérer la valeur d'initialisation d'un CS lorsque celui-ci est initialisé par la
     * valeur d'un CS d'une autre table.
     * 
     * @param string $code_enr
     *            : Code identifiant l'enregistrement ex :Code d'un centre, Réf ART-FOURN etc....
     *            
     */
    public function initValueForCSpanier($code_enr)
    {
        // echo 'yanis'; exit;
        $result = & SqlCs::rqSelectValueCSforInit($this->TAB_SOUR, $this->CHP_SOUR, $code_enr)->Trouve1();
        $this->setVALEUR($result['VALEUR']);
    }

    /**
     * Fonction permettant de supprimer toutes les lignes de CS qui ne sont liées à aucune ligne de panier
     * et ce afin d'éviter les erreurs d'insertion lors des enregsitrements ou transferts de panier
     */
    public static function DeleteCSwithoutLigne()
    {
        rqDeleteCSwithoutLigne()->ExecuteSql();
    }

    /**
     * Autres méthodes
     */
    
    /**
     * Fonction contrôlant la valeur d'un CS renseigné par un utilisateur en fonction des attributs du CS
     * 
     * @param $controle_obligatoire boolean
     *            : Si true on contrôle le caractère obligatoire du champ
     * @param $controle_validite boolean
     *            : Si true on contrôle la validité de la donnée saisie
     * @return array : Tableau contenant le résultat du contrôle (0 ou 1) et un code erreur (si 0).
     *        
     */
    function ControlValueCS($controle_obligatoire = true, $controle_validite = true, $code_ste = null)
    {
        // Si le CS est défini comme masqué ou bien s'il n'est pas modifiable alors on n'effectue aucun contrôle dessus
        // et on renvoie le résultat de contrôle ok.
        if (BoolSql($this->NONDISPO) || (BoolSql($this->NONMODIF) && !$_SESSION['AuthModCSNonMod']))
            return array(
                1
            );
        
        // Si le champ est marqué comme obligatoire et qu'aucune valeur n'est présente
      
        // echo $controle_obligatoire;
        if ($controle_obligatoire && BoolSql($this->OBLIG) && (0 == mb_strlen($this->VALEUR) || NULL == $this->VALEUR))
        {
                return array(
                    0,
                    'NON_RENSEIGNE'
                );
            
        }
        // Si le contrôle s'effectue en mode total alors on contrôle en plus l'existence des données
        if ($controle_validite && (0 != mb_strlen($this->VALEUR) && NULL != $this->VALEUR)) {
            // Si le champ est renseigné
            if (0 != mb_strlen($this->VALEUR) && NULL != $this->VALEUR) {
                if (BoolSql($this->CONTROLE)) { // Si le champ est contrôlé par une table
                    if (BoolSql($this->CTRL_STD)) { // Si la table est standard
                        if ($this->getContexte() == 'DOA') {
                            $societe = null;
                            if ($reqDoaSoc = SqlDoaSociete::rqGetDoaSociete($this->getUniqueInfo())->TrouveTous()) {
                                $societe = null;
                                foreach ($reqDoaSoc as & $element)
                                    $societe[] = array(
                                        'type' => $element['TYPE_GS'],
                                        'value' => $element['CODE']
                                    );
                            }
                        } else 
                            $societe = $code_ste ?? $_SESSION['Session_SocUsr'];
                            
                        $result = & SqlCs::getRqForCS($this->TYPE, 'controle', $societe, $this->VALEUR)->Trouve1();
                    } else{
                        // Si la table n'est pas standard
                        
                        if (!$code_ste) {
                            $societe = $_SESSION['Session_SocUsr'];
                        }

                        $result = & SqlCs::rqIsValueTS_DON($this->TYPE, $this->VALEUR, $societe)->Trouve1();
                    }
                    
                    if (! is_array($result)) {
                        return array(
                            0,
                            'NON_EXISTANT'
                        );
                    }
                    if($this->FORMAT == 'D'){
                        $this->VALEUR = convertDateUserToSql($this->VALEUR);
                    }
                    return array(
                        1,
                        $result
                    );
                } else {
                    // SPEC 4241 : ajout des contrôles des nouveaux formats
                    // En fonction du format on adapte le type de contrôle
                    switch ($this->FORMAT) {
                        case 'A': // Si la donnée doit être alphanumérique
                                  // Si la chaine saisie est trop longue
                            if (mb_strlen($this->VALEUR) > $this->ALP_LONG) {
                                return array(
                                    0,
                                    'LONGUEUR_CHAINE_INCORRECTE'
                                );
                            }
                            break;
                        
                        case 'N': // Si la donnée doit être numérique
                                  
                            // Si le nombre saisi n'a pas le format attendu
                            if (! ControleSaisie::CtrlFormatNumber($this->VALEUR, $this->PE_LONG, $this->PD_LONG)) {
                                return array(
                                    0,
                                    'FORMAT_NOMBRE_INCORRECT'
                                );
                            }
                            
                            // Si le nombre est négatif alors que les nombres négatifs sont interdits pour ce champ
                            if ($this->VALEUR < 0 && ! BoolSql($this->NEG_AUTO)) {
                                return array(
                                    0,
                                    'SIGNE_NOMBRE_INCORRECT'
                                );
                            }
                            
                            break;
                        
                        case 'L': // Si la donnée doit être logique
                                  // Pas de contrôle sur les champs logiques (checkbox)
                            break;
                        
                        case 'M': // Si la donnée doit être un mémo
                                  // Si la longueur de la chaine est trop grande
                            if (! ControleSaisie::LengthControl($this->VALEUR, 3000)) {
                                return array(
                                    0,
                                    'LONGUEUR_CHAINE_INCORRECTE'
                                );
                            }
                            break;
                        
                        case 'H': // Si la donnée doit être une heure
                            if (! ControleSaisie::IsHourWithSecond($this->VALEUR)) {
                                return array(
                                    0,
                                    'FORMAT_HEURE_INCORRECTE'
                                );
                            }
                            break;
                        
                        case 'D': // Si la donnée doit être une date
                            $date = str_replace('/', '', $this->VALEUR);
                            if ($date == '00000000' || $date == '')
                                
                                $this->VALEUR = '00000000';
                            else if (! ControleSaisie::isDateValideFormat($this->VALEUR)) {
                                return array(
                                    0,
                                    'DATE_INCORRECTE'
                                );
                            } else // Si le format de la date est OK on transforme la date pour le format de la BDD
                                $this->VALEUR = convertDateUserToSql($this->VALEUR);
                            break;
                        
                        case 'U': // Si la donnée doit être une url
                            if (! ControleSaisie::LengthControl($this->VALEUR, 3000)) {
                                return array(
                                    0,
                                    'LONGUEUR_CHAINE_INCORRECTE'
                                );
                            }
                            if (! ControleSaisie::checkUrl($this->VALEUR)) {
                                return array(
                                    0,
                                    'URL_INCORRECT'
                                );
                            }
                            break;
                        
                        case 'E': // Si la donnée doit être un email
                            if (! ControleSaisie::LengthControl($this->VALEUR, 3000)) {
                                return array(
                                    0,
                                    'LONGUEUR_CHAINE_INCORRECTE'
                                );
                            }
                            $valeur = str_replace(',', ';', $this->VALEUR);
                            $tblmail = explode(';', $valeur);
                            $controleKO = 0;
                            foreach($tblmail as $mail){
                                $controleKO = !ControleSaisie::checkMail($mail);
                                if($controleKO)
                                {
                                    break;
                                }
                            }
                            
                            if ($controleKO) {
                                return array(
                                    0,
                                    'EMAIL_INCORRECT'
                                );
                            }
                            break;
                        
                        case '1': // Si la donnée doit être montant avec devise
                                    
                            // Si le nombre saisi n'a pas le format attendu
                            if (! ControleSaisie::CtrlFormatNumber($this->VALEUR, $this->PE_LONG, $this->PD_LONG)) {
                                return array(
                                    0,
                                    'FORMAT_NOMBRE_INCORRECT'
                                );
                            }
                            
                            // Si le nombre est négatif alors que les nombres négatifs sont interdits pour ce champ
                            if ($this->VALEUR < 0 && ! BoolSql($this->NEG_AUTO)) {
                                return array(
                                    0,
                                    'SIGNE_NOMBRE_INCORRECT'
                                );
                            }
                            
                            // S'il n'y a pas de devise
                            if ($this->DEVISE == '') {
                                return array(
                                    0,
                                    'DEVISE_NOMBRE_INCORRECT'
                                );
                            }
                            
                            break;
                    }
                }
            }
        }
        
        return array(
            1
        );
    }

    public static function ControlValueTS(& $type, & $code, $societe = '')
    {
        if ($reqSql = & SqlCs::rqGetListeValueForCSforTableNotStd($type, $code, '', true, false, $societe)->Trouve1())
            return array(
                0 => 1,
                1 => array(
                    'Libelle' => $reqSql['Libelle']
                )
            );
        
        return array(
            0 => 0,
            1 => 'NON_EXISTANT'
        );
    }

    /**
     * Fonction retournant le message d'erreur utilisateur découlant de la saisie d'un CS
     *
     * @param string $code_retour
     *            : code retour du contrôle
     * @param string $libelle_cs
     *            : Libéllé du CS sur lequel le contrôle a été effectué
     * @return string
     */
    public static function &alertUser($code_retour, $libelle_cs = '')
    {
        $retour = '';
        
        if ('' != $libelle_cs)
            $libelle_cs = $libelle_cs;
        
        switch ($code_retour) {
            case 'NON_EXISTANT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : La valeur saisie n\'existe pas, veuillez vérifier') : trad('La valeur saisie n\'existe pas, veuillez vérifier.');
                break;
            
            case 'NON_RENSEIGNE':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : Une valeur doit être obligatoirement saisie') : trad('Une valeur doit être obligatoirement saisie.');
                break;
            
            case 'LONGUEUR_CHAINE_INCORRECTE':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : La valeur saisie est trop longue, veuillez vérifier') : trad('La valeur saisie est trop longue, veuillez vérifier.');
                break;
            
            case 'FORMAT_HEURE_INCORRECTE':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : L\'heure saisie n\'a pas le format attendu, veuillez vérifier si le format est bien de type HH:MM:SS') : trad('L\'heure saisie n\'a pas le format attendu, veuillez vérifier si le format est bien de type HH:MM:SS.');
                break;
            
            case 'DATE_INCORRECTE':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : La date saisie n\'a pas le format attendu, veuillez vérifier') : trad('La date saisie n\'a pas le format attendu, veuillez vérifier.');
                break;
            
            case 'FORMAT_NOMBRE_INCORRECT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : Le nombre saisi n\'a pas le format attendu, veuillez vérifier') : trad('Le nombre saisi n\'a pas le format attendu, veuillez vérifier.');
                break;
            
            case 'SIGNE_NOMBRE_INCORRECT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : Les valeurs négatives ne sont pas autorisées, veuillez vérifier') : trad('Les valeurs négatives ne sont pas autorisées, veuillez vérifier.');
                break;
            
            case 'DEVISE_NOMBRE_INCORRECT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(' : La devise est obligatoire, veuillez vérifier') : trad('La devise est obligatoire, veuillez vérifier.');
                break;                
            
            case 'EMAIL_INCORRECT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(" : L'email saisi n'est pas valide, veuillez vérifier.") : trad("L'email saisi n'est pas valide, veuillez vérifier.");
                break;              
            
            case 'URL_INCORRECT':
                $retour = $libelle_cs != '' ? trad('Pour le champ ') . $libelle_cs . trad(" : L'url saisie n'est pas valide, veuillez vérifier. Voici un exemple d'url valide : https://oxatest.fr") : trad("L'url saisie n'est pas valide, veuillez vérifier. Voici un exemple d'url valide : https://oxatest.fr");
                break;
        }        
        
        return $retour;
    }

    /**
     * Fonction retournant pour une table donnée, un numéro de CS donnée et un enregistrement donné
     * les informations relatives au CS dont sa valeur
     *
     * @param string $table
     * @param int $num_cs
     * @param string $code_enr
     * @return array
     */
    public static function &getInfoCSDocument($table, & $num_cs, & $code_enr)
    {
        return SqlCs::rqSelectValueCSforInit($table, $num_cs, $code_enr)->Trouve1();
    }

    /**
     * Fonction permettant de retourner le libellé d'un CS
     *
     * @param string $societe
     *            : Societe pour laquelle le CS est recherché
     * @return string
     */
    public function &getLibelleCS(& $societe, & $valeur)
    {
        $result['Libelle'] = '';
        
        // Si la table est standard
        if (BoolSql($this->CTRL_STD))
            $result = & SqlCs::getRqForCS($this->TYPE, 'controle', $societe, $valeur)->Trouve1();
        // Si la table n'est pas standard
        else
            $result = & SqlCs::rqIsValueTS_DON($this->TYPE, $valeur)->Trouve1();
        
        return $result['Libelle'];
    }

    /**
     * Fonction retournant les numéros des champs suplémentaires contenant les valeurs des axes d'imputations liés au CDC
     *
     * @return string SQL
     */
    public static function &getListeCSFromCDC()
    {
        return SqlCs::rqGetListeCSFromCDC()->TrouveTous();
    }
    
    // spec 4437 - client 130 : 
    public static function getValueCSSectimp($societe, $sectimp)
    {
        if (Param::IsSISecto())
        {
            $code_enr = str_pad($societe, 7, ' ', STR_PAD_RIGHT) . $sectimp;
        }
        else
        {
            $code_enr = str_pad($sectimp, 7, ' ', STR_PAD_LEFT);
        }
        
        return sqlCS::rqGetValueCSSectimp($code_enr)->trouve1()['VALEUR'];
    }

    public function setIsObligNonModifNonDispo(& $id_panier, & $id_ligne)
    {
        $info_ligne = & SqlPanier::rqGetAllLignePanier($id_panier, $id_ligne)->Trouve1();
        $info_cs = & SqlCs::rqGetInfoCSDALigneForImputCdc('DA_LIGNE', $this->NUM_FIX)->Trouve1();
        $nom_cs = explode('_', $info_cs['CODEDICO']);
        $info_propriete_csObl = & SqlCs::rqGetParamCSForCDCImput($info_ligne['CDC_CODE'], 'NCS_CODECOMP_' . $nom_cs[3] . '_OBLIG')->Trouve1();
        $this->setOBLIG(BoolSql($info_propriete_csObl['VALEUR']));
        $info_propriete_csMod = & SqlCs::rqGetParamCSForCDCImput($info_ligne['CDC_CODE'], 'NCS_CODECOMP_' . $nom_cs[3] . '_MODIF')->Trouve1();
        $this->setNONMODIF(BoolSql($info_propriete_csMod['VALEUR']));
        $info_propriete_csAff = & SqlCs::rqGetParamCSForCDCImput($info_ligne['CDC_CODE'], 'NCS_CODECOMP_' . $nom_cs[3] . '_AFF')->Trouve1();
        $this->setNONDISPO(BoolSql($info_propriete_csAff['VALEUR']));
    }
    
    public static function generateXMLCS($code_table, $tag_xsl, $popup_ctrl = 'gestion_cs_panier.php', $form, $ligne_exists = true, $contexte = null, $codeEnr = null, $code_ste = null)
    {
        $listeCS = & SqlCs::rqGetInfoCS($code_table)->TrouveTous();
        if($code_table == 'DOA')
        {
            $codeEnr = str_pad($codeEnr, 9, '0', STR_PAD_LEFT);
        }
        
        if (is_array($listeCS)) 
        {
            $i = 0;
            foreach ($listeCS as & $ligne) 
            {
               /* $ligne['NONMODIF'] = true;
                // Dans le contexte de modification de document depuis le module signature on prend on compte
                // la propriété des CS : 'Modifiable en signature ?'
                if (('signature' == $contexte || 'signerModifDocument' == $contexte) && !BoolSql($ligne['MODIFSIGN']))
                {
                    $ligne['NONMODIF'] = true;
                }
                else if (('signature' == $contexte || 'signerModifDocument' == $contexte) && BoolSql($ligne['MODIFSIGN']))
                {
                    $ligne['NONMODIF'] = false;
                }
                */

                if ($ligne_exists) 
                {
                    $result = SqlCs::rqGetValCsDonForNumFix($code_table, '', '', $codeEnr, $ligne['NUM_FIX'])->Trouve1();
                    $ligne['VALEUR'] = $result['VALEUR'];
                    if($ligne['TBLSECTO']){
                        $ligne['VALEUR'] = substr($result['VALEUR'], 7) === false ? '' : substr($result['VALEUR'], 7);
                    }
                    if($ligne['TYPE'] == 'MEMO')
                    {
                        $ligne['VALEUR'] = Memos::get($result['VALEUR']);
                    }
                } 
                else if (! array_key_exists('VALEUR', $ligne))
                {
                    $ligne['VALEUR'] = '';
                }
                            
                if ('D' == $ligne['FORMAT'])
                {
                    if(strstr($ligne['VALEUR'], '/') == false){
                        $ligne['VALEUR'] = convertDateSqlToFr($ligne['VALEUR']);
                    }
                }
                if($ligne['FORMAT'] == 'U' || $ligne['FORMAT'] == 'E')
                {
                    $ligne['ALP_LONG'] = '3000';
                }
                if($ligne['FORMAT'] == 'M')
                {
                    $ligne['VALEUR'] = $ligne['VALEUR'] ?? '';
                }
                            
                if ($ligne['VALEUR'] != '' && BoolSql($ligne['CONTROLE']) && ! BoolSql($ligne['CTRL_STD']))
                {   
                    if ($lib = & SqlCs::rqGetLibCS($ligne['VALEUR'], $ligne['TYPE'], (BoolSql($ligne['TBLSECTO']) ? ($code_ste ?? $panierEntete->getCODE_STE()) : ''))->Trouve1())
                    {
                        $ligne['libelle_valeur'] = $lib['LIB01DICO'];
                    }
                    else
                    {
                        $ligne['libelle_valeur'] = '';
                    }
                }
                
                $j = 0;
                                        
                $popup_ctrl_onblur = $popup_ctrl;
                $bloc_name = '';
                                        
                //$pointeur = & $listeCS['ListeCS']['CS'][$i];
                                        
                foreach ($ligne as $key => & $value) 
                {
                    $inputValuetest =  'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_VALEUR' . $bloc_name;
                    $pointeur['attributs'][$j] = array(
                        '!name' => $key, // Nom du CS
                        '!value' => $value, // Valeur du CS
                        '!cle' => 'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_' . $key, // Identifiant du CS
                        '!popup_ctrl' => $popup_ctrl, // Page cible lorsque l'utilisateur appelle un zoom sur un CS
                        '!name_champ_input' => 'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_VALEUR' . $bloc_name, // Nom du champ imput pour le CS
                        '!name_champ_libelle' => 'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_LIBELLE_VALUE', // Libellé de la valeur du CS
                        '!UserAuthModCSNonMod' => $_SESSION['AuthModCSNonMod'], // Droit indiquant si l'utilisateur peut modifier le CS même si celui-ci n'est pas modifiable
                    );
                    
                    if($ligne['FORMAT']=='1' && $key == 'FORMAT'){
                        $pointeur['attributs'][$j]['id_info_sup'] = 'devise_CS_' . $tag_xsl . '_' .$ligne['NUM_FIX'];
                        $pointeur['attributs'][$j]['value_info_sup'] = array(
                            '!id' => 'select_'.$pointeur['attributs'][$j]['id_info_sup'],
                            '!value' => $panierEntete->getCOD_DEV() ?? $_SESSION['DEVISE_BASE'],
                            '!name' => $pointeur['attributs'][$j]['id_info_sup'],
                            'options' => $listeDevises
                        );
                    }
                    
                    if($ligne['FORMAT']=='D')
                    {
                        $pointeur['attributs'][$j]['!onclick'] = "CL.show(null,document.{$form}.{$inputValuetest},null,-80);";
                    }
                    
                    if($ligne['FORMAT']=='U')
                    {
                        $pointeur['attributs'][$j]['!onclick'] = 'openUrl(\'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_VALEUR\')';
                        
                    }
                    
                    if($ligne['FORMAT']=='E')
                    {
                        $pointeur['attributs'][$j]['!onclick'] = 'openMail(\'CS_' . $tag_xsl . '_' . $ligne['NUM_FIX'] . '_VALEUR\')';
                    }
                    
                    if (0 == $j) // Construction de la liste globale de référence des identifiant des CS présents
                        $liste_numfix .= $ligne['NUM_FIX'] . '|';
                        
                        $j ++;
                }
                
                // On ajoute les actions associées aux champs
                // $popup_ctrl_onblur = gestion_cs_panier.php
                if (BoolSql($ligne['CONTROLE'])) {
                    // Ajout de l'action contrôlant la saisie d'un champ soumis à un contrôle
                    $zoom = (BoolSql($ligne['CTRL_STD']) ? 'zoom_CS_TABLE_STD' : 'zoom_TS_DON');
                    $type = htmlentities(urlencode($ligne['TYPE']));
                    $onblur = "if(this.value!=''){Traite('{$popup_ctrl_onblur}?action=SelectValueCS&champ=CS_{$tag_xsl}_{$ligne['NUM_FIX']}_VALEUR$bloc_name&controle=$zoom&type=$type',this.form['CS_{$tag_xsl}_{$ligne['NUM_FIX']}_VALEUR$bloc_name']);}";
                    $onblur .= " else{SetInnerHTML('CS_{$tag_xsl}_{$ligne['NUM_FIX']}_LIBELLE_VALUE','');} ";
                    
                    // Ajout de l'action de zoom sur la liste des valeurs possible d'un CS
                    $champ = "CS_{$tag_xsl}_{$ligne['NUM_FIX']}_VALEUR$bloc_name";
                    $onclick = "Traite(\"{$popup_ctrl}?action={$zoom}&TYPE={$type}&champ={$champ}&LIBELLE=" . htmlentities(urlencode($ligne['NOM'])) . "&form={$form}&controle={$zoom}&type={$type}'\",document.{$form}.{$champ});";
                    
                    $pointeur['actions'] = array(
                        '!onblur' => $onblur,
                        '!onclick' => $onclick
                    );
                }
                
                $arrayCS['ListeCS']['CS'][$i] = $pointeur;
                $pointeur=[];
                
                $i ++;
            }
        }

        return $arrayCS;
    }

    public static function getValuesCS($code_table, $tag_xsl = 0,$getReturn = 0)
    {
        $liste_cs_nouvelle_ligne = array();
        $liste_cs = & SqlCs::rqGetInfoCS($code_table)->TrouveTous();
        
        foreach($liste_cs as $cs)
        {
            $cs['VALEUR'] = getValueCS('CS_'.$tag_xsl.'_'.$cs['NUM_FIX'].'_VALEUR');
            $CS = new CS($cs);
            $code_retour = $CS->ControlValueCS();
            if (0 == $code_retour[0]) {
                if(!$getReturn)
                {
                    Affichage::messageJS(CS::alertUser($code_retour[1], $cs['NOM']));
                         exit();
                }else
                    return false;
            }
            
            $liste_cs_nouvelle_ligne[] = $cs;
        }
        
        return $liste_cs_nouvelle_ligne;
        
    }
}