| 22 |
*/ |
*/ |
| 23 |
class om_dbform extends dbForm { |
class om_dbform extends dbForm { |
| 24 |
|
|
|
/** |
|
|
* |
|
|
*/ |
|
|
var $om_formulaire = "om_formulaire"; |
|
|
|
|
|
/** |
|
|
* Constructeur |
|
|
* |
|
|
* @param string $id |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
|
*/ |
|
|
function constructeur($id, &$db, $DEBUG = false) { |
|
|
if (defined('REST_REQUEST')) { // $this->REST |
|
|
logger::instance()->display_log = false; |
|
|
} |
|
|
// |
|
|
if (isset($GLOBALS["f"])) { |
|
|
$this->f = $GLOBALS["f"]; |
|
|
} |
|
|
// Le framework REST est utilisee |
|
|
$this->errors = array(); |
|
|
|
|
|
// Affectation de l'identifiant de base de donnees dans l'attribut db |
|
|
// de l'objet |
|
|
$this->db = $db; |
|
|
// Inclusion du fichier de parametre de la table pour recuperer les |
|
|
// trois parametres permettant de construire la requete de selection |
|
|
// $champs - clause select |
|
|
// $tableSelect - clause from |
|
|
// $selection - clause where |
|
|
$fichier = "../sql/".$this->db->phptype."/".$this->table.".form.inc.php"; |
|
|
if (file_exists($fichier)) { |
|
|
include $fichier; |
|
|
} else { |
|
|
$fichier = "../sql/".$this->db->phptype."/".$this->table.".form.inc"; |
|
|
if (file_exists($fichier)) { |
|
|
include $fichier; |
|
|
} |
|
|
} |
|
|
|
|
|
// Sauvegarde des actions contextuelles supplementaires |
|
|
if (isset($portlet_actions)) { |
|
|
$this->actions_sup = $portlet_actions; |
|
|
} |
|
|
|
|
|
// Concatenation des champs pour constitution de la clause select |
|
|
$listeChamp = ""; |
|
|
foreach ($champs as $elem) { |
|
|
$listeChamp .= $elem.","; |
|
|
} |
|
|
// Suppresion de la derniere virgule |
|
|
$listeChamp = substr($listeChamp, 0, strlen($listeChamp)-1); |
|
|
// Initialisation de la variable selection |
|
|
if (!isset($selection)) { |
|
|
$selection = ""; |
|
|
} |
|
|
// Concatenation de la requete de selection |
|
|
$sql = " select ".$listeChamp." from ".$tableSelect." "; |
|
|
// Si mode ajout |
|
|
if ($id == "]") { |
|
|
// Remplacement du 'and' par 'where' dans la varibale $selection |
|
|
$selection = ltrim($selection); |
|
|
if (strtolower(substr($selection, 0, 3)) == "and") { |
|
|
$selection = " where ".substr($selection, 4, strlen($selection)); |
|
|
} |
|
|
} else { // Si mode modification ou suppression |
|
|
// Clause where en fonction du type de la cle primaire |
|
|
if ($this->typeCle == "A") { |
|
|
$sql .= " where ".$this->table.".".$this->clePrimaire." like '".$id."' "; |
|
|
} else { |
|
|
$sql .= " where ".$this->table.".".$this->clePrimaire." = ".$id." "; |
|
|
} |
|
|
} |
|
|
$sql .= " ".$selection." "; |
|
|
// Execution de la requete |
|
|
$res = $db->limitquery($sql, 0, 1); |
|
|
// Logger |
|
|
$this->addToLog("constructeur(): db->limitquery(\"".str_replace(",",", ",$sql)."\", 0, 1);", VERBOSE_MODE); |
|
|
// Si une erreur survient |
|
|
if (database::isError($res, true)) { |
|
|
// Appel de la methode de recuperation des erreurs |
|
|
$this->erreur_db($res->getDebugInfo(), $res->getMessage(), $tableSelect); |
|
|
} else { |
|
|
// Recuperation des informations sur la structure de la table |
|
|
// ??? compatibilite POSTGRESQL (len = -1, type vide, flags vide) |
|
|
$info = $res->tableInfo(); |
|
|
// Initialisation de la cle a 0 |
|
|
$i = 0; |
|
|
// Recuperation du nom de chaque champ dans l'attribut 'champs' |
|
|
foreach ($info as $elem) { |
|
|
$this->champs[$i++] = $elem['name']; |
|
|
} |
|
|
// ??? Le $i devrait etre initialises a 0 pour chaque attribut suivant |
|
|
// Recuperation de la taille de chaque champ dans l'attibut 'longueurMax' |
|
|
foreach ($info as $elem) { |
|
|
$this->longueurMax[$i++] = $elem['len']; |
|
|
} |
|
|
// Recuperation du type de chaque champ dans l'attribut 'type' |
|
|
// ??? Non utilise |
|
|
foreach ($info as $elem) { |
|
|
$this->type[$i++] = $elem['type']; |
|
|
} |
|
|
// Recuperation du flag de chaque champ dans l'attribut 'flags' |
|
|
// ??? Non utilise |
|
|
foreach ($info as $elem) { |
|
|
$this->flags[$i++] = $elem['flags']; |
|
|
} |
|
|
// Recuperation de l'enregistrement resultat de la requete |
|
|
while ($row =& $res->fetchRow()) { |
|
|
// Initialisation de la cle a 0 |
|
|
$i = 0; |
|
|
// Recuperation de la valeur de chaque champ dans l'attribut 'val' |
|
|
foreach ($row as $elem) { |
|
|
$this->val[$i] = $elem; |
|
|
if (defined('REST_REQUEST')) { // $this->REST |
|
|
$this->valF[$this->champs[$i]] = $elem; |
|
|
} |
|
|
$i++; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
/** |
|
|
* Cette methode permet d'executer l'ajout (MODE 'insert') de l'objet dans |
|
|
* la base de donnees. |
|
|
* |
|
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
|
*/ |
|
|
function ajouter($val, &$db = NULL, $DEBUG = false) { |
|
|
// Logger |
|
|
$this->addToLog("ajouter() - begin", EXTRA_VERBOSE_MODE); |
|
|
// Mutateur de valF |
|
|
$this->setValF($val); |
|
|
// Mutateur de valF specifique a l'ajout |
|
|
$this->setValFAjout($val); |
|
|
// Verification de la validite des donnees |
|
|
$this->verifier($val, $db, $DEBUG); |
|
|
// Verification specifique au MODE 'insert' de la validite des donnees |
|
|
$this->verifierAjout($val, $db); |
|
|
// Verification du verrou |
|
|
$this->testverrou(); |
|
|
// Si les verifications precedentes sont correctes, on procede a |
|
|
// l'ajout, sinon on ne fait rien et on affiche un message d'echec |
|
|
if ($this->correct) { |
|
|
// Appel au mutateur pour le calcul de la cle primaire (si la cle |
|
|
// est automatique) specifique au MODE 'insert' |
|
|
$this->setId($db); |
|
|
// Execution du trigger 'before' specifique au MODE 'insert' |
|
|
// Le premier parametre est vide car en MODE 'insert' |
|
|
// l'enregistrement n'existe pas encore donc il n'a pas |
|
|
// d'identifiant |
|
|
$this->triggerajouter("", $db, $val, $DEBUG); |
|
|
// Execution de la requete d'insertion des donnees de l'attribut |
|
|
// valF de l'objet dans l'attribut table de l'objet |
|
|
$res = $db->autoExecute(DB_PREFIXE.$this->table, $this->valF, DB_AUTOQUERY_INSERT); |
|
|
// Si une erreur survient |
|
|
if (database::isError($res, true)) { |
|
|
// Appel de la methode de recuperation des erreurs |
|
|
$this->erreur_db($res->getDebugInfo(), $res->getMessage(), ''); |
|
|
} else { |
|
|
// Log |
|
|
$this->addToLog(_("Requete executee"), VERBOSE_MODE); |
|
|
// Log |
|
|
$message = _("Enregistrement")." ".$this->valF[$this->clePrimaire]." "; |
|
|
$message .= _("de la table")." \"".$this->table."\" "; |
|
|
$message .= "[ ".$db->affectedRows()." "; |
|
|
$message .= _("enregistrement(s) ajoute(s)")." ]"; |
|
|
$this->addToLog($message, VERBOSE_MODE); |
|
|
// Message de validation |
|
|
$this->addToMessage(_("Vos modifications ont bien ete enregistrees.")."<br/>"); |
|
|
// Mise en place du verrou pour ne pas valider plusieurs fois |
|
|
// le meme formulaire |
|
|
$this->verrouille(); |
|
|
// Execution du trigger 'after' specifique au MODE 'insert' |
|
|
// Le premier parametre est vide car en MODE 'insert' |
|
|
// l'enregistrement n'existe pas encore donc il n'a pas |
|
|
// d'identifiant |
|
|
$this->triggerajouterapres("", $db, $val, $DEBUG); |
|
|
} |
|
|
} else { |
|
|
// Message d'echec (saut d'une ligne supplementaire avant le |
|
|
// message pour qu'il soit mis en evidence) |
|
|
$this->addToMessage("<br/>"._("SAISIE NON ENREGISTREE")."<br/>"); |
|
|
} |
|
|
// Logger |
|
|
$this->addToLog("ajouter() - end", EXTRA_VERBOSE_MODE); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Cette methode permet d'executer la modification (MODE 'update') de |
|
|
* l'objet dans la base de donnees. |
|
|
* |
|
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
|
*/ |
|
|
function modifier($val = array(), &$db = NULL, $DEBUG = false) { |
|
|
// Logger |
|
|
$this->addToLog("modifier() - begin", EXTRA_VERBOSE_MODE); |
|
|
// Recuperation de la valeur de la cle primaire de l'objet |
|
|
if(isset($val[$this->clePrimaire])) |
|
|
$id = $val[$this->clePrimaire]; |
|
|
else |
|
|
$id=$this->id; |
|
|
// Appel au mutateur de l'attribut valF de l'objet |
|
|
$this->setValF($val); |
|
|
// Verification de la validite des donnees |
|
|
$this->verifier($val, $db, $DEBUG); |
|
|
// Verification du verrou |
|
|
$this->testverrou(); |
|
|
// Si les verifications precedentes sont correctes, on procede a |
|
|
// la modification, sinon on ne fait rien et on affiche un message |
|
|
// d'echec |
|
|
if ($this->correct) { |
|
|
// Execution du trigger 'before' specifique au MODE 'update' |
|
|
$this->triggermodifier($id, $db, $val, $DEBUG); |
|
|
// Execution de la requête de modification des donnees de l'attribut |
|
|
// valF de l'objet dans l'attribut table de l'objet |
|
|
$res = $db->autoExecute(DB_PREFIXE.$this->table, $this->valF, DB_AUTOQUERY_UPDATE, $this->getCle($id)); |
|
|
// Si une erreur survient |
|
|
if (database::isError($res, true)) { |
|
|
// Appel de la methode de recuperation des erreurs |
|
|
$this->erreur_db($res->getDebugInfo(), $res->getMessage(), ''); |
|
|
} else { |
|
|
// Log |
|
|
$this->addToLog(_("Requete executee"), VERBOSE_MODE); |
|
|
// Log |
|
|
$message = _("Enregistrement")." ".$id." "; |
|
|
$message .= _("de la table")." \"".$this->table."\" "; |
|
|
$message .= "[ ".$db->affectedRows()." "; |
|
|
$message .= _("enregistrement(s) mis a jour")." ]"; |
|
|
$this->addToLog($message, VERBOSE_MODE); |
|
|
// Message de validation |
|
|
if ($db->affectedRows() == 0) { |
|
|
$this->addToMessage(_("Attention vous n'avez fait aucune modification.")."<br/>"); |
|
|
} else { |
|
|
$this->addToMessage(_("Vos modifications ont bien ete enregistrees.")."<br/>"); |
|
|
} |
|
|
// Mise en place du verrou pour ne pas valider plusieurs fois |
|
|
// le meme formulaire |
|
|
$this->verrouille(); |
|
|
// Execution du trigger 'after' specifique au MODE 'update' |
|
|
$this->triggermodifierapres($id, $db, $val, $DEBUG); |
|
|
} |
|
|
} else { |
|
|
// Message d'echec (saut d'une ligne supplementaire avant le |
|
|
// message pour qu'il soit mis en evidence) |
|
|
$this->addToMessage("<br/>"._("SAISIE NON ENREGISTREE")."<br/>"); |
|
|
} |
|
|
// Logger |
|
|
$this->addToLog("modifier() - end", EXTRA_VERBOSE_MODE); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Cette methode permet d'executer la suppression (MODE 'delete') de |
|
|
* l'objet dans la base de donnees. |
|
|
* |
|
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
|
*/ |
|
|
function supprimer($val = array(), &$db = NULL, $DEBUG = false) { |
|
|
// Logger |
|
|
$this->addToLog("supprimer() - begin", EXTRA_VERBOSE_MODE); |
|
|
// Recuperation de la valeur de la cle primaire de l'objet |
|
|
if(isset($val[$this->clePrimaire])) |
|
|
$id = $val[$this->clePrimaire]; |
|
|
else |
|
|
$id=$this->id; |
|
|
// Verification des contraintes d'integrite specifique au MODE 'delete' |
|
|
$this->correct=true; |
|
|
$this->cleSecondaire($id, $db, $val, $DEBUG); |
|
|
// Verification du verrou |
|
|
$this->testverrou(); |
|
|
// Si les verifications precedentes sont correctes, on procede a |
|
|
// la suppression, sinon on ne fait rien et on affiche un message |
|
|
// d'echec |
|
|
if ($this->correct) { |
|
|
// Execution du trigger 'before' specifique au MODE 'delete' |
|
|
$this->triggersupprimer($id, $db, $val, $DEBUG); |
|
|
// Construction de la requete de suppression de l'objet dans |
|
|
// l'attribut table de l'objet |
|
|
$sql = "delete from ".DB_PREFIXE.$this->table." where ".$this->getCle($id); |
|
|
// Execution de la requete de suppression de l'objet |
|
|
$res = $db->query($sql); |
|
|
// Logger |
|
|
$this->addToLog("supprimer(): db->query(\"".$sql."\");", VERBOSE_MODE); |
|
|
// Si une erreur survient |
|
|
if (database::isError($res, true)) { |
|
|
// Appel de la methode de recuperation des erreurs |
|
|
$this->erreur_db($res->getDebugInfo(), $res->getMessage(), ''); |
|
|
} else { |
|
|
// Log |
|
|
$message = _("Enregistrement")." ".$id." "; |
|
|
$message .= _("de la table")." \"".$this->table."\" "; |
|
|
$message .= "[ ".$db->affectedRows()." "; |
|
|
$message .= _("enregistrement(s) supprime(s)")." ]"; |
|
|
$this->addToLog($message, VERBOSE_MODE); |
|
|
// Message de validation |
|
|
$this->addToMessage(_("La suppression a ete correctement effectuee.")."<br/>"); |
|
|
// Mise en place du verrou pour ne pas valider plusieurs fois |
|
|
// le meme formulaire |
|
|
$this->verrouille(); |
|
|
// Execution du trigger 'after' specifique au MODE 'delete' |
|
|
$this->triggersupprimerapres($id, $db, $val, $DEBUG); |
|
|
} |
|
|
} else { |
|
|
// Message d'echec (saut d'une ligne supplementaire avant le |
|
|
// message pour qu'il soit mis en evidence) |
|
|
$this->addToMessage("<br/>"._("SUPPRESSION NON EFFECTUEE")."<br/>"); |
|
|
} |
|
|
// Logger |
|
|
$this->addToLog("supprimer() - end", EXTRA_VERBOSE_MODE); |
|
|
} |
|
|
|
|
|
/** |
|
|
* Methode de verification de l'unicite d'une valeur pour chaque elements du tableau unique_key, |
|
|
* ainsi que l'unicite de la cle multiple unique_multiple_key. |
|
|
* |
|
|
* @param objet $db Objet Base de donnees |
|
|
*/ |
|
|
|
|
|
function checkUniqueKey() { |
|
|
$unique=true; |
|
|
//Verification des cles uniques |
|
|
if(!empty($this->unique_key)) { |
|
|
foreach ($this->unique_key as $constraint) { |
|
|
if(!is_array($constraint)) { |
|
|
if(!is_null ($this->valF[$constraint])) { |
|
|
if(!$this->isUnique($constraint,$this->valF[$constraint])) { |
|
|
$this->addToMessage( _("La valeur saisie dans le champ")." <span class=\"bold\">"); |
|
|
$this->addToMessage( (!defined('REST_REQUEST')) ? $this->form->lib[$constraint] : $constraint); // $this->REST |
|
|
$this->addToMessage( "</span> "._("existe deja, veuillez saisir une nouvelle valeur.")."<br/>"); |
|
|
$unique=false; |
|
|
} |
|
|
} |
|
|
} else { |
|
|
//Verification du groupe de champs uniques |
|
|
$oneIsNull=false; |
|
|
if(!empty($constraint)) { |
|
|
$valueMultiple=array(); |
|
|
foreach($constraint as $field) { |
|
|
$valueMultiple[]=$this->valF[$field]; |
|
|
if(is_null($this->valF[$field])) { |
|
|
$oneIsNull=true; |
|
|
} |
|
|
} |
|
|
if(!$oneIsNull) { |
|
|
if(!$this->isUnique($constraint,$valueMultiple)) { |
|
|
foreach($constraint as $field) { |
|
|
$temp[] = (!defined('REST_REQUEST')) ? $this->form->lib[$field] : $constraint; // $this->REST |
|
|
} |
|
|
$this->addToMessage( _("Les valeurs saisies dans les champs")." <span class=\"bold\">".implode("</span>, <span class=\"bold\">",$temp)."</span> "._("existent deja, veuillez saisir de nouvelles valeurs.")."<br/>"); |
|
|
$unique=false; |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
if(!$unique) { |
|
|
$this->correct = false; |
|
|
} |
|
|
} |
|
| 25 |
|
|
| 26 |
/** |
/** |
| 27 |
* Methode permettant de requeter la base afin de definir la validite du champ unique |
* Liste des métadonnées communes à l'ensemble des fichiers de l'application |
|
* |
|
|
* @param string $champ nom du champ unique |
|
|
* @param string $value valeur à inserer dans la colonne |
|
| 28 |
*/ |
*/ |
| 29 |
function isUnique($champ,$value) { |
var $metadata_global = array( |
| 30 |
//Test sur un groupe de champs |
"codeProduit" => "getCodeProduit", |
| 31 |
if(is_array($champ) and is_array($value)) { |
); |
|
$sql = 'SELECT count(*) FROM '.DB_PREFIXE.$this->table." WHERE ".implode(" = ? AND ",$champ)." = ?"; |
|
|
} else { |
|
|
//Test sur un champ |
|
|
$sql = 'SELECT count(*) FROM '.DB_PREFIXE.$this->table." WHERE ".$champ." = ?"; |
|
|
} |
|
|
if($this->getParameter('maj')) { |
|
|
$sql .= " AND ".$this->clePrimaire." \!= ".$this->valF[$this->clePrimaire]; |
|
|
} |
|
|
$nb = $this->db->getone($sql,$value); |
|
|
$this->addToLog("isUnique() : db->getone(\"".$sql."\");", VERBOSE_MODE); |
|
|
if (database::isError($nb, true)) { |
|
|
// Affichage de l'erreur |
|
|
$this->erreur_db($nb->getDebugInfo(), $nb->getMessage(), ''); |
|
|
return true; |
|
|
} else { |
|
|
//Si superieur a 0, pas unique |
|
|
if ($nb > 0) { |
|
|
return false; |
|
|
} else { |
|
|
return true; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
| 32 |
/** |
/** |
|
* Methode de verification des contraintes not null, |
|
|
* affiche une erreur si nul. |
|
| 33 |
* |
* |
|
* @param objet $db Objet Base de donnees |
|
| 34 |
*/ |
*/ |
| 35 |
function checkRequired() { |
var $om_formulaire = "om_formulaire"; |
|
foreach($this->required_field as $field) { |
|
|
//Ne test la cle primaire car n'a pas de valeur a l'ajout |
|
|
|
|
|
// la cle primaire est automatiquement cree |
|
|
if ($field == $this->clePrimaire) { |
|
|
continue; |
|
|
} |
|
|
|
|
|
$error = false; |
|
|
|
|
|
/* En ajout - verification des requis |
|
|
|
|
|
Fonctionnement formel de la condition: |
|
|
|
|
|
SI le champ n'existe pas (est 'unset') |
|
|
OU le champ est vide |
|
|
|
|
|
ALORS le formulaire n'est pas correct |
|
|
|
|
|
SINON le formulaire est correct |
|
|
|
|
|
Explication: |
|
|
|
|
|
Les champs verifies sont les champs requis. S'ils n'existent |
|
|
pas en ajout ou qu'ils sont vide, un message apparait a l'ecran |
|
|
avertissant l'utilisateur que certains champs doivent etre |
|
|
remplis. |
|
|
|
|
|
*/ |
|
|
if ($this->getParameter('maj') == 0 and |
|
|
(!isset($this->valF[$field]) or $this->valF[$field] == '')) { |
|
|
|
|
|
$error = true; |
|
|
$this->correct = false; |
|
|
|
|
|
/* En modification - verification des requis |
|
|
|
|
|
Fonctionnement formel de la condition: |
|
|
|
|
|
SI le champ existe (est 'set') |
|
|
ET le champ est vide |
|
|
|
|
|
ALORS le formulaire n'est pas correct |
|
|
|
|
|
SINON le formulaire est correct |
|
|
|
|
|
Explication: |
|
|
|
|
|
Les champs verifies sont les champs requis. S'ils existent |
|
|
et qu'ils sont vides alors un message apparait a l'ecran |
|
|
avertissant l'utilisateur que certains champs doivent etre |
|
|
remplis. Si ces champs sont tous saisis, le formulaire est |
|
|
correctement soumis. Par contre, si l'un des champs requis |
|
|
n'existe pas au moment de verification (il aurait ete 'unset'), |
|
|
il ne sera pas verifie, n'entrainera pas de formulaire incorrect |
|
|
et ne sera pas insere dans la base de donnees. |
|
|
|
|
|
Faire un 'unset' permet de ne pas mettre a jour certaines |
|
|
donnees sensibles en base a chaque soumission de formulaire. |
|
|
|
|
|
Faire un 'unset' permet egalement d'outre passer cette condition |
|
|
en mode de modification. On suppose qu'a l'ajout une valeur |
|
|
a ete inseree dans un champ, et qu'il n'est plus necessaire |
|
|
de verifier si ce champ est vide puisque sa valeur ne sera |
|
|
pas modifiee en base. Elle sera donc conservee. |
|
|
|
|
|
*/ |
|
|
} elseif ($this->getParameter('maj') == 1 |
|
|
and isset($this->valF[$field]) |
|
|
and $this->valF[$field] == '') { |
|
|
|
|
|
$error = true; |
|
|
$this->correct = false; |
|
|
} |
|
|
|
|
|
// ajout du message d'erreur |
|
|
if ($error == true) { |
|
|
//$this->msg .= _('Le champ').' <span class="bold">'.($this->form->lib[$field]!=""?$this->form->lib[$field]:_($field)).'</span> '._('est obligatoire').".<br/>"; |
|
|
$this->addToMessage( _('Le champ').' <span class="bold">'.((!defined('REST_REQUEST')) ? $this->form->lib[$field] :_($field)).'</span> '._('est obligatoire').".<br/>"); // $this->REST |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
* |
|
|
*/ |
|
|
function message() { |
|
|
|
|
|
// do not output anything in case of a REST request |
|
|
if (defined('REST_REQUEST')) { |
|
|
return; |
|
|
} |
|
|
|
|
|
if ($this->msg != "") { |
|
|
|
|
|
// |
|
|
if ($this->correct) { |
|
|
$class = "valid"; |
|
|
} else { |
|
|
$class = "error"; |
|
|
} |
|
|
$this->f->displayMessage($class, $this->msg); |
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
* Cette methode ne doit plus etre appelee, c'est 'message::isError($res)' |
|
|
* qui s'occupe d'afficher le message d'erreur et de faire le 'die()'. |
|
|
* |
|
|
* @deprecated |
|
|
*/ |
|
|
function erreur_db($debuginfo, $messageDB, $table) { |
|
|
if (!defined('REST_REQUEST')) { // $this->REST |
|
|
die(_("Erreur de base de donnees. Contactez votre administrateur.")); |
|
|
} else { |
|
|
$this->errors['db_debuginfo'] = $debuginfo; |
|
|
$this->errors['db_message'] = $messageDB; |
|
|
$this->addToLog("Erreur de BD pour table ".$table ." avec message: \"".$messageDB. |
|
|
"\" et debug info \"".$debuginfo."\"", VERBOSE_MODE); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
/** |
|
|
* |
|
|
*/ |
|
|
function addToLog($message, $type = DEBUG_MODE) { |
|
|
if (defined('REST_REQUEST')) { // dans le cas d'utilisation du REST $this->REST |
|
|
logger::instance()->log("REST request class ".get_class($this)." - ".$message, $type); |
|
|
} else { |
|
|
logger::instance()->log("class ".get_class($this)." - ".$message, $type); |
|
|
} |
|
|
} |
|
|
|
|
|
// }}} |
|
|
|
|
|
/** |
|
|
* Cette methode vide les valeurs des erreurs du tableau errors. |
|
|
*/ |
|
|
function clearErrors() { |
|
|
foreach (array_keys($this->errors) as $key) { |
|
|
$this->errors[$key] = ''; |
|
|
} |
|
|
} |
|
| 36 |
|
|
| 37 |
/** |
/** |
| 38 |
* Méthode pour convertir une date Y-m-d en d/m/Y |
* Retourne le code produit défini dans le paramétrage |
| 39 |
|
* @return string code produit (OpenADS) |
| 40 |
*/ |
*/ |
| 41 |
function dateDBToForm($date) { |
protected function getCodeProduit() { |
| 42 |
if($date == "") { |
return $this->f->getParameter("ged_code_produit"); |
|
return ""; |
|
|
} |
|
|
$dateFormat = new DateTime($date); |
|
|
return $dateFormat->format('d/m/Y'); |
|
|
} |
|
|
|
|
|
|
|
|
function init_select(&$form = null, &$db = null, $maj, $debug, $field, $sql, |
|
|
$sql_by_id, $om_validite = false, $multiple = false) { |
|
|
|
|
|
// MODE AJOUTER et MODE MODIFIER |
|
|
if ($maj < 2) { |
|
|
|
|
|
$contenu = array(); |
|
|
$res = $db->query($sql); |
|
|
$this->addToLog("setSelect(): db->query(\"".$sql."\");", VERBOSE_MODE); |
|
|
// verification d'une eventuelle erreur |
|
|
if (database::isError($res)) { |
|
|
die($res->getMessage().$sql); |
|
|
} else { |
|
|
// Initialisation du select |
|
|
$contenu[0][0] = ''; |
|
|
$contenu[1][0] = _('choisir')." "._($field); |
|
|
// |
|
|
$k=1; |
|
|
while($row =& $res->fetchRow()){ |
|
|
$contenu[0][$k] = $row[0]; |
|
|
$contenu[1][$k] = $row[1]; |
|
|
$k++; |
|
|
} |
|
|
// gestion des objets a date de validite |
|
|
if ($om_validite == true) { |
|
|
|
|
|
// ajout de la valeur manquante a $contenu si necessaire |
|
|
if ($maj == 1) { |
|
|
|
|
|
if (!in_array($this->form->val[$field], $contenu[0])) { |
|
|
|
|
|
// |
|
|
$this->getSelectOldValue($form, $maj, $db, $contenu, |
|
|
$sql_by_id, $field); |
|
|
} else { |
|
|
|
|
|
$empty = true; |
|
|
foreach ($this->form->val as $f => $value) { |
|
|
if (!empty($value)) { |
|
|
$empty = false; |
|
|
} |
|
|
} |
|
|
|
|
|
// |
|
|
if ($empty == true and |
|
|
$_POST[$field] != '') { |
|
|
|
|
|
$this->getSelectOldValue($form, $maj, $db, |
|
|
$contenu, $sql_by_id, |
|
|
$field, |
|
|
$_POST[$field]); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
// |
|
|
$form->setSelect($field, $contenu); |
|
|
} |
|
|
} |
|
|
|
|
|
// MODE SUPPRIMER et MODE CONSULTER |
|
|
if ($maj == 2 or $maj == 3) { |
|
|
// Initialisation du select |
|
|
$contenu[0][0] = ''; |
|
|
$contenu[1][0] = ''; |
|
|
|
|
|
if (isset($this->form->val[$field]) and |
|
|
!empty($this->form->val[$field]) and $sql_by_id) { |
|
|
// |
|
|
if ($multiple == true) { |
|
|
$val_field = "'".str_replace(",", "','",$this->form->val[$field])."'"; |
|
|
} else { |
|
|
$val_field = $this->form->val[$field]; |
|
|
} |
|
|
|
|
|
// ajout de l'identifiant recherche a la requete |
|
|
$sql_by_id = str_replace('<idx>', $val_field, $sql_by_id); |
|
|
|
|
|
// execution |
|
|
$result = $db->query($sql_by_id); |
|
|
$this->addToLog("setSelect(): db->query(".$sql_by_id.");", VERBOSE_MODE); |
|
|
if (database::isError($result)) { |
|
|
die($result->getMessage().$sql_by_id); |
|
|
} |
|
|
|
|
|
$row =& $result->fetchRow(); |
|
|
$contenu[0][0] = $row[0]; |
|
|
$contenu[1][0] = $row[1]; |
|
|
|
|
|
$k=1; |
|
|
while($row =& $result->fetchRow()){ |
|
|
$contenu[0][$k] = $row[0]; |
|
|
$contenu[1][$k] = $row[1]; |
|
|
$k++; |
|
|
} |
|
|
} |
|
|
|
|
|
$form->setSelect($field, $contenu); |
|
|
} |
|
| 43 |
} |
} |
| 44 |
|
|
| 45 |
// {{{ SURCHARGES DES LIBELLES DES BOUTONS |
// {{{ SURCHARGES DES LIBELLES DES BOUTONS |
Parent Directory
| 
Revision Log
| 
Patch