WebSVN – eFlore/Applications.cel – Diff – /trunk/src/org/tela_botanica/client/image/ImageModele.java


package org.tela_botanica.client.image;
 
import java.util.HashMap;
import java.util.Iterator;
import java.util.Vector;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;
import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;
import org.tela_botanica.client.modeles.objets.Configuration;
import org.tela_botanica.client.modeles.objets.ImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeImageCarnet;
import org.tela_botanica.client.modeles.objets.ListeObservation;
import org.tela_botanica.client.modeles.objets.Utilisateur;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
import com.google.gwt.user.client.Window;
import com.gwtext.client.data.ArrayReader;
import com.gwtext.client.data.FieldDef;
import com.gwtext.client.data.IntegerFieldDef;
import com.gwtext.client.data.MemoryProxy;
import com.gwtext.client.data.Node;
import com.gwtext.client.data.RecordDef;
import com.gwtext.client.data.Store;
import com.gwtext.client.data.StringFieldDef;
import com.gwtext.client.data.Tree;
import com.gwtext.client.widgets.tree.TreeNode;
 
/**
 * Modèle d'accès aux données pour les images. C'est un singleton
 * 
 * @author aurelien
 * 
 */
public class ImageModele implements Rafraichissable {
 
	/**
	 * Booleen indiquant si le médiateur est instancié (l'instance doit être
	 * unique donc le booleen est static)
	 */
	private static boolean estInstancie = false;
 
	/**
	 * le modèle lui même
	 */
	private static ImageModele thisModele = null;
 
	/**
	 * Le médiateur associé au modèle
	 */
	private ImageMediateur iMediateur = null;
 
	/**
	 * La configuration en cours
	 */
	private Configuration config = null;
 
	/**
	 * La liste des image affichées en cours
	 */
	private ListeImageCarnet cacheImage = new ListeImageCarnet(0);
	/**
	 * Table de correspondance entre les mots clés et leurs identifiants
	 */
	private HashMap<String, String> motsCles = new HashMap<String, String>(0);
	/**
	 * Le store contenant les données à afficher, que le modèle transmet au
	 * médiateur quand il le demande
	 */
	private Store st = null;
	/**
	 * Arbre des mots clés
	 */
	private com.gwtext.client.data.Tree arbreMotsCles = new Tree();
 
	/**
	 * Numéro de page en cours
	 */
	private int pageEncours = 0;
	/**
	 * Nombre de pages totales
	 */
	private int pageMax = 1;
	/**
	 * Taille de page (par défaut 50)
	 */
	private int taillePage = 50;
	/**
	 * Nombre d'éléments total correspondant à la requete
	 */
	private int nbElements = 0;
 
	/**
	 * "Presse papier" pour les images qui permet de garder en mémoire une
	 * sélection
	 */
	private Vector<String> selectionImages = new Vector<String>(0);
 
	/**
	 * Retourne une instance de manière unique
	 * 
	 * @param im
	 *            le médiateur à associer
	 * @return l'instance du modèle
	 */
	static ImageModele Instance(ImageMediateur im) {
		// si le modèle n'est pas encore instancié
		if (!estInstancie) {
			// on en crée un nouveau
			estInstancie = true;
			thisModele = new ImageModele(im);
		}
 
		// sinon on retourne le "pointeur" vers le modèle lui-même
		return thisModele;
 
	}
 
	/**
	 * Le constructeur est privé et seule la méthode instance y accède
	 * 
	 * @param im
	 *            le médiateur à associer
	 */
	private ImageModele(ImageMediateur im) {
 
		iMediateur = im;
		config = new Configuration();
	}
 
	/**
	 * Accesseur pour le médiateur
	 * 
	 * @return le médiateur associé
	 */
	public ImageMediateur getIMediateur() {
		return iMediateur;
	}
 
	/**
	 * Appelle le DAO asynchrone pour obtenir la liste des images
	 * 
	 * @param r
	 *            le rafraichissable auxquel on enverra les données
	 */
	public void obtenirNombrePhotoGalerie(Rafraichissable r) {
 
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
 
		int tailleFiltres = valeursFiltres.length;
 
		String[][] criteres = new String[tailleFiltres][2];
 
		String[] utilisateur = {
				"" + getIMediateur().getIdentifiant() };
		criteres[0] = utilisateur;
 
 
		for (int i = 0; i < valeursFiltres.length; i++) {
			criteres[i] = valeursFiltres[i];
		}
 
		// on les crée un DAO auquel on les transmet et qui demande le nombre
		// d'images correspondantes (pour les pages)
		NombreImageAsynchroneDAO niaDAO = new NombreImageAsynchroneDAO(this);
		niaDAO.obtenirNombreImages(this, criteres);
	}
	
