| New file |
|---|
| 0,0 → 1,533 |
|---|
| <?php |
| // declare(encoding='UTF-8'); |
| /** |
| * Script gérant la maintenance de DEL. |
| * |
| * @category DEL |
| * @package Scripts |
| * @subpackage Maintenance |
| * @author Aurelien PERONNET <aurelien@tela-botanica.org> |
| * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt> |
| * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt> |
| * @copyright 1999-2014 Tela Botanica <accueil@tela-botanica.org> |
| */ |
| class Maintenance extends Script { |
| |
| protected $tables_referentiel = array(); |
| protected $conteneur = null; |
| |
| public function executer() { |
| $cmd = $this->getParametre('a'); |
| $this->conteneur = new Conteneur($this->parametres); |
| |
| switch ($cmd) { |
| case 'corrigerNomsReferentiels' : |
| $this->corrigerNomsReferentiels(); |
| break; |
| case 'supprimerPropositionsOrphelines' : |
| $this->supprimerPropositionsOrphelines(); |
| break; |
| case 'affecterNnsAuxPropositionsViables' : |
| $this->affecterNnsAuxPropositionsViables(); |
| break; |
| case 'dedoublonnerPropositions' : |
| $this->dedoublonnerPropositions(); |
| break; |
| case 'dedoublonnerPropositionsEtCorrigerDonnees' : |
| // Suppression des propositions et votes sur des obs inexistantes |
| // pas la peine de traiter ce qui n'existe plus ! |
| $this->supprimerPropositionsOrphelines(); |
| // Corriger les noms de référentiels permet de simplifier les affectations de noms ensuite |
| $this->corrigerNomsReferentiels(); |
| // Affectations de nums noms aux propositions qui le permettent |
| $this->affecterNnsAuxPropositionsViables(); |
| echo "\n"; |
| $this->dedoublonnerPropositions(); |
| // A la fin, les votes qui n'ont pas été fusionnés pointent sur des propositions |
| // qui n'existent plus, donc on les supprime |
| $this->supprimerVotesOrphelins(); |
| echo "\n"; |
| break; |
| default : |
| throw new Exception("Erreur : la commande '$cmd' n'existe pas!"); |
| } |
| } |
| |
| private function corrigerNomsReferentiels() { |
| |
| echo "Corrections des noms de referentiels ... "; |
| |
| $requete = "UPDATE del_commentaire ". |
| "SET nom_referentiel = 'bdtfx' ". |
| "WHERE nom_referentiel IN ('bdtfx_v1', 'bdtfx:1.01') "; |
| $modif = $this->conteneur->getBdd()->executer($requete); |
| |
| $requete = "UPDATE del_commentaire ". |
| "SET nom_referentiel = 'apd' ". |
| "WHERE nom_referentiel IN ('bdtao', 'bdtao:1.00') "; |
| $modif = $this->conteneur->getBdd()->executer($requete); |
| |
| $requete = "UPDATE del_commentaire ". |
| "SET nom_referentiel = 'bdtxa' ". |
| "WHERE nom_referentiel IN ('bdtxa:1.00') "; |
| $modif = $this->conteneur->getBdd()->executer($requete); |
| |
| $requete = "UPDATE del_commentaire ". |
| "SET nom_referentiel = 'isfan' ". |
| "WHERE nom_referentiel IN ('isfan:1.00') "; |
| $modif = $this->conteneur->getBdd()->executer($requete); |
| |
| echo "OK \n"; |
| |
| return $modif; |
| } |
| |
| private function supprimerPropositionsOrphelines() { |
| echo "Suppression des propositions orphelines (et des votes associés) ... "; |
| |
| $requete_prop = "DELETE FROM del_commentaire ". |
| "WHERE ce_observation NOT IN (SELECT id_observation FROM del_observation)"; |
| $modif_prop = $this->conteneur->getBdd()->executer($requete_prop); |
| |
| |
| $modif_votes = $this->supprimerVotesOrphelins(); |
| |
| echo "OK \n"; |
| |
| return $modif_prop && $modif_votes; |
| } |
| |
| private function supprimerVotesOrphelins() { |
| $requete_votes = "DELETE FROM del_commentaire_vote ". |
| "WHERE ce_proposition NOT IN (SELECT id_commentaire FROM del_commentaire)"; |
| |
| $modif_votes = $this->conteneur->getBdd()->executer($requete_votes); |
| } |
| |
| private function dedoublonnerPropositions() { |
| echo "Détection des propositions en doublons \n"; |
| // La méthode n'est pas optimisée, on fait beaucoup de boucles, de traitement de données |
| // etc... mais la méthode ne doit pas être lancée souvent et elle est rapide |
| // donc lisibilité > performances |
| $infos_indexees = array(); |
| $infos_indexees_par_obs = array(); |
| |
| // Selection des ids de commentaires dupliqués, groupés par observation et par nom (concaténés par des virgules) |
| $requete_id_prod_doubl = "SELECT GROUP_CONCAT(id_commentaire) as id_commentaires_dupliques ". |
| "FROM del_commentaire ". |
| "GROUP BY ce_observation, nom_sel ". |
| "HAVING COUNT(nom_sel) > 1 "; |
| |
| $ids_propositions_doublonnees = $this->conteneur->getBdd()->recupererTous($requete_id_prod_doubl); |
| |
| // Assemblage en une seule chaine des id de commentaires |
| $ids_propositions_doublonnees_chaine = ""; |
| foreach($ids_propositions_doublonnees as $ids_p_d) { |
| $ids_propositions_doublonnees_chaine .= $ids_p_d['id_commentaires_dupliques'].","; |
| } |
| $ids_propositions_doublonnees_chaine = rtrim($ids_propositions_doublonnees_chaine, ','); |
| |
| $propositions_doublonnees = array(); |
| if(!empty($ids_propositions_doublonnees)) { |
| // Selection des informations relatives aux ids de commentaires trouvés au dessus |
| $requete_prop_doubl = "SELECT * FROM del_commentaire ". |
| "WHERE id_commentaire IN (".$ids_propositions_doublonnees_chaine.") ". |
| "ORDER BY ce_observation, date "; |
| |
| $propositions_doublonnees = $this->conteneur->getBdd()->recupererTous($requete_prop_doubl); |
| } |
| |
| echo count($propositions_doublonnees)." propositions pour ".count($ids_propositions_doublonnees)." couples 'observation-nom_sel' sont potentiellement en doublons \n"; |
| |
| // Organisation par numéro d'obs, puis par nom sel, puis par id proposition |
| // + Création d'un tableau indexé par id proposition pour accès direct au infos |
| foreach($propositions_doublonnees as &$proposition_d) { |
| $id_obs = $proposition_d['ce_observation']; |
| $id_proposition = $proposition_d['id_commentaire']; |
| $nom_sel_prop = $proposition_d['nom_sel']; |
| |
| $infos_indexees[$id_proposition] = $proposition_d; |
| if(!isset($infos_indexees_par_obs[$id_obs])) { |
| $infos_indexees_par_obs[$id_obs] = array(); |
| } |
| $proposition_d['votes'] = array(); |
| $infos_indexees_par_obs[$id_obs][$nom_sel_prop][$id_proposition] = $proposition_d; |
| } |
| |
| $votes_doublonnes = array(); |
| if(!empty($ids_propositions_doublonnees)) { |
| // Selection des votes concernés par ces propositions |
| $requete_votes_prop_doubl = "SELECT * FROM del_commentaire_vote ". |
| "WHERE ce_proposition IN (".$ids_propositions_doublonnees_chaine.")"; |
| |
| $votes_doublonnes = $this->conteneur->getBdd()->recupererTous($requete_votes_prop_doubl); |
| } |
| |
| echo count($votes_doublonnes)." votes sont concernés \n"; |
| |
| // Affectation des votes trouvés aux propositions concernées |
| foreach($votes_doublonnes as &$vote_d) { |
| $id_proposition = $vote_d['ce_proposition']; |
| $proposition_concernee = $infos_indexees[$id_proposition]; |
| $id_obs = $proposition_concernee['ce_observation']; |
| $nom_sel_prop = $proposition_concernee['nom_sel']; |
| |
| $infos_indexees_par_obs[$id_obs][$nom_sel_prop][$id_proposition]['votes'][] = $vote_d; |
| } |
| |
| $nb_propositions_conservees = 0; |
| $nb_propositions_supprimees = 0; |
| $nb_votes_reaffectes = 0; |
| |
| // Tri des propositions pour savoir lequelles conserver et lesquelles supprimer |
| foreach($infos_indexees_par_obs as $obs => &$propositions) { |
| foreach($propositions as $nom => &$doublons) { |
| $this->trierPropositionsEtFusionnerVotes($doublons); |
| $nb_propositions_conservees += count($doublons['propositions_conservees']); |
| $nb_propositions_supprimees += count($doublons['propositions_supprimees']); |
| $nb_votes_reaffectes += count($doublons['votes_propositions_doublons']); |
| } |
| } |
| |
| echo $nb_propositions_conservees." propositions seront conservées \n"; |
| echo $nb_propositions_supprimees." propositions seront supprimées car inutiles ou fusionnées \n"; |
| echo $nb_votes_reaffectes." groupes de votes seront potentiellement réaffectés \n"; |
| |
| // Mise à jour proprement dite |
| foreach($infos_indexees_par_obs as $obs => &$nom_en_doublons) { |
| foreach($nom_en_doublons as $nom_en_doublon => &$propositions_en_doublons) { |
| $this->mettreAJourPropositions($propositions_en_doublons); |
| } |
| $this->afficherAvancement('observations traitées ', 1); |
| } |
| |
| // Fichier json pour vérification par zieutage (chemin à modifier suivant l'emplacement désiré) |
| //file_put_contents('/home/aurelien/web/test_fusion.json', json_encode($infos_indexees_par_obs)); |
| } |
| |
| private function trierPropositionsEtFusionnerVotes(&$prop_a_doublons) { |
| |
| $proposition_conservees = array(); |
| $propositions_supprimees = array(); |
| $votes_conserves = array(); |
| |
| foreach($prop_a_doublons as &$prop) { |
| // Indexer le tableau par nom_sel courriel permet de ne garder qu'un seul couple |
| // utilisateur / nom sci pour chaque observation |
| // (on utilise le courriel car les gens non identifiés peuvent proposer également |
| // et celui-ci est normalement toujours rempli) |
| $index = strtolower($prop['nom_sel']).'-'.$prop['utilisateur_courriel']; |
| |
| // Fusion des votes s'il y en a |
| if(!empty($prop['votes'])) { |
| // Utiliser le couple utilisateur / nom sci pour stocker les votes permet facilement |
| // de réaffecter les votes à la proposition qui sera conservée |
| if(!isset($votes_conserves[$index])) { |
| $votes_conserves[$index] = array(); |
| } |
| |
| // Si on trouve un vote pour et un vote contre par le même utilisateur |
| // (cas d'une proposition doublonnée votée de manière contradictoire par |
| // un utilisateur), on garde le vote positif |
| |
| foreach($prop['votes'] as $vote_proposition) { |
| // Un utilisateur ne peut avoir qu'un seul vote par proposition |
| $index_vote = $vote_proposition['ce_utilisateur']; |
| if(isset($votes_conserves[$index][$index_vote])) { // fusion |
| $vote_deja_present = $votes_conserves[$index][$index_vote]; |
| // Mise à jour de la valeur dans le cas où le vote existe déjà |
| $valeur_vote_maj = max($votes_conserves[$index][$index_vote]['valeur'], $vote_proposition['valeur']); |
| $votes_conserves[$index][$index_vote]['valeur'] = $valeur_vote_maj; |
| $votes_conserves[$index][$index_vote]['raison'] .= ' - '.$vote_proposition['valeur']; |
| } else { // nouveau vote |
| $vote_proposition['raison'] = 'Fusion de '.$vote_proposition['valeur']; |
| $votes_conserves[$index][$index_vote] = $vote_proposition; |
| } |
| } |
| } |
| |
| // valeurs par défaut |
| $conservee = false; |
| $raison = 'Supprimée car ne rentre dans aucun cas'; |
| |
| // Les cas ci dessous permettent de fusionner le maximum d'information |
| // dans la proposition qui sera conservée (car il existe des doublons qui ne sont |
| // pas tout à fait identiques (ex.: l'un à un num_nom et l'autre pas) |
| |
| // Les propositions sont classées par ordre de saisie donc on gardera comme base de fusion, |
| // la plus ancienne qui correspond à au moins un cas de conservation |
| $this->fusionnerPropositions($index, $prop, $proposition_conservees, $propositions_supprimees); |
| } |
| |
| // Si aucune proposition ne convient on prend la première |
| // qui est normalement la plus ancienne |
| // @TODO normalement ça sert plus à rien |
| if (empty($proposition_conservees)) { |
| $prop_conservee = reset($prop_a_doublons); |
| $index = strtolower($prop_conservee['nom_sel']).'-'.$prop_conservee['utilisateur_courriel']; |
| $proposition_conservees[$index] = $prop_conservee; |
| $proposition_conservees[$index]['raison'] = "Conservée car aucune autre ne convient \n"; |
| |
| // Dans ce cas on retire la proposition de la liste des propositions supprimées |
| unset($propositions_supprimees[$prop_conservee['id_commentaire']]); |
| } |
| |
| $prop_a_doublons['propositions_conservees'] = $proposition_conservees; |
| $prop_a_doublons['propositions_supprimees'] = $propositions_supprimees; |
| $prop_a_doublons['votes_propositions_doublons'] = $votes_conserves; |
| |
| } |
| |
| /** |
| * Tente de fusionner toutes les propositions, pour une observation donnée, |
| * en se basant sur le couple auteur-nom_selectionne |
| */ |
| protected function fusionnerPropositions($index, &$prop, &$proposition_conservees, &$propositions_supprimees) { |
| // On garde un exemple de chaque couple auteur/nom scientifique |
| // Ca laisse des doublons en terme de nom mais au moins ça ne lèse pas les auteurs |
| if(!isset($proposition_conservees[$index])) { |
| // première rencontre avec le couple nom_sel/auteur |
| $proposition_conservees[$index] = $prop; |
| } else { // Cas de la fusion |
| // Fusion d'un nom valide : fusionner nom _sel_nn (et nom_ret_nn et nom_ret s'ils existent) |
| if(!empty($prop['nom_sel_nn'])) { |
| $proposition_conservees[$index]['nom_sel_nn'] = $prop['nom_sel_nn']; |
| // infos complémentaires concernant le référentiel |
| if(!empty($prop['nom_referentiel'])) { |
| $proposition_conservees[$index]['nom_referentiel'] = $prop['nom_referentiel']; |
| } |
| if(!empty($prop['famille'])) { |
| $proposition_conservees[$index]['famille'] = $prop['famille']; |
| } |
| // Fusion du nom retenu s'il existe |
| if($proposition_conservees[$index]['nom_ret_nn'] == 0) { // on admet que nom_ret existe aussi dans ce cas |
| $proposition_conservees[$index]['nom_ret'] = $prop['nom_ret']; |
| $proposition_conservees[$index]['nom_ret_nn'] = $prop['nom_ret_nn']; |
| } |
| } |
| |
| // Fusion du caractère retenu : fusioner le booleen, la date de retention, le validateur |
| if($prop['proposition_retenue'] == "1") { |
| $proposition_conservees[$index]['proposition_retenue'] = $prop['proposition_retenue']; |
| if (empty($proposition_conservees[$index]['date_validation'])) { |
| $proposition_conservees[$index]['date_validation'] = $prop['date_validation']; |
| } |
| if (empty($proposition_conservees[$index]['ce_validateur'])) { |
| $proposition_conservees[$index]['ce_validateur'] = $prop['ce_validateur']; |
| } |
| } |
| |
| // Fusion du caractère initial : fusion du booleen, fusion des infos d'auteur et de la date la plus ancienne |
| if($prop['proposition_initiale'] == "1") { |
| $proposition_conservees[$index]['proposition_initiale'] = $prop['proposition_initiale']; |
| if (empty($proposition_conservees[$index]['ce_utilisateur'])) { |
| $proposition_conservees[$index]['ce_utilisateur'] = $prop['ce_utilisateur']; |
| } |
| if (empty($proposition_conservees[$index]['utilisateur_prenom'])) { |
| $proposition_conservees[$index]['utilisateur_prenom'] = $prop['utilisateur_prenom']; |
| } |
| if (empty($proposition_conservees[$index]['utilisateur_nom'])) { |
| $proposition_conservees[$index]['utilisateur_nom'] = $prop['utilisateur_nom']; |
| } |
| if (empty($proposition_conservees[$index]['utilisateur_courriel'])) { |
| $proposition_conservees[$index]['utilisateur_courriel'] = $prop['utilisateur_courriel']; |
| } |
| // Test tout simple pour éviter les dates vides |
| if (empty($proposition_conservees[$index]['date'])) { |
| if(substr($prop['date'], 0, 4) != "0000") { |
| $proposition_conservees[$index]['date'] = $prop['date']; |
| } |
| } |
| } |
| |
| // Fusion du commentaire (concaténation du texte) |
| if(trim($proposition_conservees[$index]['texte']) != "") { |
| $prop['texte'] = trim($prop['texte']); |
| // Suppression du texte fusionné, au cas où il existerait déjà (un peu barbare mais bon) |
| $proposition_conservees[$index]['texte'] = str_replace($prop['texte'].';', '', $proposition_conservees[$index]['texte']); |
| $proposition_conservees[$index]['texte'] .= $prop['texte'].';'; |
| } |
| |
| // À la fin, une proposition fusionnée doit être supprimée |
| $propositions_supprimees[$prop['id_commentaire']] = $prop; |
| } |
| } |
| |
| private function mettreAJourPropositions(&$propositions_a_obs_a_nom) { |
| $propositions_conservees = $propositions_a_obs_a_nom['propositions_conservees']; |
| foreach($propositions_conservees as $index => $proposition_conservee) { |
| |
| $id_proposition_conservee = $proposition_conservee['id_commentaire']; |
| // Pas besoin de mettre à jour une clé primaire ! |
| unset($proposition_conservee['id_commentaire']); |
| |
| // Suppression des champs qui n'existent pas dans la base de données |
| unset($proposition_conservee['votes']); |
| unset($proposition_conservee['raison']); |
| $maj_prop = array(); |
| |
| // on prend les champs un par un |
| foreach($proposition_conservee as $champ => $valeur) { |
| $maj_prop[] = $champ.'='.$this->conteneur->getBdd()->proteger($valeur); |
| } |
| |
| $requete_maj_prop = "UPDATE del_commentaire SET ".implode(',', $maj_prop)." ". |
| "WHERE id_commentaire = ".$id_proposition_conservee; |
| // écriture de sinformations fusionnées dans la base |
| $modif_prop = $this->conteneur->getBdd()->requeter($requete_maj_prop); |
| |
| if(isset($propositions_a_obs_a_nom['votes_propositions_doublons'][$index])) { |
| $votes_a_proposition = $propositions_a_obs_a_nom['votes_propositions_doublons'][$index]; |
| |
| foreach($votes_a_proposition as $vote_a_proposition) { |
| |
| $id_vote_conserve = $vote_a_proposition['id_vote']; |
| // Pas besoin de mettre à jour un clé primaire ! |
| unset($vote_a_proposition['id_vote']); |
| |
| // Suppression des champs qui n'existent pas dans la base de données |
| unset($vote_a_proposition['raison']); |
| $maj_vote = array(); |
| |
| $vote_a_proposition['ce_proposition'] = $id_proposition_conservee; |
| foreach($vote_a_proposition as $champ_v => $valeur_v) { |
| $maj_vote[] = $champ_v.'='.$this->conteneur->getBdd()->proteger($valeur_v); |
| } |
| // tous les votes pertinents pointent maintenant vers la proposition fusionnée |
| // certains votes voient leur valeur mise à jour (fusion de valeurs de votes) |
| $requete_maj_vote = "UPDATE del_commentaire_vote SET ".implode(',', $maj_vote)." ". |
| "WHERE id_vote = ".$id_vote_conserve; |
| $modif_vote = $this->conteneur->getBdd()->requeter($requete_maj_vote); |
| } |
| } |
| } |
| |
| // Suppression des propositions devenues inutiles |
| $propositions_supprimees = $propositions_a_obs_a_nom['propositions_supprimees']; |
| if(!empty($propositions_supprimees)) { |
| $ids_propositions_supprimees = array(); |
| foreach($propositions_supprimees as $index_prop_supprimee => $proposition_supprimee) { |
| $ids_propositions_supprimees[] = $this->conteneur->getBdd()->proteger($proposition_supprimee['id_commentaire']); |
| } |
| |
| $requete_supp_prop = "DELETE FROM del_commentaire ". |
| "WHERE id_commentaire IN (". |
| implode(',', $ids_propositions_supprimees). |
| ")"; |
| $supp_prop = $this->conteneur->getBdd()->requeter($requete_supp_prop); |
| } |
| } |
| |
| private function affecterNnsAuxPropositionsViables() { |
| |
| $this->construireTableauReferentiels(); |
| |
| echo "Affectation de nn aux propositions qui le permettent \n"; |
| $propositions = $this->obtenirPropositionsPotentiellementViables(); |
| |
| $noms_ordonnes = array(); |
| $nb_propositions_traitees = 0; |
| $nb_prop_orphelines = count($propositions); |
| $nb_prop_augmentees = 0; |
| $nb_noms_trouves = 0; |
| $nb_prop_inchangees = 0; |
| |
| echo $nb_prop_orphelines.' propositions sont potentiellement améliorables'."\n"; |
| |
| foreach($propositions as $prop) { |
| |
| $referentiel = in_array($prop['referentiel_proposition'], array_keys($this->tables_referentiel)) ? |
| $prop['referentiel_proposition'] : $prop['referentiel_observation']; |
| $referentiel = in_array($referentiel, array_keys($this->tables_referentiel)) ? |
| $referentiel : 'tous'; |
| $referentiel = substr($referentiel, 0, 5); |
| |
| if($referentiel == 'tous') { |
| $noms_trouves = 0; |
| foreach(array_keys($this->tables_referentiel) as $ref) { |
| $noms_possibles[$referentiel] = $this->rechercherNomsPossibles($ref, $prop['nom_sel']); |
| $nb_noms_trouves += count($noms_possibles[$referentiel]); |
| $noms_trouves += empty($noms_possibles[$referentiel]) ? 1 : 0; |
| } |
| $nb_prop_inchangees += $noms_trouves != 0 ? 1 : 0; |
| |
| // Un seul référentiel correspond (c'est déjà bon signe) |
| if(count($noms_possibles) == 1) { |
| $nom_dans_ref = reset($noms_possibles); |
| $nom_referentiel = key($noms_possibles); |
| // Un seul nom trouvé : OK |
| if(count($nom_dans_ref) == 1) { |
| if(isset($nom_dans_ref['num_nom'])) { |
| $this->mettreAjourProposition($prop['id_commentaire'], $nom_referentiel, $nom_dans_ref); |
| $nb_prop_augmentees ++; |
| } |
| } |
| } |
| } else { |
| $noms_possibles = $this->rechercherNomsPossibles($referentiel, $prop['nom_sel']); |
| $noms_ordonnes[$prop['id_commentaire']]['nom_trouves'] = $noms_possibles; |
| $nb_noms_trouves += count($noms_possibles); |
| $nb_prop_inchangees += empty($noms_possibles) ? 1 : 0; |
| |
| // On ne met à jour qu'en étant absolument sur (si l'on a trouvé un seul nom) |
| if(count($noms_possibles) == 1) { |
| $nom_dans_ref = array_pop($noms_possibles); |
| if(isset($nom_dans_ref['num_nom'])) { |
| $this->mettreAjourProposition($prop['id_commentaire'], $referentiel, $nom_dans_ref); |
| $nb_prop_augmentees ++; |
| } |
| } |
| } |
| |
| $this->afficherAvancement('propositions traitées ', 1); |
| } |
| |
| $noms_ordonnes[$prop['id_commentaire']]['proposition'] = $prop; |
| |
| echo "\n"; |
| echo $nb_noms_trouves.' noms ont été trouvés'."\n"; |
| echo $nb_prop_augmentees.' propositions ont été améliorées'."\n"; |
| echo $nb_prop_inchangees.' propositions n\'ont pas pu être améliorées'."\n"; |
| } |
| |
| |
| private function obtenirPropositionsPotentiellementViables() { |
| $requete = 'SELECT DISTINCT dc.id_commentaire, dc.nom_sel, dc.nom_referentiel as referentiel_proposition, '. |
| 'do.nom_referentiel as referentiel_observation '. |
| 'FROM del_commentaire dc '. |
| 'INNER JOIN del_observation do '. |
| ' ON do.id_observation = dc.ce_observation '. |
| 'WHERE dc.nom_sel != "" AND (dc.nom_sel_nn = 0 OR dc.nom_sel_nn IS NULL)'; |
| |
| $propositions = $this->conteneur->getBdd()->recupererTous($requete); |
| |
| return $propositions; |
| } |
| |
| private function rechercherNomsPossibles($referentiel, $nom) { |
| $nom = trim($nom); |
| $requete = "SELECT num_nom, num_nom_retenu, nom_sci, CONCAT(nom_sci, ' ', auteur) as nom_sci_etendu FROM ".$this->tables_referentiel[$referentiel]." ". |
| "WHERE CONCAT(nom_sci, ' ', auteur) = ".$this->conteneur->getBdd()->proteger($nom)." ". |
| " OR nom_sci = ".$this->conteneur->getBdd()->proteger($nom)." ". |
| "ORDER BY CONCAT(nom_sci, ' ', auteur) ASC"; |
| |
| $noms = $this->conteneur->getBdd()->recupererTous($requete); |
| return $noms; |
| } |
| |
| private function mettreAjourProposition($id_proposition, $referentiel, $infos) { |
| $requete = "UPDATE del_commentaire ". |
| "SET nom_sel_nn = ".$this->conteneur->getBdd()->proteger($infos['num_nom']).", ". |
| " nom_referentiel = ".$this->conteneur->getBdd()->proteger($referentiel)." ". |
| "WHERE id_commentaire = ".$this->conteneur->getBdd()->proteger($id_proposition); |
| |
| return $this->conteneur->getBdd()->executer($requete); |
| } |
| |
| private function construireTableauReferentiels() { |
| $referentiels_dispos = explode(',', $this->conteneur->getParametre('referentiels')); |
| foreach($referentiels_dispos as $ref) { |
| $this->tables_referentiel[$ref] = $this->conteneur->getParametre('table_referentiel_'.$ref); |
| } |
| } |
| } |