Subversion Repositories eFlore/Applications.cel

Compare Revisions

Ignore whitespace Rev 1 → Rev 2

/trunk/src/org/tela_botanica/client/image/ImageModele.java
New file
0,0 → 1,742
package org.tela_botanica.client.image;
 
import java.util.HashMap;
import java.util.Iterator;
 
import org.tela_botanica.client.interfaces.Rafraichissable;
import org.tela_botanica.client.modeles.Configuration;
import org.tela_botanica.client.modeles.ImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ImageCarnet;
import org.tela_botanica.client.modeles.ImageUploaderAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeImageAsynchroneDAO;
import org.tela_botanica.client.modeles.ListeImageCarnet;
import org.tela_botanica.client.modeles.MotsClesAsynchroneDAO;
import org.tela_botanica.client.modeles.NombreImageAsynchroneDAO;
 
import com.google.gwt.json.client.JSONArray;
import com.google.gwt.json.client.JSONObject;
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 ;
/**
* 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 obtenirPhotoGalerie(Rafraichissable r)
{
String motsClesFiltres[][] = getIMediateur().renvoyerFiltres() ;
int tailleFiltres = motsClesFiltres.length ;
String[][] criteres = new String[tailleFiltres+1][2] ;
String[][] criteres2 = new String[tailleFiltres+2][2] ;
String[] utilisateur = {"ci_ce_utilisateur", ""+getIMediateur().getIdentifiant()} ;
criteres[0] = utilisateur ;
String[] limite = {"ci_limite" ,""+taillePage } ;
String[] taillePage = {"ci_numero_page",""+pageEncours} ;
criteres2[0] = limite ;
criteres2[1] = taillePage ;
for (int i = 0 ; i < motsClesFiltres.length; i++) {
criteres[i+1] = motsClesFiltres[i] ;
criteres2[i+2] = motsClesFiltres[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) ;
// 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()
{
ImageUploaderAsynchroneDAO IuADaO = new ImageUploaderAsynchroneDAO(this) ;
IuADaO.choisirMethodeUpload() ;
}
/**
* 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) ;
}
/**
* 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()][8];
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.getDate() ;
photoData[i][2] = im.getIptcCity() ;
photoData[i][3] = im.getMake()+" "+im.getModel() ;
photoData[i][4] = im.getSUrl() ;
photoData[i][5] = im.getMUrl() ;
photoData[i][6] = im.getLUrl() ;
photoData[i][7] = im.getNote() ;
i++ ;
}
// creation du store qui les contient
FieldDef defNumImage = new IntegerFieldDef("num_image");
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[] defTab = {defNumImage,defDatImage,defLieImage,defAppImage,defUrlImageS,defUrlImageM,defUrlImage,defNoteImage};
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) ;
}
// 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("cmc_id_mot_cle_utilisateur").isString().stringValue() ;
String mot_cle = noeud.get("cmc_mot_cle").isString().stringValue() ;
String parent = noeud.get("cmc_id_parent").isString().stringValue() ;
String[] usObj = {mot_cle, id_noeud} ;
// et on construit l'arbre à partir de la racine (qui est toujoursl e 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) ;
}
}
}
// enfin on met à jour l'arbre des mots clés contenu dans le modèle
rafraichirArbreMotsCles(arbreMotsCles) ;
// 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]) ;
}
}
/**
* 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)
{
for (int i = 0; i < ids.length; i++)
{
if(cacheImage.containsKey(ids[i]))
{
ImageCarnet ic = (ImageCarnet)cacheImage.get(ids[i]) ;
ic.mettreAjourMotsCles(motsClesEnCours) ;
ImageAsynchroneDAO imgDao = new ImageAsynchroneDAO(this) ;
imgDao.SynchroniserMotsClesImageBaseDeDonnees(ic) ;
}
}
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(this) ;
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(this) ;
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(this) ;
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(this) ;
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(this) ;
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 ;
obtenirPhotoGalerie(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) ;
obtenirPhotoGalerie(this) ;
}
/**
* 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 ;
}
}