	public void obtenirPhotoGalerie(Rafraichissable r)
	{
		String valeursFiltres[][] = getIMediateur().renvoyerFiltres();
		
		int tailleFiltres = valeursFiltres.length;
		
		String[][] criteres2 = new String[tailleFiltres + 2][2];
		
		String[] limite = { "limite", "" + taillePage };
		String[] taillePage = { "numero_page", "" + pageEncours };
		
		criteres2[0] = limite;
		criteres2[1] = taillePage;
 
		for (int i = 0; i < valeursFiltres.length; i++) {
			criteres2[i + 2] = valeursFiltres[i];
		}
		
		// et on crée un DAO auquel on les transmet et qui envoie une requete
		// pour recevoir les images
		ListeImageAsynchroneDAO liaDAO = new ListeImageAsynchroneDAO(this);
		liaDAO.ObtenirListeImages(this, criteres2);
	}
 
	/**
	 * Appelle le DAO d'upload qui va choisir la methode d'upload adaptée et
	 * lancer l'interface appropriée
	 */
	@SuppressWarnings("static-access")
	public void uploaderImages(boolean multiple) {
		ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this);
		if(multiple) {
			IuADaO.appelerUploadMultiple();
		}
		else 
		{
			IuADaO.appelerUploadSimple();
		}
	}
 
	/**
	 * Met à jour la liste des images à partir d'un objet
	 * 
	 * @param o
	 *            la nouvelle liste d'image
	 */
	public void rafraichirListeImage(Object o) {
		cacheImage = (ListeImageCarnet) o;
	}
 
	/**
	 * Met à jour l'arbre des mots clés à partir d'un objet
	 * 
	 * @param o
	 *            le nouvel arbre de mots clés
	 */
	public void rafraichirArbreMotsCles(Object o) {
		arbreMotsCles = (com.gwtext.client.data.Tree) o;
	}
 
	/**
	 * Met à jour la table de correspondance mots clés / ids à partir d'un objet
	 * 
	 * @param o
	 *            la nouvelle table des mots clés
	 */
	@SuppressWarnings("unchecked")
	public void rafraichirMotsCles(Object o) {
		if (o instanceof HashMap) {
			motsCles = (HashMap<String, String>) o;
		}
	}
 
	/**
	 * Va chercher les métadonnées associées à une image dans la liste des
	 * images chargée dans le modèle
	 * 
	 * @param r
	 *            le rafraichissable auquel on enverra les informations
	 * @param id
	 *            l'identifiant de l'image
	 */
	public void obtenirMetadonnees(Rafraichissable r, String id) {
		ImageCarnet im = (ImageCarnet) cacheImage.get(id);
 
		Object meta[] = new Object[3];
		meta[0] = im.getMetadonnesExif();
		meta[1] = im.getMetadonnesIptc();
		meta[2] = im.getInfoGenerales();
 
		r.rafraichir(meta, false);
	}
 
	/**
	 * Va chercher les mots clés associés à une image dans la liste des images
	 * chargée dans le modèle
	 * 
	 * @param r
	 *            le rafraichissable auquel on enverra les informations
	 * @param id
	 *            l'identifiant de l'image
	 */
	public void obtenirMotsClesId(Rafraichissable r, String id) {
		ImageCarnet im = cacheImage.get(id);
		String motsClesId = im.getMotsCles();
		String[] motsClesIdTab = motsClesId.split(",");
 
		r.rafraichir(motsClesIdTab, false);
	}
	
	/**
	 * Va chercher le nom du mot clé associé à un id dans le cache local
	 * 
	 * @param String id
	 *            id du mot clé
	 * @return le mot clé associé à l'identifiant
	 */
	public String obtenirTexteMotCle(String id) {
		
		String correspondanceId = "";
		
		String motCleTexte = motsCles.get(id);
		
		if(motCleTexte != null) {
			correspondanceId = motCleTexte;
		}
		
		return correspondanceId;
	}
	
	/**
	 * Construit une chaine contenant le texte des mots clés séparés par des virgules
	*/
	public String renvoyerChaineMotClesTexte(ImageCarnet ic) {
		String chaineMotsCles = ic.getMotsCles();
		String[] tabMotsCles = chaineMotsCles.split(",");
		String chaineMotsClesTexte = "";
		for (int i = 0; i < tabMotsCles.length; i++) {
			chaineMotsClesTexte += motsCles.get(tabMotsCles[i]);
			chaineMotsClesTexte += (i != tabMotsCles.length - 1) ? "," : "";
		}
		return chaineMotsClesTexte;
	}
 
	/**
	 * Met à jour la liste des images en local et appelle le DAO de mise à jour
	 * pour les commentaires et la date des images selectionnées
	 * 
	 * @param commentaires
	 *            le commentaire à appliquer
	 * @param date
	 *            la date à appliquer
	 * @param ids
	 *            les identifiants des images selectionnées
	 */
	public void mettreAJourCacheImage(String commentaires, String date,
			String note, String ids[]) {
		for (int i = 0; i < ids.length; i++) {
			String key = ids[i];
			ImageCarnet ic = cacheImage.get(key);
			ic.miseAJourInfoGenerales(commentaires, date, note);
			mettreAjourBaseDeDonneesImageCarnet(ic);
		}
 
	}
 
	/**
	 * Ajoute un nouveau mot clés à la liste des mots clés locale
	 * 
	 * @param text
	 *            le mot clé
	 * @param id
	 *            l'identifiant du mot clé
	 */
	public void mettreAjourMotsClesId(String text, String id) {
		motsCles.put(id, text);
	}
 
	/**
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
	 * les informations des images modifiées par l'utilisateur
	 */
	public void mettreAJourBaseDeDonneesListeImageCarnet() {
		ListeImageAsynchroneDAO liDaO = new ListeImageAsynchroneDAO(this);
 
		liDaO.SynchroniserBaseDeDonnees(cacheImage);
	}
 
	/**
	 * Appelle le DAO chargé de mettre à jour la base de données avec les toutes
	 * les informations d'une image donnée
	 * 
	 * @param ic
	 *            l'image à synchroniser avec la base
	 */
	public void mettreAjourBaseDeDonneesImageCarnet(ImageCarnet ic) {
		ImageAsynchroneDAO iaDaO = new ImageAsynchroneDAO(this);
		iaDaO.SynchroniserBaseDeDonnees(ic);
	}
 
	/**
	 * Supprime les images données du cache local et appelle le DAO qui les
	 * supprime de la base de données
	 * 
	 * @param ids
	 *            les identifiants des images selectionnées
	 */
	public void supprimerImages(String[] ids) {
		String rids[] = new String[ids.length];
		ListeImageAsynchroneDAO liDao = new ListeImageAsynchroneDAO(this);
 
		for (int i = 0; i < ids.length; i++) {
			String key = ids[i];
			ImageCarnet ic = cacheImage.get(key);
			rids[i] = ic.getId();
 
			cacheImage.remove(key);
		}
 
		if (rids.length != 0) {
			liDao.supprimerBaseDeDonnees(rids);
		}
	}
 
	/**
	 * Met à jour les données locales suivant le type des nouvelles données et
	 * appelle le médiateur pour le notifier de la mise à jour
	 */
	public void rafraichir(Object nouvelleDonnees,
			boolean repandreRafraichissement) {
		// si l'on a reçu une liste d'images
		if (nouvelleDonnees instanceof ListeImageCarnet) {
			ListeImageCarnet data = (ListeImageCarnet) nouvelleDonnees;
			Object[][] photoData = new Object[data.size()][13];
			int i = 0;
 
			if (data.size() == 0) {
				pageEncours = 0;
			}
 
			// on la parse et on récupère les informations qui nous interessent
			for (Iterator<String> it = data.keySet().iterator(); it.hasNext();) {
				ImageCarnet im = data.get(it.next());
				photoData[i][0] = im.getOrdre();
				photoData[i][1] = im.getNomOriginal();
				photoData[i][2] = im.getDate();
				photoData[i][3] = im.getIptcCity();
				photoData[i][4] = im.getFabriquantAppareil() + " " + im.getModeleAppareil();
				photoData[i][5] = im.getUrlFormatListe();
				photoData[i][6] = im.getUrlFormatGalerie();
				photoData[i][7] = im.getUrlFormatZoom();
				photoData[i][8] = im.getNote();
				photoData[i][9] = im.getId();
				photoData[i][10] = im.getTailleImage()[1];
				photoData[i][11] = im.getTailleImage()[0];
				photoData[i][12] = im.getIdsObsAssociees();
 
				i++;
			}
 
			// creation du store qui les contient
			FieldDef defNumImage = new IntegerFieldDef("num_image");
			FieldDef defNomImage = new StringFieldDef("nom_original");
			FieldDef defDatImage = new StringFieldDef("dat_image");
			FieldDef defLieImage = new StringFieldDef("lie_image");
			FieldDef defAppImage = new StringFieldDef("app_image");
			FieldDef defUrlImageS = new StringFieldDef("url_image_S");
			FieldDef defUrlImageM = new StringFieldDef("url_image_M");
			FieldDef defUrlImage = new StringFieldDef("url_image");
			FieldDef defNoteImage = new IntegerFieldDef("note_image");
			FieldDef defIdImage = new IntegerFieldDef("id_image");
			FieldDef defTailleX = new IntegerFieldDef("taille_x");
			FieldDef defTailleY = new IntegerFieldDef("taille_y");
			FieldDef defObsAssociees = new StringFieldDef("obs_associees");
			FieldDef[] defTab = { defNumImage,defNomImage, defDatImage, defLieImage,
					defAppImage, defUrlImageS, defUrlImageM, defUrlImage,
					defNoteImage, defIdImage, defTailleX, defTailleY, defObsAssociees };
			RecordDef rd = new RecordDef(defTab);
 
			final MemoryProxy dataProxy = new MemoryProxy(photoData);
			final ArrayReader reader = new ArrayReader(rd);
 
			final Store photoStore = new Store(dataProxy, reader);
 
			rafraichirListeImage(nouvelleDonnees);
 
			st = photoStore;
			st.load();
 
			// par défaut le store est trié sur le numéro d'image
			st.sort("num_image");
 
			// si on doit répandre les données, on notifie le médiateur qui les
			// distribuera à son tour
			if (repandreRafraichissement) {
				getIMediateur().synchroniserDonneesZoomListeGalerie(st, this);
			}
		}
 
		// si on reçoit un tableau JSON
		if (nouvelleDonnees instanceof JSONArray) {
			// alors on a reçu les informations sur les mots clés
			JSONArray reponse = (JSONArray) nouvelleDonnees;
 
			final int taillemax = reponse.size();
 
			// si le tableau est vide
			if (taillemax == 0) {
				// on crée un arbre vide
				TreeNode root = new TreeNode();
				root.setId("racine");
				root.setText("Tags");
				String[] usObj = { "Tags", "racine" };
				root.setUserObject(usObj);
				arbreMotsCles.setRootNode(root);
			}
			
			HashMap<String, String> motsCles = new HashMap<String, String>(taillemax);
 
			// pour chacun des élements du tableau
			for (int j = 0; j < taillemax; j++) {
				// on extrait les élements du tableau
				if (reponse.get(j).isObject() != null) {
					JSONObject noeud = (JSONObject) reponse.get(j);
 
					String id_noeud = noeud.get("id_mot_cle_utilisateur")
							.isString().stringValue();
					String mot_cle = noeud.get("mot_cle").isString()
							.stringValue();
					String parent = noeud.get("ce_mot_cle_utilisateur_parent").isString()
							.stringValue();
 
					String[] usObj = { mot_cle, id_noeud };
 
					// et on construit l'arbre à partir de la racine (qui est
					// toujours le premier élément)
					if (id_noeud.equals("racine")) {
						TreeNode root = new TreeNode();
						root.setId(id_noeud);
						root.setText(mot_cle);
						root.setUserObject(usObj);
						arbreMotsCles.setRootNode(root);
					} else {
						// et en ajoutant les noeuds un à un (qui sont renvoyé
						// dans l'ordre hierarchique de leur niveau
						// ce qui permet de les traiter séquentiellement)
						TreeNode node = new TreeNode();
						node.setId(id_noeud);
						node.setText(mot_cle);
						node.setChecked(false);
						Node parentNode = arbreMotsCles.getNodeById(parent);
						node.setUserObject(usObj);
						parentNode.appendChild(node);
					}
					
					motsCles.put(id_noeud, mot_cle);
				}
			}
			
			
			// enfin on met à jour l'arbre des mots clés contenu dans le modèle
			rafraichirArbreMotsCles(arbreMotsCles);
			// la table de hachage
			rafraichirMotsCles(motsCles);
			// et on notifie le médiateur de la mise à jour en lui passant une
			// copie des données
			getIMediateur().rafraichirArbreMotsCles(arbreMotsCles);
		}
 
		// Si on reçoit un tableau d'entiers
		// c'est un tableau d'un seul entier qui est le nombre d'images
		// correspondant aux critères
		if (nouvelleDonnees instanceof int[]) {
			int[] pages = (int[]) nouvelleDonnees;
 
			// on calcule le nombre de pages nécessaires et on les met à jour
			// dans le modèle
			pageMax = calculerNbPages(pages[0]);
			nbElements = pages[0];
 
			// et on notifie de le mediateur du changement des valeurs
			getIMediateur().changerPageMaxEtCourante(pageMax, pageEncours,
					taillePage, pages[0]);
			
			obtenirPhotoGalerie(this) ;
		}
		
		if(nouvelleDonnees instanceof ListeObservation) {
			
			getIMediateur().rafraichirMiniListeObservations((ListeObservation)nouvelleDonnees) ;
		}
		
		if(nouvelleDonnees instanceof Tree) {
			rafraichirArbreMotsCles(nouvelleDonnees);
			getIMediateur().rafraichirArbreMotsCles((Tree)nouvelleDonnees);
		}
	}
 
	/**
	 * Affiche les paires / valeur de tous les mots clés stockés
	 */
	public void afficherMotsCles() {
		for (Iterator<String> it = motsCles.keySet().iterator(); it.hasNext();) {
			String key = it.next();
			String valeur = (String) motsCles.get(key);
			System.out.println("clé : " + key + " valeur : " + valeur);
		}
	}
 
	/**
	 * Met à jour les mots clés associés à une image et appelle le DAO pour
	 * synchroniser la base de données
	 * 
	 * @param ids
	 *            les identifiants des images selectionnées
	 * @param motsClesEnCours
	 *            les mots clés à appliquer aux images
	 * @param arbreMC
	 *            l'arbre de mots clés en cours
	 */
	public void mettreAjourMotsCles(String[] ids, String motsClesEnCours,
			com.gwtext.client.data.Tree arbreMC) {
		
		String idImgs = ""; 
		for (int i = 0; i < ids.length; i++) {
			if (cacheImage.containsKey(ids[i])) {
				ImageCarnet ic = (ImageCarnet) cacheImage.get(ids[i]);
				ic.mettreAjourMotsCles(motsClesEnCours);
			}
			
			idImgs += ids[i];
			idImgs += (i < (ids.length - 1)) ? ",": ""; 
		}
		
		LiaisonMotsClesImageAsynchroneDAO liMcDao = new LiaisonMotsClesImageAsynchroneDAO(this);
		liMcDao.modifier(this, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idImgs, motsClesEnCours);
 
		rafraichirArbreMotsCles(arbreMC);
	}
 
	/**
	 * Appelle le DAO des mots clés pour obtenir l'arbre complet stocké dans la
	 * base de données
	 */
	public void initialiserArbreMotsCles() {
		
			MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO();
			MCDao.obtenirListeMotsCles(this);
	}
 
	/**
	 * Envoie l'arbre des mots clés stocké localement à l'élément rafrachissable
	 * donné, qui le demande
	 * 
	 * @param r
	 *            le rafraichissable demandeur de l'arbre
	 */
	public void obtenirArbreMotCle(Rafraichissable r) {
			r.rafraichir(arbreMotsCles, false);
	}
 
	/**
	 * Ajoute un mot clé à l'arbre des mots clés local et appelle le DAO qui
	 * fait la mise à jour de l'arbre des mots clés dans la base
	 * 
	 * @param n
	 *            le nouveau noeud contenant le mot clé
	 * @param arbreMC
	 *            l'arbre des mots cles en cours
	 */
	public void ajouterMotCleDansArbre(TreeNode n,
			com.gwtext.client.data.Tree arbreMC) {
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO();
 
		String[] usObj = (String[]) n.getUserObject();
		String motCle = usObj[0];
		String id = usObj[1];
		String parentId = "";
 
		if (!id.equals("racine")) {
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
			parentId = parentUsObj[1];
		} else {
			parentId = "racine";
		}
 
		rafraichirArbreMotsCles(arbreMC);
 
		String nouveauMotCle = "&identifiant=" + getIdentifiant() + "&motcle="
				+ motCle + "&id=" + id + "&parent=" + parentId;
		MCDao.ajouterBaseDeDonnees(nouveauMotCle);
	}
 
	/**
	 * Supprime un noeud de l'arbre des mots clés et appelle le DAO qui va
	 * supprimer les mots clés associés dans la base
	 * 
	 * @param n
	 *            le noeud à supprimer
	 * @param arbreMC
	 *            l'arbre des mots clés en cours
	 */
	public void supprimerMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO();
 
		String[] usObj = (String[]) n.getUserObject();
		String id = usObj[1];
 
		MCDao.supprimerBaseDeDonnees(id);
 
	}
 
	/**
	 * Modifie le noeud donné dans l'arbre des mots clés en cours et appelle le
	 * DAO qui synchronise la modification dans la base de données
	 * 
	 * @param n
	 *            le noeud modifié
	 * @param arbreMC
	 *            l'arbre des mots clés en cours
	 */
	public void modifierMotCleDansArbre(TreeNode n, Tree arbreMC) {
 
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO();
 
		String[] usObj = (String[]) n.getUserObject();
		String motCle = usObj[0];
		String id = usObj[1];
		String parentId = "";
 
		if (!id.equals("racine")) {
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
			parentId = parentUsObj[1];
		} else {
			parentId = "racine";
		}
 
		rafraichirArbreMotsCles(arbreMC);
 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
				+ parentId;
		MCDao.modifierBaseDeDonnees(motCleModifie);
 
	}
 
	/**
	 * Deplace un noeud dans l'arbre des mots cles et appelle le DAO qui
	 * reorganise l'arbre dans la base de donnees suivant le changement
	 * 
	 * @param n
	 *            le noeud deplace (et son sous arbre associe)
	 * @param arbreMC
	 *            l'arbre des mots cles en cours
	 */
	public void deplacerMotCleDansArbre(TreeNode n, Tree arbreMC) {
		MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO();
 
		String[] usObj = (String[]) n.getUserObject();
		String motCle = usObj[0];
		String id = usObj[1];
		String parentId = "";
		if (!id.equals("racine")) {
			String[] parentUsObj = (String[]) n.getParentNode().getUserObject();
			parentId = parentUsObj[1];
		} else {
			parentId = "racine";
		}
 
		rafraichirArbreMotsCles(arbreMC);
 
		String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent="
				+ parentId;
		MCDao.deplacerBaseDeDonnees(motCleModifie);
	}
 
	/**
	 * Change le numéro de la page en cours et envoie une demande de mise à jour
	 * des données
	 * 
	 * @param nouvellePageCourante
	 *            la nouvelle page à afficher
	 */
	public void changerNumeroPage(int nouvellePageCourante) {
		pageEncours = nouvellePageCourante;
		obtenirNombrePhotoGalerie(this);
	}
 
	/**
	 * Calcule le nombre de pages nécessaires pour afficher un nombre d'élements
	 * donnés en fonction de la taille de page en cours
	 * 
	 * @param nbElements
	 *            le nombre d'élements total
	 * @return le nombre de pages
	 */
	public int calculerNbPages(int nbElements) {
		// A cause de la betise de java pour les conversion implicite on fait
		// quelques conversions manuellement
		// pour eviter qu'il arrondisse mal la division
		// nombre de pages = (nombre d'element / taille de la page) arrondie à
		// l'entier superieur
		double nPage = (1.0 * nbElements) / (1.0 * taillePage);
		double nPageRound = Math.ceil(nPage);
		Double nPageInt = new Double(nPageRound);
 
		// on convertit en entier
		return nPageInt.intValue();
	}
 
	/**
	 * Recalcule la page en cours lors du changement du nombre d'élements
	 * 
	 * @param nbElements
	 *            le nombre d'élements total
	 * @return la nouvelle page encours
	 */
	public int calculerPageCourante(int nbElements) {
		// on calcule le nombre de page
		int nouvelNbPages = calculerNbPages(nbElements);
		// la nouvelle page en cours
		double nPageCourante = (1.0 * pageEncours) / (1.0 * pageMax)
				* (1.0 * nouvelNbPages);
 
		// on arrondit au supérieur
		double nPageRound = Math.ceil(nPageCourante);
		Double nPageInt = new Double(nPageRound);
 
		// on convertit en entier
		return Math.abs(nPageInt.intValue());
	}
 
	/**
	 * Change la taille de page et recalcule la page encours
	 * 
	 * @param nouvelleTaillePage
	 *            la nouvelle taille de page à utiliser
	 */
	public void changerTaillePage(int nouvelleTaillePage) {
		taillePage = nouvelleTaillePage;
		pageEncours = calculerPageCourante(nbElements);
		obtenirNombrePhotoGalerie(this);
	}
	
	/**
	 * Met la valeur de la page en cours à la dernière 
	 */
	public void setDernierePage() {
		changerNumeroPage(pageMax);
	}
 
	/**
	 * Notifie le mediateur que l'upload ou le download est termine et qu'il
	 * faut rafraichir les vues avec les nouvelles données
	 */
	public void requeteTerminee() {
		getIMediateur().demasquerChargement();
		getIMediateur().rafraichirToutesVues();
	}
 
	/**
	 * Obtient l'identifiant de l'utilisateur auprès du médiateur
	 * 
	 * @return id de l'utilisateur
	 */
	public String getIdentifiant() {
 
		return getIMediateur().getIdentifiant();
	}
 
	/**
	 * renvoie la taille d'une image grâce à son identifiant
	 * 
	 * @param id
	 *            l'identifiant de l'image
	 * @return un tableau contenant la longueur et la hauteur de l'image
	 */
	public String[] obtenirTailleImage(String id) {
 
		return (cacheImage.get(id)).getTailleImage();
 
	}
 
	/**
	 * Suivant l'id d'une image donnée, fais une demande au modèle pour qu'il
	 * renvoie la note associée au rafrachissable qui la demande
	 * 
	 * @param r
	 *            le rafraichissable demandeur de l'information
	 * @param id
	 *            l'identifiant del'image
	 */
	public void obtenirNote(Rafraichissable r, String id) {
 
		r.rafraichir((cacheImage.get(id)).getNote(), true);
 
	}
 
	/**
	 * Accesseur pour la configuration en cours d'utilisation
	 * 
	 * @return la configuration
	 */
	public Configuration getConfig() {
 
		return config;
	}
 
	/**
	 * Ajoute des images à la selection en cours
	 * 
	 * @param ids
	 *            les identifiants des images à ajouter
	 */
	public void ajouterImagesSelection(String[] ids) {
 
		for (int i = 0; i < ids.length; i++) {
			
			String idImg = cacheImage.get(ids[i]).getId();
			selectionImages.add(idImg);
		}
	}
 
	public int getCompteSelection() {
		return selectionImages.size();
	}
	
	/**
	 * Vide la selection en cours
	 */
	public void viderSelection() {
		selectionImages.clear();
	}
 
	public String renvoyerSelection() {
 
		String selection = "";
		
		if(selectionImages.size() <= 0)
		{
			selection += "-255" ;
		}
		else
		{
			for (Iterator<String> it = selectionImages.iterator(); it.hasNext();) {
	
				String idEncours = it.next();
				selection += idEncours + ",";
			}
		}
 
		return selection;
	}
 
	public void lierImagesObervations(String idsObs, String idsImg) {
		
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
		lienDAO.lierImageBaseDeDonnees(idsImg, idsObs) ;
		
	}
 
	public void obtenirLiaisonObservations(ImageMediateur imageMediateur,
			String id) {
		
		String imgId = cacheImage.get(id).getId() ;
		
		LienImageAsynchroneDAO lienDao = new LienImageAsynchroneDAO(this) ;
		lienDao.obtenirLiaisonsImagesObservations(this, imgId) ;
		
	}
 
	public void supprimerLiaisonImages(String[] idsImg, String idObs) {
		
		String chaineIdImg = "";
		
		for(int i = 0; i < idsImg.length; i++) {
			String idImg = cacheImage.get(idsImg[i]).getId() ;
			chaineIdImg += ","+idImg;
		}
		
		chaineIdImg = chaineIdImg.replaceFirst(",", "");
		
		LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ;
		lienDAO.supprimerLienImageObservation(chaineIdImg, idObs) ;		
	}
 
	public void obtenirMiniListeObservations(Rafraichissable r, String[] critere, int taillePage, int numeroPage) {
		
		String[][] criteres = {{critere[0],critere[1]},{"limite",""+taillePage},{"numero_page",""+numeroPage}} ;		
		
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
		ListeObservationAsynchroneDAO loaDAO = new ListeObservationAsynchroneDAO(this);
		loaDAO.obtenirListeObservation(r, iMediateur.getIdentifiant(), criteres);	
		
	}
 
	public void obtenirNombreMiniListeObservations(Rafraichissable r, String[] critere) {
		
		String[][] criteres = {{critere[0],critere[1]}} ;		
		
		// et on crée un DAO auquel on les transmet et qui envoie une requete pour recevoir les images
		NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this);
		noaDAO.obtenirNombreObservation(r, iMediateur.getIdentifiant(), criteres);	
		
	}
 
	public void obtenirDatesImages(Rafraichissable r) {
		ListeDateImageAsynchroneDAO lDateDao = new ListeDateImageAsynchroneDAO(this);
		lDateDao.obtenirListeDate(r, iMediateur.getIdentifiant());
	}
 
}

