Subversion Repositories eFlore/Applications.cel

Rev

Rev 1842 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
416 aurelien 1 
<?php
821 jpm 2 
// declare(encoding='UTF-8');
856 aurelien 3 
// ATTENTION ! Classe compatible uniquement avec nouveau format de bdd du cel //
416 aurelien 4 
/**
821 jpm 5 
 * Service de recherche et modification de l'arbre des mots clés associés à un id.
6 
 * 1: Le service recoit un mot clé à ajouter à l'arbre
7 
 * 2: Le service recherche l'arbre ou sous arbre correspondant au critères demandé
8 
 * 3: Le service renvoie l'arbre au format json
9 
 *
10 
 * Encodage en entrée : utf8
11 
 * Encodage en sortie : utf8
416 aurelien 12 
 *
13 
 * Cas d'utilisation :
14 
 *
821 jpm 15 
 * @author Aurélien PERONNET <aurelien@tela-botanica.org>
16 
 * @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
17 
 * @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
18 
 * @version $Id$
19 
 * @copyright © 2011, Tela-Botanica
416 aurelien 20 
 */
856 aurelien 21 
class InventoryKeyWordList extends Cel {
22 
 
1298 aurelien 23 
	protected $suffixe = '';
24 
	protected $suffixe_table = null;
25 
	protected $suffixe_champ = null;
26 
 
27 
	private function setChampsEtTablePourSuffixe($suffixe) {
28 
		$this->suffixe = $suffixe;
29 
		switch($suffixe) {
30 
			case 'obs':
31 
				$this->suffixe_table = '_obs';
32 
				$this->suffixe_champ = '_obs';
33 
			break;
34 
			case 'images':
35 
				$this->suffixe_table = '_images';
36 
				$this->suffixe_champ = '_image';
37 
			break;
38 
		}
39 
	}
416 aurelien 40 
 
821 jpm 41 
	public function getElement($uid) {
42 
		// Controle detournement utilisateur
43 
		$id_utilisateur = $uid[1] ;
44 
		$this->controleUtilisateur($uid[1]);
1298 aurelien 45 
		$this->setChampsEtTablePourSuffixe($uid[0]);
46 
 
1914 raphael 47 
		$this->envoyerJson(self::getMotsClefs($uid[1], $uid[0]));
48 
		return TRUE; // compat: pourquoi renvoyer true si vide ?
49 
	}
50 
 
51 
 
52 
	static function getMotsClefs($uid, $type) {
53 
		if($type == 'obs') {
54 
			return Cel::db()->requeter(sprintf(
55 
				'SELECT mot_cle, id_mot_cle_obs, ce_mot_cle_obs_parent'.
56 
				' FROM cel_mots_cles_obs'.
57 
				' WHERE id_utilisateur = %s'.
58 
				' ORDER BY niveau',
59 
				Cel::db()->proteger($uid)));
416 aurelien 60 
		}
1914 raphael 61 
 
62 
		if($type == 'images') {
63 
			return Cel::db()->requeter(sprintf(
64 
				'SELECT mot_cle, id_mot_cle_image, ce_mot_cle_image_parent'.
65 
				' FROM cel_mots_cles_images'.
66 
				' WHERE id_utilisateur = %s'.
67 
				' ORDER BY niveau',
68 
				Cel::db()->proteger($uid)));
69 
		}
70 
		/* pour extraire un mot-clef en particulier (bien que getMotsClefId() soit plus adapté:
71 
		array_walk($ret,
72 
				   create_function('&$val, $k, $keyword',
73 
								   'if($val["mot_cle"] != $keyword) $val = NULL;' .
74 
								   'else $val = $val["id_mot_cle_obs"];'),
75 
				   'XXX');
76 
		$obsKeywordIdToDetach = array_filter($ret);
77 
		$obsKeywordIdToDetach = array_pop($obsKeywordIdToDetach); */
78 
 
79 
		return array();
416 aurelien 80 
	}
81 
 
1914 raphael 82 
 
83 
	static function getMotsClefId($uid, $type, $keyword) {
84 
		if($type == 'obs') {
85 
			$ret = Cel::db()->requeter(sprintf(
86 
				'SELECT mot_cle, id_mot_cle_obs, ce_mot_cle_obs_parent'.
87 
				' FROM cel_mots_cles_obs'.
88 
				' WHERE id_utilisateur = %s'.
89 
				' AND mot_cle = %s'.
90 
				' ORDER BY niveau',
91 
				Cel::db()->proteger($uid),
92 
				Cel::db()->proteger($keyword) ));
93 
		}
94 
 
95 
		if($type == 'images') {
96 
			$ret = Cel::db()->requeter(sprintf(
97 
				'SELECT mot_cle, id_mot_cle_image, ce_mot_cle_image_parent'.
98 
				' FROM cel_mots_cles_images'.
99 
				' WHERE id_utilisateur = %s'.
100 
				' AND mot_cle = %s'.
101 
				' ORDER BY niveau',
102 
				Cel::db()->proteger($uid),
103 
				Cel::db()->proteger($keyword) ));
104 
		}
105 
		return @$ret[0]['id_mot_cle_obs'];
106 
	}
107 
 
821 jpm 108 
	public function updateElement($uid, $pairs) {
109 
		$id_utilisateur = $uid[1];
110 
		$this->controleUtilisateur($uid[1]);
1298 aurelien 111 
 
112 
		$this->setChampsEtTablePourSuffixe($uid[0]);
416 aurelien 113 
 
821 jpm 114 
		$id_mot_cle = $pairs['id'];
115 
		$action = $pairs['action'];
416 aurelien 116 
 
821 jpm 117 
		if ($action == 'modification') {
118 
			$nouveau_nom = $pairs['motcle'];
1268 aurelien 119 
			$nouvel_id_general = md5(mb_strtolower($nouveau_nom));
416 aurelien 120 
 
1298 aurelien 121 
			$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 122 
						'SET mot_cle = '.Cel::db()->proteger($nouveau_nom).' , '.
123 
						'	md5 = '.Cel::db()->proteger($nouvel_id_general).' '.
124 
						'WHERE id_mot_cle'.$this->suffixe_champ.' = '.Cel::db()->proteger($id_mot_cle).' '.
125 
						'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur) ;
126 
			$reussite = Cel::db()->executer($requete);
1298 aurelien 127 
			if ($reussite !== false) {
821 jpm 128 
				echo 'OK';
1834 aurelien 129 
				return true;
130 
			} else {
131 
				return false;
821 jpm 132 
			}
133 
		} else if ($action == 'deplacement') {
856 aurelien 134 
 
1914 raphael 135 
			self::commencerTransaction();
856 aurelien 136 
 
821 jpm 137 
			$transaction_reussie_1 = true;
138 
			$id_pere = $pairs['parent'];
139 
			$bornes = $this->calculerBornesEtNiveau($id_mot_cle, $id_utilisateur);
856 aurelien 140 
			$bg = $bornes['bg'];
141 
			$bd = $bornes['bd'];
142 
			$niveau = $bornes['niveau'];
416 aurelien 143 
 
821 jpm 144 
			// on inverse l'intervalle de l'élément déplacé et du sous arbre
856 aurelien 145 
			$transaction_reussie_2 = $this->exclureIntervalle($bg, $bd, $id_utilisateur);
416 aurelien 146 
 
821 jpm 147 
			$bg_negative = $bg - $bd - 1;
148 
			$bd_negative = $bd - $bd - 1;
416 aurelien 149 
 
821 jpm 150 
			// on recalcule les intervalles de l'arbre privé de ce sous arbre
856 aurelien 151 
			$transaction_reussie_3 = $this->decalerBornesMoinsIntervalle($bg, $bd, $id_utilisateur);
416 aurelien 152 
 
821 jpm 153 
			$bornes_pere = $this->calculerBornesEtNiveau($id_pere, $id_utilisateur);
856 aurelien 154 
			$bg_pere = $bornes_pere['bg'];
155 
			$bd_pere = $bornes_pere['bd'];
416 aurelien 156 
 
856 aurelien 157 
			$niveau_pere = $bornes_pere['niveau'];
416 aurelien 158 
 
821 jpm 159 
			$decalage = $bd - $bg + 1;
416 aurelien 160 
 
821 jpm 161 
			// on decale les bornes droite du pere pour préparer l'insertion
856 aurelien 162 
			$transaction_reussie_4 = $this->decalerBornesPlusIntervalle($bd_pere, $decalage, $id_utilisateur);
821 jpm 163 
 
164 
			$nouvelle_bd = $bd_pere + $decalage;
165 
			$modif_niveau = $niveau_pere - $niveau + 1;
416 aurelien 166 
 
856 aurelien 167 
			$transaction_reussie_5 = $this->inclureIntervalle($bg_negative, $bd_negative, $nouvelle_bd, $modif_niveau, $id_utilisateur);
168 
 
169 
			$transaction_reussie_6 = $this->changerPere($id_mot_cle, $id_pere, $id_utilisateur);
416 aurelien 170 
 
1298 aurelien 171 
			if ($transaction_reussie_1 !== false && $transaction_reussie_2 !== false &&
172 
				$transaction_reussie_3 !== false && $transaction_reussie_4 !== false &&
173 
				$transaction_reussie_5 !== false && $transaction_reussie_6 !== false) {
1914 raphael 174 
				self::completerTransaction();
1834 aurelien 175 
				return true;
821 jpm 176 
			} else {
1914 raphael 177 
				self::annulerTransaction();
1834 aurelien 178 
				return false;
821 jpm 179 
			}
180 
		}
1842 raphael 181 
		return true;
821 jpm 182 
	}
416 aurelien 183 
 
821 jpm 184 
	public function createElement($pairs) {
185 
		// Controle detournement utilisateur
1014 aurelien 186 
		$this->controleUtilisateur($pairs['identifiant']);
416 aurelien 187 
 
1298 aurelien 188 
		$this->setChampsEtTablePourSuffixe($pairs['mode']);
1014 aurelien 189 
		$id_utilisateur = $pairs['identifiant'];
821 jpm 190 
		$mot_cle = $pairs['motcle'];
416 aurelien 191 
 
856 aurelien 192 
		// TODO supprimer accents
821 jpm 193 
		$id_mot_cle_general = md5(mb_strtolower($mot_cle));
194 
		$id_mot_cle = $pairs['id'];
195 
		$id_parent = $pairs['parent'];
416 aurelien 196 
 
821 jpm 197 
		$this->ajouterMotCleRacine($id_utilisateur);
416 aurelien 198 
 
821 jpm 199 
		$bornes = $this->calculerBornesEtNiveau($id_parent, $id_utilisateur);
856 aurelien 200 
		$borne_pere = $bornes['bd'];
201 
		$niveau = $bornes['niveau'] + 1;
202 
		$bg = $bornes['bd'];
821 jpm 203 
		$bd = $bg + 1;
416 aurelien 204 
 
1914 raphael 205 
        if(!$borne_pere) return false;
206 
 
207 
		self::commencerTransaction();
821 jpm 208 
		$transaction_reussie_1 = $this->decalerBornesPlusDeux($borne_pere,$id_utilisateur) ? true : false;
209 
 
1298 aurelien 210 
		$requete = 	'INSERT INTO  cel_mots_cles'.$this->suffixe_table.' '.
821 jpm 211 
					'VALUES ( '.
1765 raphael 212 
					Cel::db()->proteger($id_mot_cle).', '.
213 
					Cel::db()->proteger($id_utilisateur).', '.
214 
					Cel::db()->proteger($mot_cle).', '.
215 
					Cel::db()->proteger($id_mot_cle_general).', '.
216 
					Cel::db()->proteger($bg).', '.
217 
					Cel::db()->proteger($bd).', '.
218 
					Cel::db()->proteger($niveau).', '.
219 
					Cel::db()->proteger($id_parent).') ' ;
856 aurelien 220 
 
1765 raphael 221 
		$transaction_reussie_2 = Cel::db()->executer($requete);
416 aurelien 222 
 
821 jpm 223 
		if ($transaction_reussie_1 && $transaction_reussie_2) {
1914 raphael 224 
            // on sort de self::createElement ==> JRest::(get|post) ==> JRest->created() qui fait header().
225 
            // or si nous dépassons ini_get(output_buffering) nous ne pouvons plus réécrire le code de retour
226 
            // HTTP, de plus, si ini_get(output_buffering) == off, nous enverrions un warning.
227 
            // d'où ce clone de JRest::created();
228 
            header('HTTP/1.0 201 Created');
229 
			self::completerTransaction();
230 
            exit;
821 jpm 231 
		} else {
1914 raphael 232 
            // cf ci-dessus: JRest::badRequest
233 
            header('HTTP/1.0 400 Bad Request');
234 
			self::annulerTransaction();
235 
            exit;
416 aurelien 236 
		}
1842 raphael 237 
		return true;
416 aurelien 238 
	}
239 
 
821 jpm 240 
	public function deleteElement($uid) {
241 
 
1298 aurelien 242 
		$this->setChampsEtTablePourSuffixe($uid[0]);
821 jpm 243 
		$id_utilisateur = $uid[1];
244 
		$id_mot_cle = $uid[2];
1300 aurelien 245 
 
246 
		$tableau_ids_mots_cles = array();
247 
		$tableau_ids_mots_cles[] = $id_mot_cle;
416 aurelien 248 
 
821 jpm 249 
		$this->controleUtilisateur($id_utilisateur);
1914 raphael 250 
		self::commencerTransaction();
416 aurelien 251 
 
821 jpm 252 
		$bornes  = $this->calculerBornesEtNiveau($id_mot_cle, $id_utilisateur);
1300 aurelien 253 
		if($bornes) {
254 
			$bg = $bornes['bg'];
255 
			$bd = $bornes['bd'];
256 
 
257 
			$requete_mots_cles_fils = 'SELECT id_mot_cle'.$this->suffixe_champ.' as id FROM cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 258 
						'WHERE bg >= '.Cel::db()->proteger($bg).' '.
259 
						'	AND bd <= '.Cel::db()->proteger($bd).' '.
260 
						'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
416 aurelien 261 
 
1765 raphael 262 
			$mots_cles_fils = Cel::db()->requeter($requete_mots_cles_fils);
1300 aurelien 263 
			foreach ($mots_cles_fils as $fils) {
264 
				$tableau_ids_mots_cles[] = $fils['id'];
265 
			}
266 
 
267 
			$requete = 	'DELETE FROM cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 268 
						'WHERE bg >= '.Cel::db()->proteger($bg).' '.
269 
						'	AND bd <= '.Cel::db()->proteger($bd).' '.
270 
						'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
1300 aurelien 271 
 
1765 raphael 272 
			$transaction_reussie_1 = Cel::db()->executer($requete);
1300 aurelien 273 
			$transaction_reussie_2 = $this->decalerBornesMoinsIntervalle($bg, $bd, $id_utilisateur) ? true : false;
274 
 
275 
			if ($transaction_reussie_1 !== false && $transaction_reussie_2 !== false) {
1914 raphael 276 
				self::completerTransaction();
1300 aurelien 277 
			} else {
1914 raphael 278 
				self::annulerTransaction();
1300 aurelien 279 
			}
416 aurelien 280 
		}
1300 aurelien 281 
		// Suppression des liaisons associées à ce mot clé
282 
		$gestion_liaisons = new LiaisonMotsCles($this->config, $this->suffixe);
283 
		$gestion_liaisons->supprimerToutesLiaisonsPourIdMotCle($id_utilisateur, $tableau_ids_mots_cles);
1834 aurelien 284 
 
285 
		return true;
416 aurelien 286 
	}
821 jpm 287 
 
288 
	private function ajouterMotCleRacine($id) {
856 aurelien 289 
		$requete = 	'SELECT COUNT(*) as nb_mc '.
1298 aurelien 290 
					'FROM cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 291 
					'WHERE id_utilisateur = '.Cel::db()->proteger($id).' ';
292 
		$resultat = Cel::db()->requeter($requete);
416 aurelien 293 
 
856 aurelien 294 
		if (is_array($resultat) && count($resultat) > 0) {
295 
			$valeurs = $resultat[0]['nb_mc'];
416 aurelien 296 
 
1298 aurelien 297 
			switch ($this->suffixe) {
298 
				case 'obs' :
821 jpm 299 
					$nom_racine = 'Projets';
300 
					$id_racine = 'racine_obs';
301 
					break;
1298 aurelien 302 
				case 'images' :
821 jpm 303 
					$nom_racine = 'Mots clés';
304 
					$id_racine = 'racine';
305 
					break;
306 
				default:
1298 aurelien 307 
					$nom_racine = $this->suffixe;
308 
					$id_racine = $this->suffixe;
821 jpm 309 
			}
1425 aurelien 310 
 
1765 raphael 311 
			$md5_racine = Cel::db()->proteger(md5($nom_racine));
312 
			$id_racine = Cel::db()->proteger($id_racine);
313 
			$nom_racine = Cel::db()->proteger($nom_racine);
314 
			$id_utilisateur = Cel::db()->proteger($id);
416 aurelien 315 
 
1425 aurelien 316 
			if ($valeurs == 0) {
317 
				$requete = "INSERT INTO cel_mots_cles{$this->suffixe_table} ".
318 
						   "VALUES ($id_racine, $id_utilisateur, $nom_racine, $md5_racine, ".
319 
						   "1, 2, 0, '') ";
320 
 
1765 raphael 321 
				Cel::db()->executer($requete);
821 jpm 322 
			}
416 aurelien 323 
		}
821 jpm 324 
	}
416 aurelien 325 
 
821 jpm 326 
	/**
327 
	 * Désactive l'auto-commit puis débute la transaction
328 
	 */
1914 raphael 329 
	static function commencerTransaction() {
821 jpm 330 
		// Désactive l'autocommit le temps de la manipulation de l'arbre
1914 raphael 331 
		$reussite_autocommit = Cel::db()->executer("SET AUTOCOMMIT = 0");
821 jpm 332 
		// Débute une nouvelle transaction
1914 raphael 333 
		$reussite_begin = Cel::db()->executer("BEGIN");
416 aurelien 334 
	}
335 
 
821 jpm 336 
	/**
337 
	 * Termine la transaction puis réactive l'auto-commit
338 
	 */
1914 raphael 339 
	static function completerTransaction() {
821 jpm 340 
		// Complète la transaction
1914 raphael 341 
		$reussite_commit = Cel::db()->executer("COMMIT");
821 jpm 342 
		// Réactive l'autocommit le temps de la manipulation de l'arbre
1914 raphael 343 
		$reussite_autocommit = Cel::db()->executer("SET AUTOCOMMIT = 1");
416 aurelien 344 
 
821 jpm 345 
		echo 'OK';
416 aurelien 346 
	}
821 jpm 347 
 
348 
	/**
349 
	 * Annule la transaction et réactive l'auto-commit
350 
	 */
1914 raphael 351 
	static function annulerTransaction() {
821 jpm 352 
		// Annule la transaction
1914 raphael 353 
		$reussite_rollback = Cel::db()->executer("ROLLBACK");
821 jpm 354 
		// Réactive l'autocommit le temps de la manipulation de l'arbre
1914 raphael 355 
		$reussite_autocommit = Cel::db()->executer("SET AUTOCOMMIT = 1");
416 aurelien 356 
 
821 jpm 357 
		echo 'ERROR';
358 
	}
416 aurelien 359 
 
821 jpm 360 
	/**
361 
	 * Renvoie les bornes d'un noeud de l'arbre des mots clés
362 
	 */
363 
	private function calculerBornesEtNiveau($id_mot_cle,$id_utilisateur) {
856 aurelien 364 
		$requete = 	'SELECT bd, bg, niveau '.
1298 aurelien 365 
					'FROM cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 366 
					'WHERE id_mot_cle'.$this->suffixe_champ.' = '.Cel::db()->proteger($id_mot_cle).' '.
367 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
1300 aurelien 368 
 
1765 raphael 369 
		$resultat = Cel::db()->requeter($requete);
856 aurelien 370 
 
1300 aurelien 371 
		$valeurs = null;
856 aurelien 372 
		if(is_array($resultat) && count($resultat) > 0) {
373 
			$valeurs = $resultat[0];
374 
		}
375 
 
821 jpm 376 
		return $valeurs;
377 
	}
416 aurelien 378 
 
821 jpm 379 
	/**
380 
	 * Décale les bornes de deux pour insérer un nouvel élément
381 
	 */
382 
	private function decalerBornesPlusDeux($valeur, $id_utilisateur) {
383 
		// Décalage borne droite
1298 aurelien 384 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
385 
					'SET bd = bd + 2 WHERE bd >= '.$valeur.' '.
1765 raphael 386 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
387 
		$reussi_1 = Cel::db()->executer($requete);
821 jpm 388 
 
389 
		// Décalage borne gauche
1298 aurelien 390 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
856 aurelien 391 
					'SET bg = bg + 2 '.
1298 aurelien 392 
					'WHERE bg >= '.$valeur.' '.
1765 raphael 393 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
394 
		$reussi_2 = Cel::db()->executer($requete);
821 jpm 395 
 
1298 aurelien 396 
		return $reussi_1 !== false && $reussi_2 !== false;
416 aurelien 397 
	}
398 
 
821 jpm 399 
	/**
400 
	 * Décale les bornes d'un intervalle negatif donne (pour la suppression d'un sous arbre).
401 
	 */
402 
	private function decalerBornesMoinsIntervalle($bg, $bd, $id_utilisateur) {
403 
		$decalage = $bd - $bg + 1;
416 aurelien 404 
 
821 jpm 405 
		// Décalage borne droite
1298 aurelien 406 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
407 
					'SET bd = bd - '.$decalage.' '.
408 
					'WHERE bd >=  '.$bg.' '.
1765 raphael 409 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
410 
		$reussi_1 = Cel::db()->executer($requete);
416 aurelien 411 
 
821 jpm 412 
		// Décalage borne gauche
1298 aurelien 413 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
414 
					'SET bg = bg - '.$decalage.' '.
415 
					'WHERE bg >  '.$bg.' '.
1765 raphael 416 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
417 
		$reussi_2 = Cel::db()->executer($requete);
821 jpm 418 
 
1298 aurelien 419 
		return $reussi_1 !== false && $reussi_2 !== false;
416 aurelien 420 
	}
421 
 
821 jpm 422 
	/**
423 
	 * Décale à droite des bornes donées d'un intervalle positif donne (pour l'ajout d'un sous arbre).
424 
	 */
425 
	private function decalerBornesPlusIntervalle($valeur_bornes, $largeur, $id_utilisateur) {
426 
		$decalage = $largeur;
416 aurelien 427 
 
821 jpm 428 
		// decalage borne droite
1298 aurelien 429 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
430 
					'SET bd = bd + '.$decalage.' '.
431 
					'WHERE bd >=  '.$valeur_bornes.' '.
1765 raphael 432 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
433 
		$reussi_1 = Cel::db()->executer($requete);
416 aurelien 434 
 
821 jpm 435 
		// decalage borne gauche
1298 aurelien 436 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
437 
					'SET bg = bg + '.$decalage.' '.
438 
					'WHERE bg >=  '.$valeur_bornes.' '.
1765 raphael 439 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
440 
		$reussi_2 = Cel::db()->executer($requete);
416 aurelien 441 
 
1298 aurelien 442 
		return $reussi_1 !== false && $reussi_2 !== false;
821 jpm 443 
	}
416 aurelien 444 
 
821 jpm 445 
	/**
446 
	 * Inverse les bornes d'un intervalle pour l'exclure des modifications sur l'arbre sans changer la hiérarchie.
447 
	 */
448 
	private function exclureIntervalle($bg, $bd, $id_utilisateur) {
1298 aurelien 449 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
450 
					'SET bd = bd - '.$bd.' - 1 , '.
451 
					'	bg =  bg -  '.$bd.' - 1 '.
452 
					'WHERE bd <=  '.$bd.' '.
453 
					'	AND bg >=  '.$bg.' '.
1765 raphael 454 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
416 aurelien 455 
 
1765 raphael 456 
		return Cel::db()->executer($requete);
416 aurelien 457 
	}
458 
 
821 jpm 459 
	/**
460 
	 * Recale les bornes dun intervalle pour l'inclure dans l'arbre à la bonne place.
461 
	 * Décalage borne droite
462 
	 */
463 
	private function inclureIntervalle($bg, $bd, $decalage,$modif_niveau, $id_utilisateur) {
416 aurelien 464 
 
1298 aurelien 465 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
466 
					'SET bg =  bg + '.$decalage.' , '.
467 
					'	bd = bd + '.$decalage.', '.
856 aurelien 468 
					'	niveau = niveau + '.$modif_niveau.' '.
1298 aurelien 469 
					' WHERE bg >=  '.$bg.' '.
470 
					'	AND bd <=  '.$bd.' '.
1765 raphael 471 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
416 aurelien 472 
 
1765 raphael 473 
		return Cel::db()->executer($requete);
821 jpm 474 
	}
416 aurelien 475 
 
821 jpm 476 
	private function changerPere($id_mot_cle, $id_pere, $id_utilisateur) {
1298 aurelien 477 
		$requete = 	'UPDATE cel_mots_cles'.$this->suffixe_table.' '.
1765 raphael 478 
					'SET ce_mot_cle'.$this->suffixe_champ.'_parent = '.Cel::db()->proteger($id_pere).' '.
479 
					'WHERE id_mot_cle'.$this->suffixe_champ.' = '.Cel::db()->proteger($id_mot_cle).' '.
480 
					'	AND id_utilisateur = '.Cel::db()->proteger($id_utilisateur).' ';
1300 aurelien 481 
 
1765 raphael 482 
		return Cel::db()->executer($requete);
821 jpm 483 
	}
416 aurelien 484 
 }
485 
?>