| 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; |
|
|
} |
|
|
//Si le flag $archivable est posé |
|
|
//if(isset($archivable) and $archivable){ |
|
|
// $this->archivable=TRUE; |
|
|
//} else { |
|
|
// $this->archivable=FALSE; |
|
|
//} |
|
|
// 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->clePrimaire." like '".$id."' "; |
|
|
} else { |
|
|
$sql .= " where ".$this->table.".".$this->clePrimaire." = ".$id." "; |
|
|
} |
|
|
} |
|
|
$sql .= " ".$selection." "; |
|
|
//print '$sql:'.$sql.' '; |
|
|
// 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++; |
|
|
} |
|
|
} |
|
|
} |
|
|
if(!$this->canAccess()) { |
|
|
// |
|
|
$message_class = "error"; |
|
|
$message = _("Droits insuffisants. Vous n'avez pas suffisament de ". |
|
|
"droits pour acceder a cette page."); |
|
|
$this->f->addToMessage($message_class, $message); |
|
|
|
|
|
// |
|
|
$this->f->setFlag(NULL); |
|
|
$this->f->display(); |
|
|
|
|
|
// Arrêt du script |
|
|
die(); |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
| 25 |
|
|
| 26 |
/** |
/** |
| 27 |
* Cette methode permet d'executer l'ajout (MODE 'insert') de l'objet dans |
* Liste des métadonnées communes à l'ensemble des fichiers de l'application |
|
* la base de donnees. |
|
|
* |
|
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
| 28 |
*/ |
*/ |
| 29 |
function ajouter($val, &$db = NULL, $DEBUG = false) { |
var $metadata_global = array( |
| 30 |
// Logger |
"codeProduit" => "getCodeProduit", |
| 31 |
$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 |
|
|
if(isset($val[$this->clePrimaire])) // *** |
|
|
$id = $val[$this->clePrimaire]; |
|
|
else |
|
|
$id=$this->id; |
|
|
$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); |
|
|
} |
|
|
|
|
|
|
|
| 32 |
/** |
/** |
| 33 |
* |
* |
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
| 34 |
*/ |
*/ |
| 35 |
function verifierAjout($val = array(), &$db = NULL) { |
var $om_formulaire = "om_formulaire"; |
|
|
|
|
// Verifier [verify] |
|
|
// la cle primaire est obligatoire |
|
|
// [primary key is compulsory] |
|
|
if ($this->valF[$this->clePrimaire] == "") { |
|
|
// |
|
|
$this->correct = false; |
|
|
// |
|
|
$this->addToMessage("<br/>"); |
|
|
$this->addToMessage( _("L'\"identifiant\" est obligatoire")." "); |
|
|
$this->addToMessage("[ "._($this->clePrimaire)." ]"); |
|
|
} |
|
|
if ($this->typeCle == "A") { |
|
|
$sql = "select count(*) from ".DB_PREFIXE.$this->table." "; |
|
|
$sql .= "where ".$this->clePrimaire."='".$this->valF[$this->clePrimaire]."' "; |
|
|
$nb = $db->getone($sql); |
|
|
$this->addToLog("verifierAjout(): db->getone(\"".$sql."\");", VERBOSE_MODE); |
|
|
if (database::isError($nb)) { |
|
|
$this->erreur_db($nb->getDebugInfo(), $nb->getMessage(), ''); |
|
|
}else{ |
|
|
if ($nb > 0) { |
|
|
$this->correct = false; |
|
|
$this->addToMessage($nb." "); |
|
|
$this->addToMessage( _("cle primaire existante")); |
|
|
$this->addToMessage(" ".$this->table."<br />"); |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
| 36 |
|
|
|
|
|
| 37 |
/** |
/** |
| 38 |
* Cette methode permet d'executer la modification (MODE 'update') de |
* Retourne le code produit défini dans le paramétrage |
| 39 |
* l'objet dans la base de donnees. |
* @return string code produit (OpenADS) |
|
* |
|
|
* @param array $val |
|
|
* @param object $db Objet de connexion DB |
|
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
| 40 |
*/ |
*/ |
| 41 |
function modifier($val = array(), &$db = NULL, $DEBUG = false) { |
protected function getCodeProduit() { |
| 42 |
|
return $this->f->getParameter("code_produit"); |
|
// 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); |
|
| 43 |
} |
} |
| 44 |
|
|
| 45 |
|
// {{{ SURCHARGES DES LIBELLES DES BOUTONS |
| 46 |
|
|
| 47 |
/** |
/** |
| 48 |
* Cette methode permet d'executer la suppression (MODE 'delete') de |
* Cette methode permet d'afficher le bouton de validation du formulaire |
|
* l'objet dans la base de donnees. |
|
| 49 |
* |
* |
| 50 |
* @param array $val |
* @param integer $maj Mode de mise a jour |
| 51 |
* @param object $db Objet de connexion DB |
* @return void |
|
* @param boolean $DEBUG Mode debug (@deprecated) |
|
| 52 |
*/ |
*/ |
| 53 |
function supprimer($val = array(), &$db = NULL, $DEBUG = false) { |
function bouton($maj) { |
|
// 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); |
|
|
} |
|
| 54 |
|
|
| 55 |
|
if (!$this->correct) { |
| 56 |
|
// |
| 57 |
/** |
if ($maj == 2) { |
| 58 |
* Methode de verification de l'unicite d'une valeur pour chaque elements du tableau unique_key, |
$bouton = _("Supprimer"); |
| 59 |
* ainsi que l'unicite de la cle multiple unique_multiple_key. |
} else { |
| 60 |
* |
if ($maj == 1) { |
| 61 |
* @param objet $db Objet Base de donnees |
$bouton = _("Modifier"); |
|
*/ |
|
|
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; |
|
|
} |
|
|
} |
|
| 62 |
} else { |
} else { |
| 63 |
//Verification du groupe de champs uniques |
$bouton = _("Ajouter"); |
|
$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; |
|
|
} |
|
|
} |
|
|
} |
|
| 64 |
} |
} |
| 65 |
} |
} |
| 66 |
|
//// |
| 67 |
|
//$bouton .= " "._("l'enregistrement de la table")." :"; |
| 68 |
|
//$bouton .= " '"._($this->table)."'"; |
| 69 |
|
// |
| 70 |
|
$params = array( |
| 71 |
|
"value" => $bouton, |
| 72 |
|
"class" => "btn btn-primary", |
| 73 |
|
); |
| 74 |
|
// |
| 75 |
|
$this->f->layout->display_form_button($params); |
| 76 |
} |
} |
|
if(!$unique) { |
|
|
$this->correct = false; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
* Methode permettant de requeter la base afin de definir la validite du champ unique |
|
|
* |
|
|
* @param string $champ nom du champ unique |
|
|
* @param string $value valeur à inserer dans la colonne |
|
|
*/ |
|
|
function isUnique($champ,$value) { |
|
|
//Test sur un groupe de champs |
|
|
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; |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
| 77 |
|
|
|
/** |
|
|
* Methode de verification des contraintes not null, |
|
|
* affiche une erreur si nul. |
|
|
* |
|
|
* @param objet $db Objet Base de donnees |
|
|
*/ |
|
|
function checkRequired() { |
|
|
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 |
|
|
} |
|
|
} |
|
| 78 |
} |
} |
| 79 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 80 |
/** |
/** |
| 81 |
* |
* |
| 82 |
*/ |
*/ |
| 83 |
function message() { |
function boutonsousformulaire($datasubmit, $maj, $val=null) { |
|
|
|
|
// do not output anything in case of a REST request |
|
|
if (defined('REST_REQUEST')) { |
|
|
return; |
|
|
} |
|
|
|
|
|
if ($this->msg != "") { |
|
| 84 |
|
|
| 85 |
|
if (!$this->correct) { |
| 86 |
// |
// |
| 87 |
$m = new message(); |
switch ($maj) { |
| 88 |
|
case 0: |
| 89 |
|
$bouton = _("Ajouter"); |
| 90 |
|
break; |
| 91 |
|
case 1: |
| 92 |
|
$bouton = _("Modifier"); |
| 93 |
|
break; |
| 94 |
|
case 2: |
| 95 |
|
$bouton = _("Supprimer"); |
| 96 |
|
break; |
| 97 |
|
} |
| 98 |
|
//// |
| 99 |
|
//$bouton .= " "._("l'enregistrement de la table")." :"; |
| 100 |
|
//$bouton .= " '"._($this->table)."'"; |
| 101 |
// |
// |
| 102 |
if ($this->correct) { |
$params = array( |
| 103 |
$class = "valid"; |
"class" => "", |
| 104 |
} else { |
"value" => $bouton, |
| 105 |
$class = "error"; |
"onclick" => "affichersform('".get_class($this)."', '$datasubmit', this.form);return false;", |
| 106 |
} |
); |
| 107 |
$m->displayMessage($class, $this->msg); |
// |
| 108 |
|
$this->f->layout->display_form_button($params); |
|
} |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
* 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); |
|
| 109 |
} |
} |
|
} |
|
|
|
|
| 110 |
|
|
|
/** |
|
|
* |
|
|
*/ |
|
|
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); |
|
|
} |
|
| 111 |
} |
} |
|
|
|
| 112 |
// }}} |
// }}} |
|
|
|
|
/** |
|
|
* Cette methode vide les valeurs des erreurs du tableau errors. |
|
|
*/ |
|
|
function clearErrors() { |
|
|
foreach (array_keys($this->errors) as $key) { |
|
|
$this->errors[$key] = ''; |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
| 113 |
} |
} |
| 114 |
|
|
| 115 |
?> |
?> |
Parent Directory
| 
Revision Log
| 
Patch