Subversion Repositories eFlore/Applications.cel

(root)/trunk/src/org/tela_botanica/client/image/ImageModele.java @ 1045 – Rev 989 → 1009

Rev 989		Rev 1009
1	`package org.tela_botanica.client.image;`	1	`package org.tela_botanica.client.image;`
2		2
3	`import java.util.HashMap;`	3	`import java.util.HashMap;`
4	`import java.util.Iterator;`	4	`import java.util.Iterator;`
5	`import java.util.Vector;`	5	`import java.util.Vector;`
6		6
7	`import org.tela_botanica.client.interfaces.Rafraichissable;`	7	`import org.tela_botanica.client.interfaces.Rafraichissable;`
8	`import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;`	8	`import org.tela_botanica.client.modeles.dao.ImageAsynchroneDAO;`
9	`import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;`	9	`import org.tela_botanica.client.modeles.dao.ImageUploaderAsynchroneDAO;`
10	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;`	10	`import org.tela_botanica.client.modeles.dao.LiaisonMotsClesImageAsynchroneDAO;`
11	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`	11	`import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO;`
12	`import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;`	12	`import org.tela_botanica.client.modeles.dao.ListeDateImageAsynchroneDAO;`
13	`import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;`	13	`import org.tela_botanica.client.modeles.dao.ListeImageAsynchroneDAO;`
14	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`	14	`import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO;`
15	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`	15	`import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO;`
16	`import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;`	16	`import org.tela_botanica.client.modeles.dao.NombreImageAsynchroneDAO;`
17	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`	17	`import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO;`
18	`import org.tela_botanica.client.modeles.objets.Configuration;`	18	`import org.tela_botanica.client.modeles.objets.Configuration;`
19	`import org.tela_botanica.client.modeles.objets.ImageCarnet;`	19	`import org.tela_botanica.client.modeles.objets.ImageCarnet;`
20	`import org.tela_botanica.client.modeles.objets.ListeImageCarnet;`	20	`import org.tela_botanica.client.modeles.objets.ListeImageCarnet;`
21	`import org.tela_botanica.client.modeles.objets.ListeObservation;`	21	`import org.tela_botanica.client.modeles.objets.ListeObservation;`
22	`import org.tela_botanica.client.modeles.objets.Utilisateur;`	22	`import org.tela_botanica.client.modeles.objets.Utilisateur;`
23		23
24	`import com.google.gwt.json.client.JSONArray;`	24	`import com.google.gwt.json.client.JSONArray;`
25	`import com.google.gwt.json.client.JSONObject;`	25	`import com.google.gwt.json.client.JSONObject;`
26	`import com.google.gwt.user.client.Window;`	26	`import com.google.gwt.user.client.Window;`
27	`import com.gwtext.client.data.ArrayReader;`	27	`import com.gwtext.client.data.ArrayReader;`
28	`import com.gwtext.client.data.FieldDef;`	28	`import com.gwtext.client.data.FieldDef;`
29	`import com.gwtext.client.data.IntegerFieldDef;`	29	`import com.gwtext.client.data.IntegerFieldDef;`
30	`import com.gwtext.client.data.MemoryProxy;`	30	`import com.gwtext.client.data.MemoryProxy;`
31	`import com.gwtext.client.data.Node;`	31	`import com.gwtext.client.data.Node;`
32	`import com.gwtext.client.data.RecordDef;`	32	`import com.gwtext.client.data.RecordDef;`
33	`import com.gwtext.client.data.Store;`	33	`import com.gwtext.client.data.Store;`
34	`import com.gwtext.client.data.StringFieldDef;`	34	`import com.gwtext.client.data.StringFieldDef;`
35	`import com.gwtext.client.data.Tree;`	35	`import com.gwtext.client.data.Tree;`
36	`import com.gwtext.client.widgets.tree.TreeNode;`	36	`import com.gwtext.client.widgets.tree.TreeNode;`
37		37
38	`/**`	38	`/**`
39	`* Modèle d'accès aux données pour les images. C'est un singleton`	39	`* Modèle d'accès aux données pour les images. C'est un singleton`
40	`*`	40	`*`