eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.taxeditor.store;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.HashMap;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.UUID;
  19
  20 import org.eclipse.core.runtime.IProgressMonitor;
  21 import org.eclipse.ui.IMemento;
  22
  23 import eu.etaxonomy.cdm.model.common.AnnotationType;
  24 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  25 import eu.etaxonomy.cdm.model.common.ExtensionType;
  26 import eu.etaxonomy.cdm.model.common.Language;
  27 import eu.etaxonomy.cdm.model.common.MarkerType;
  28 import eu.etaxonomy.cdm.model.common.TermBase;
  29 import eu.etaxonomy.cdm.model.description.Feature;
  30 import eu.etaxonomy.cdm.model.description.MeasurementUnit;
  31 import eu.etaxonomy.cdm.model.description.Modifier;
  32 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  33 import eu.etaxonomy.cdm.model.description.Scope;
  34 import eu.etaxonomy.cdm.model.description.Stage;
  35 import eu.etaxonomy.cdm.model.description.State;
  36 import eu.etaxonomy.cdm.model.description.StatisticalMeasure;
  37 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  38 import eu.etaxonomy.cdm.model.media.RightsTerm;
  39 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  40 import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
  41 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  42 import eu.etaxonomy.cdm.model.name.Rank;
  43 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  44 import eu.etaxonomy.cdm.model.occurrence.DeterminationModifier;
  45 import eu.etaxonomy.cdm.model.occurrence.PreservationMethod;
  46 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  47 import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;
  48
  49 /**
  50  * @author n.hoffmann
  51  * @created Dec 7, 2010
  52  * @version 1.0
  53  */
  54 public class TermManager extends ContextListenerAdapter{
  55
  56         private static final String TERMS = "terms";
  57         private static final String TERM = "term";
  58         private static final String HIDE = "hide";
  59
  60         private static final String CLASS = "class";
  61         private static final String UUID_STRING = "uuid";
  62
  63         private Map<String, Collection<UUID>> hiddenTermsMap = new HashMap<String, Collection<UUID>>();
  64
  65         public TermManager(){
  66                 CdmStore.getContextManager().addContextListener(this);
  67         }
  68
  69         /* (non-Javadoc)
  70          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextStart(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  71          */
  72         @Override
  73         public void contextStart(IMemento memento, IProgressMonitor monitor) {
  74                 // read preferred terms from memento into an in memory representation
  75                 if(memento == null){
  76                         return;
  77                 }
  78
  79                 IMemento terms = memento.getChild(TERMS);
  80
  81                 if(terms == null){
  82                         return;
  83                 }
  84
  85                 for(IMemento term : terms.getChildren(TERM)){
  86                         String typeName = term.getString(CLASS);
  87                         Collection<UUID> hiddenTermUuids = new ArrayList<UUID>();
  88                         for(IMemento hide : term.getChildren(HIDE)){
  89                                 String uuidString = hide.getString(UUID_STRING);
  90                                 UUID uuid = UUID.fromString(uuidString);
  91                                 hiddenTermUuids.add(uuid);
  92                         }
  93                         hiddenTermsMap.put(typeName, hiddenTermUuids);
  94                 }
  95         }
  96
  97         /* (non-Javadoc)
  98          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextAboutToStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  99          */
 100         @Override
 101         public void contextStop(IMemento memento, IProgressMonitor monitor) {
 102                 saveTerms(memento, monitor);
 103         }
 104
 105         /* (non-Javadoc)
 106          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#workbenchShutdown(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 107          */
 108         @Override
 109         public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 110                 saveTerms(memento, monitor);
 111         }
 112
 113         private void saveTerms(IMemento memento, IProgressMonitor monitor){
 114                 if(memento == null) return;
 115
 116                 IMemento terms = memento.createChild(TERMS);
 117                 for (String preferredTerm : hiddenTermsMap.keySet()){
 118                         IMemento term = terms.createChild(TERM);
 119                         term.putString(CLASS, preferredTerm);
 120                         for(UUID uuid : hiddenTermsMap.get(preferredTerm)){
 121                                 IMemento hide = term.createChild(HIDE);
 122                                 hide.putString(UUID_STRING, uuid.toString());
 123                         }
 124                 }
 125         }
 126
 127         /**
 128          * Generic method to get term preferences for a term vocabulary
 129          *
 130          * @param initialTerms a {@link java.util.List} object.
 131          * @return a {@link java.util.List} object.
 132          */
 133         public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
 134
 135                 List<T> filteredTerms = new ArrayList<T>();
 136
 137                 String typeName = getTermClass(initialTerms);
 138                 Collection<UUID> hiddenTermUuids = hiddenTermsMap.get(typeName);
 139
 140                 if(hiddenTermUuids == null){
 141                         return initialTerms;
 142                 }
 143
 144                 for (T term : initialTerms){
 145                         if(! hiddenTermUuids.contains(term.getUuid())){
 146                                 filteredTerms.add(term);
 147                         }
 148                 }
 149
 150                 return filteredTerms;
 151         }
 152
 153         private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){
 154                 return initialTerms.iterator().next().getClass().getName();
 155         }
 156
 157         /**
 158          * <p>getPreferredSpecimenTypeDesignationStatus</p>
 159          *
 160          * @return a {@link java.util.List} object.
 161          */
 162         public List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getFilteredTerms(TermStore.getSpecimenTypeDesignationStatus());}
 163
 164         /**
 165          * <p>getPreferredNameTypeDesignationStatus</p>
 166          *
 167          * @return a {@link java.util.List} object.
 168          */
 169         public List<NameTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getFilteredTerms(TermStore.getNameTypeDesignationStatus()); }
 170
 171         /**
 172          * <p>getPreferredTaxonRelationshipTypes</p>
 173          *
 174          * @return a {@link java.util.List} object.
 175          */
 176         public List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getFilteredTerms(TermStore.getTaxonRelationshipTypes());}
 177
 178         /**
 179          * <p>getPreferredFeatures</p>
 180          *
 181          * @return a {@link java.util.List} object.
 182          */
 183         public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());}
 184
 185         /**
 186          * <p>getPreferredRanks</p>
 187          *
 188          * @return a {@link java.util.List} object.
 189          */
 190         public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());}
 191
 192         /**
 193          * <p>getPreferredPresenceAbsenceTerms</p>
 194          *
 195          * @return a {@link java.util.List} object.
 196          */
 197         public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());}
 198
 199         /**
 200          * <p>getPreferredNomenclaturalStatusTypes</p>
 201          *
 202          * @return a {@link java.util.List} object.
 203          */
 204         public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){    return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());}
 205
 206         /**
 207          * <p>getPreferredNameRelationshipTypes</p>
 208          *
 209          * @return a {@link java.util.List} object.
 210          */
 211         public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());}
 212
 213         /**
 214          * <p>getPreferredLanguages</p>
 215          *
 216          * @return a {@link java.util.List} object.
 217          */
 218         public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); }
 219
 220         /**
 221          * <p>getPreferredMarkerTypes</p>
 222          *
 223          * @return a {@link java.util.List} object.
 224          */
 225         public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); }
 226
 227         /**
 228          * <p>getPreferredExtensionTypes</p>
 229          *
 230          * @return a {@link java.util.List} object.
 231          */
 232         public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); }
 233
 234         /**
 235          * <p>getPreferredRightsTypes</p>
 236          *
 237          * @return a {@link java.util.List} object.
 238          */
 239         public List<RightsTerm> getPreferredRightsTypes() {     return getFilteredTerms(TermStore.getRightsTypes());}
 240
 241         /**
 242          * <p>getPreferredNamedAreaTypes</p>
 243          *
 244          * @return a {@link java.util.List} object.
 245          */
 246         public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); }
 247
 248         /**
 249          * <p>getPreferredAnnotationTypes</p>
 250          *
 251          * @return a {@link java.util.List} object.
 252          */
 253         public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); }
 254
 255         /**
 256          * <p>getPreferredStages</p>
 257          *
 258          * @return a {@link java.util.List} object.
 259          */
 260         public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); }
 261
 262         /**
 263          * <p>getPreferredPreservationMethods</p>
 264          *
 265          * @return a {@link java.util.List} object.
 266          */
 267         public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); }
 268
 269         /**
 270          * <p>getPreferredMeasurementUnits</p>
 271          *
 272          * @return a {@link java.util.List} object.
 273          */
 274         public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); }
 275
 276         /**
 277          * <p>getPreferredStates</p>
 278          *
 279          * @return a {@link java.util.List} object.
 280          */
 281         public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); }
 282
 283         /**
 284          * <p>getPreferredModifiers</p>
 285          *
 286          * @return a {@link java.util.List} object.
 287          */
 288         public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); }
 289
 290         /**
 291          * <p>getPreferredStatisticalMeasures</p>
 292          *
 293          * @return a {@link java.util.List} object.
 294          */
 295         public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); }
 296
 297         /**
 298          * <p>getPreferredScopes</p>
 299          *
 300          * @return a {@link java.util.List} object.
 301          */
 302         public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); }
 303
 304         /**
 305          * <p>getPreferredDeterminationModifiers</p>
 306          *
 307          * @return a {@link java.util.List} object.
 308          */
 309         public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); }
 310
 311         /**
 312          * Generic method to set term preferences
 313          *
 314          * @param preferredTerms a {@link java.util.List} object.
 315          * @param initialTerms a {@link java.util.List} object.
 316          * @param <T> a T object.
 317          */
 318         public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
 319                 String typeName = getTermClass(initialTerms);
 320
 321                 Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
 322
 323                 for(TermBase term : initialTerms){
 324                         if(! preferredTerms.contains(term)){
 325                                 undesiredTermUuids.add(term.getUuid());
 326                         }
 327                 }
 328
 329                 hiddenTermsMap.put(typeName, undesiredTermUuids);
 330         }
 331
 332         /**
 333          * <p>addTermToPreferredTerms</p>
 334          *
 335          * @param term a T object.
 336          * @param <T> a T object.
 337          */
 338         public <T extends TermBase> void addTermToPreferredTerms(T term){
 339
 340 //              VocabularyEnum vocabulary = VocabularyEnum.getVocabularyEnum(term.getClass());
 341 //
 342 //              getPreferenceStore().setValue(getPreferenceKey(term), VocabularyStore.getTermVocabulary(vocabulary).getTerms().contains(term));
 343 //
 344 //              firePreferencesChanged(term.getClass());
 345         }
 346 }