| New file |
|---|
| 0,0 → 1,603 |
|---|
| package org.tela_botanica.client.observation; |
| |
| |
| //TODO : normaliser les noms de methodes (obtenir, ajouter ...) |
| |
| import java.util.HashMap; |
| |
| import org.tela_botanica.client.i18n.Msg; |
| import org.tela_botanica.client.interfaces.Rafraichissable; |
| import org.tela_botanica.client.modeles.dao.ExportObservationsDAO; |
| import org.tela_botanica.client.modeles.dao.ImageGeneriqueVueAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ImageInformationRepartitionAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ImportObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.InformationLocaliteDAO; |
| import org.tela_botanica.client.modeles.dao.LiaisonMotsClesObsAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.LienImageAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeDateObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeEntiteGeographiqueObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielLocaliteAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielNomAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ListeReferentielPersoAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.MotsClesAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NomRetenuAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.NombreObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.ObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.dao.TransmissionObservationAsynchroneDAO; |
| import org.tela_botanica.client.modeles.objets.Configuration; |
| import org.tela_botanica.client.modeles.objets.ListeObservation; |
| import org.tela_botanica.client.modeles.objets.Observation; |
| import org.tela_botanica.client.modeles.objets.Utilisateur; |
| import org.tela_botanica.client.modeles.objets.ListeReferentielPerso.TypesReferentiels; |
| import org.tela_botanica.client.util.MotsClesUtilitaire; |
| |
| 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.Node; |
| import com.gwtext.client.data.Tree; |
| import com.gwtext.client.widgets.tree.TreeNode; |
| |
| |
| public class ObservationModele 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 ; |
| private static ObservationModele thisModele = null ; |
| |
| /** |
| * La configuration en cours |
| */ |
| private Configuration config = null; |
| |
| /** |
| * Le médiateur associé au modèle |
| */ |
| private ObservationMediateur observationMediateur = null ; |
| |
| /** |
| * La liste des mots clés en cours |
| */ |
| private HashMap<String, String> motsCles = new HashMap<String, String>(0); |
| private Tree arbreMotsCles = new Tree() ; |
| |
| /** |
| * La liste des observations affichées en cours (verifier utilité) |
| */ |
| private ListeObservation cacheObservation = new ListeObservation(0) ; |
| |
| /** |
| * Retourne une instance de manière unique |
| * @param im le médiateur à associer |
| * @return l'instance du modèle |
| */ |
| |
| static ObservationModele Instance(ObservationMediateur observationMediateur) |
| { |
| // si le modèle n'est pas encore instancié |
| if(!estInstancie) |
| { |
| // on en crée un nouveau |
| estInstancie = true ; |
| thisModele = new ObservationModele(observationMediateur); |
| } |
| return thisModele ; |
| } |
| |
| |
| |
| private ObservationModele(ObservationMediateur observationMediateur) { |
| |
| this.observationMediateur=observationMediateur; |
| |
| config = new Configuration(); |
| |
| |
| } |
| |
| /** |
| * Appelle le DAO asynchrone pour obtenir le nombre d'observation |
| * @param r le rafraichissable auxquel on enverra les données |
| * @param filtrage |
| * @param taillePage |
| */ |
| public void obtenirNombreObservation(Rafraichissable r) { |
| |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres() ; |
| // on rassemble les critères |
| // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages) |
| NombreObservationAsynchroneDAO noaDAO = new NombreObservationAsynchroneDAO(this) ; |
| noaDAO.obtenirNombreObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres) ; |
| |
| } |
| |
| |
| public void obtenirListeObservation(Rafraichissable r) { |
| obtenirListeObservation(r,observationMediateur.getTaillePage(),observationMediateur.getPageEnCours()); |
| } |
| |
| /** |
| * Appelle le DAO asynchrone pour obtenir la liste des images |
| * @param r le rafraichissable auxquel on enverra les données |
| * @param taillePage |
| */ |
| public void obtenirListeObservation(Rafraichissable r, int taillePage, int pageEncours) { |
| |
| |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres() ; |
| // on rassemble les critères |
| |
| |
| // ensuite on demande la page correspondante avec les mêmes critères |
| String[][] criteres2 = new String[criteres.length+4][2] ; |
| |
| criteres2[0][0] = "limite" ; |
| criteres2[0][1] = ""+taillePage ; |
| criteres2[1][0] = "numero_page" ; |
| criteres2[1][1] = ""+pageEncours ; |
| criteres2[2][0] = "tri" ; |
| criteres2[2][1] = ""+observationMediateur.renvoyerTri(); |
| criteres2[3][0] = "tri_dir"; |
| criteres2[3][1] = ""+observationMediateur.renvoyerDirectionTri() ; |
| |
| for(int i = 0 ; i < criteres.length ; i++) |
| { |
| criteres2[i+4][0] = criteres[i][0] ; |
| criteres2[i+4][1] = criteres[i][1] ; |
| } |
| |
| // 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, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres2); |
| } |
| |
| /** |
| * |
| * Lance la creation d'une observation |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| |
| public void ajouterObservation(Rafraichissable r, Observation obs) { |
| ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this); |
| obsDAO.ajouter(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| |
| /** |
| * |
| * Lance la creation d'une observation |
| * @param r : la vue demandeuse de donnee |
| * @param critere : les criteres de selection |
| */ |
| public void modifierObservation(Rafraichissable r, Observation obs) { |
| ObservationAsynchroneDAO obsDAO=new ObservationAsynchroneDAO(this); |
| obsDAO.modifier(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| |
| public void modifierObservationEnMasse( |
| Rafraichissable r, Observation obs) { |
| ListeObservationAsynchroneDAO liObsDAO=new ListeObservationAsynchroneDAO(this); |
| liObsDAO.modifierEnMasse(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obs); |
| } |
| |
| public void supprimerObservation(Rafraichissable r, String numeroOrdre) { |
| |
| ObservationAsynchroneDAO obsDao = new ObservationAsynchroneDAO(this) ; |
| obsDao.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(),numeroOrdre) ; |
| |
| |
| } |
| |
| |
| /** |
| * Accesseur pour la configuration en cours d'utilisation |
| * |
| * @return la configuration |
| */ |
| public Configuration getConfig() { |
| return config; |
| } |
| |
| /** |
| * Obtenir des informations de repartition relative a un numero nomenclatural |
| * @param r |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirImageInformationRepartition(Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| |
| ImageInformationRepartitionAsynchroneDAO repDAO= new ImageInformationRepartitionAsynchroneDAO(this); |
| repDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation); |
| |
| |
| } |
| |
| /** |
| * Obtenir une image generique associee a un numero nomenclatural |
| * @param r |
| * @param numeroNomenclaturalSaisiObservation |
| */ |
| public void obtenirImageGenerique( Rafraichissable r, String referentielTaxo, String numeroNomenclaturalSaisiObservation) { |
| ImageGeneriqueVueAsynchroneDAO imgDAO= new ImageGeneriqueVueAsynchroneDAO(this); |
| imgDAO.obtenirURLImage(r, referentielTaxo, numeroNomenclaturalSaisiObservation); |
| } |
| |
| |
| /** |
| * Obtenir la liste de l'ensemble des entites geographiques associes aux observation d'un utilisateur |
| * @param r |
| */ |
| public void obtenirListeEntiteGeographique(Rafraichissable r) { |
| ListeEntiteGeographiqueObservationAsynchroneDAO entDAO = new ListeEntiteGeographiqueObservationAsynchroneDAO(this); |
| entDAO.obtenirListeEntitesGeographiques(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| } |
| |
| |
| |
| public void obtenirDatesObservation( |
| Rafraichissable r) { |
| ListeDateObservationAsynchroneDAO ldoDAO = new ListeDateObservationAsynchroneDAO(this); |
| ldoDAO.obtenirListeDate(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()); |
| } |
| |
| |
| |
| public void obtenirLiaisonImage(Rafraichissable r, String idObservation) { |
| LienImageAsynchroneDAO liaDAO = new LienImageAsynchroneDAO(this) ; |
| liaDAO.obtenirLiaisonsObservationsImages(r, idObservation,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte()) ; |
| } |
| |
| |
| |
| public void exporterObservations(String format, String groupes) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres(); |
| // on rassemble les critères |
| // on les crée un DAO auquel on les transmet et qui demande le nombre d'images correspondantes (pour les pages) |
| ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ; |
| exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), criteres, format, groupes) ; |
| } |
| |
| public void exporterObservationsPDF(String[] ordres) { |
| String[][] criteres = {{"",""}} ; |
| criteres = observationMediateur.renvoyerFiltres(); |
| String ids = ""; |
| for (int j = 0; j < ordres.length; j++) { |
| ids += getIdPourOrdreObs(ordres[j]) + ","; |
| } |
| |
| String[] fmt = {"obsids", ids}; |
| String[][] tous_criteres = new String[criteres.length + 1][]; |
| System.arraycopy(criteres, 0, tous_criteres, 0, criteres.length); |
| tous_criteres[tous_criteres.length - 1] = fmt; |
| |
| ExportObservationsDAO exoDAO = new ExportObservationsDAO(this) ; |
| exoDAO.exporterObservations(Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), tous_criteres, "pdf", "standard") ; |
| } |
| |
| |
| |
| public void supprimerLiaisonImages(String idImg, String idObs) { |
| LienImageAsynchroneDAO lienDAO = new LienImageAsynchroneDAO(this) ; |
| lienDAO.supprimerLienImageObservation(idImg, idObs) ; |
| } |
| |
| public void supprimerListeObservation(Rafraichissable r, String numObs) { |
| ListeObservationAsynchroneDAO lioaDAO = new ListeObservationAsynchroneDAO(this); |
| lioaDAO.supprimerListeObservation(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObs); |
| } |
| |
| public void transmettreListeObservation(Rafraichissable r, String numObsapl, boolean publier) { |
| TransmissionObservationAsynchroneDAO toaDAO = new TransmissionObservationAsynchroneDAO(this); |
| toaDAO.transmettreObservations(r, Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), numObsapl, publier); |
| } |
| |
| public void analyserHistorique(Rafraichissable r,String anum) { |
| NomRetenuAsynchroneDAO nraDAO = new NomRetenuAsynchroneDAO(this); |
| nraDAO.obtenirNomRetenu(r, anum); |
| } |
| |
| |
| |
| public void importerObservations() { |
| ImportObservationAsynchroneDAO ioDAO = new ImportObservationAsynchroneDAO(this); |
| ioDAO.importerObservations(); |
| } |
| |
| |
| |
| public void obtenirArbreMotsCles(Rafraichissable r) { |
| MotsClesAsynchroneDAO mcoDAO = new MotsClesAsynchroneDAO("obs"); |
| mcoDAO.obtenirListeMotsCles(this); |
| } |
| |
| @Override |
| public void rafraichir(Object nouvelleDonnees, boolean repandreRaffraichissement) { |
| if(nouvelleDonnees instanceof JSONArray) { |
| JSONArray donneesArbre = (JSONArray)nouvelleDonnees; |
| Object[] arbreEtCorrespondancesIds = MotsClesUtilitaire.construireArbre(Msg.get("projets"), "racine_obs", donneesArbre, false); |
| |
| arbreMotsCles = (Tree)arbreEtCorrespondancesIds[0]; |
| motsCles = (HashMap<String, String>)arbreEtCorrespondancesIds[1]; |
| |
| // 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 |
| observationMediateur.rafraichirArbreMotsCles(arbreMotsCles); |
| } |
| |
| if(nouvelleDonnees instanceof Observation) { |
| observationMediateur.obtenirNombreObservation(); |
| } |
| } |
| |
| /** |
| * 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 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) { |
| Observation o = cacheObservation.get(id); |
| String motsClesId = o.getMotsCles(); |
| String[] motsClesIdTab = motsClesId.split(","); |
| r.rafraichir(motsClesIdTab, false); |
| } |
| |
| /** |
| * Met à jour les mots clés associés à une obs et appelle le DAO pour |
| * synchroniser la base de données |
| * |
| * @param ids |
| * les identifiants des observations selectionnées |
| * @param motsClesEnCours |
| * les mots clés à appliquer aux observations |
| */ |
| public void mettreAjourMotsCles(String motsClesEnCours, String[] idsObsALier) { |
| |
| String motsCles = ""; |
| String obsAlier = ""; |
| int nbObs = 0; |
| |
| for (int i = 0; i < idsObsALier.length; i++) { |
| |
| if (cacheObservation.containsKey(idsObsALier[i])) { |
| |
| if(!motsClesEnCours.endsWith(";") && !motsClesEnCours.startsWith(";")) { |
| motsCles += ";"; |
| } |
| |
| motsCles += motsClesEnCours; |
| |
| nbObs++; |
| |
| Observation m = cacheObservation.get(idsObsALier[i]); |
| obsAlier += ","+m.getId(); |
| |
| if(m.getMotsCles() != null && !m.getMotsCles().endsWith(";") && !motsCles.startsWith(";")) { |
| motsCles += ";"; |
| } |
| |
| m.setMotsCles(m.getMotsCles()+motsCles); |
| |
| cacheObservation.put(m.getNumeroOrdre(), m); |
| } |
| } |
| |
| while(obsAlier.startsWith(",")) { |
| obsAlier = obsAlier.replaceFirst(",", ""); |
| } |
| |
| if(nbObs > 0) { |
| |
| LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this); |
| lmcDAO.modifier(this,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), obsAlier, motsClesEnCours); |
| } |
| } |
| |
| |
| public void supprimerLiaisonMotCleObservations( |
| Rafraichissable r, String idObs, String idMC) { |
| |
| LiaisonMotsClesObsAsynchroneDAO lmcDAO = new LiaisonMotsClesObsAsynchroneDAO(this); |
| lmcDAO.supprimer(r,Utilisateur.getInstance().getIdentifiantUtilisateurConsulte(), idObs, idMC); |
| |
| } |
| |
| /** |
| * 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, Rafraichissable r) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| |
| if (!id.equals("racine_obs")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| if(!parentUsObj[1].equals("racine_obs")) { |
| parentId = parentUsObj[1]; |
| } |
| } |
| |
| rafraichirArbreMotsCles(arbreMC); |
| motsCles.put(id, motCle); |
| |
| String nouveauMotCle = "&identifiant=" + Utilisateur.getInstance().getIdentifiantUtilisateurConsulte() + "&motcle=" |
| + motCle + "&id=" + id + "&parent=" + parentId; |
| MCDao.ajouterBaseDeDonnees(nouveauMotCle, r); |
| } |
| |
| /** |
| * 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, Rafraichissable r) { |
| |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| |
| String[] usObj = (String[]) n.getUserObject(); |
| String id = usObj[1]; |
| |
| rafraichirArbreMotsCles(arbreMC); |
| |
| MCDao.supprimerBaseDeDonnees(id, r); |
| |
| } |
| |
| /** |
| * 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, Rafraichissable r) { |
| |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| |
| if (!id.equals("racine_obs")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| if(!parentUsObj[1].equals("racine_obs")) { |
| parentId = parentUsObj[1]; |
| } |
| } |
| |
| rafraichirArbreMotsCles(arbreMC); |
| |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.modifierBaseDeDonnees(motCleModifie, r); |
| |
| } |
| |
| /** |
| * 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, Rafraichissable r) { |
| MotsClesAsynchroneDAO MCDao = new MotsClesAsynchroneDAO("obs"); |
| |
| String[] usObj = (String[]) n.getUserObject(); |
| String motCle = usObj[0]; |
| String id = usObj[1]; |
| String parentId = ""; |
| |
| if (!id.equals("racine_obs")) { |
| String[] parentUsObj = (String[]) n.getParentNode().getUserObject(); |
| if(!parentUsObj[1].equals("racine_obs")) { |
| parentId = parentUsObj[1]; |
| } |
| } |
| |
| rafraichirArbreMotsCles(arbreMC); |
| |
| String motCleModifie = "&motcle=" + motCle + "&id=" + id + "&parent=" |
| + parentId; |
| MCDao.deplacerBaseDeDonnees(motCleModifie, r); |
| } |
| |
| /** |
| * 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); |
| } |
| |
| public String obtenirTexteMotCle(String id) { |
| |
| String correspondanceId = ""; |
| |
| String motCleTexte = motsCles.get(id); |
| |
| if(motCleTexte != null) { |
| correspondanceId = motCleTexte; |
| } |
| |
| return correspondanceId; |
| } |
| |
| public void rafraichirCacheObservation(ListeObservation li) { |
| cacheObservation = li ; |
| } |
| |
| public ListeObservation getCacheObservation() { |
| return cacheObservation ; |
| } |
| |
| public String getIdPourOrdreObs(String ordreObs) { |
| return (cacheObservation.get(ordreObs) != null) ? cacheObservation.get(ordreObs).getId() : null; |
| } |
| |
| public void obtenirInformationLocalite(Rafraichissable r, String nomLocalite, String code) { |
| InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r); |
| infoLocalite.obtenirInfosLocalite(r, nomLocalite, code); |
| } |
| |
| public void obtenirInformationCoord(Rafraichissable r, double lat, double lng) { |
| InformationLocaliteDAO infoLocalite = new InformationLocaliteDAO(r); |
| infoLocalite.obtenirLocalitePlusProche(r, lng, lat); |
| } |
| } |