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                 IMemento terms = memento.getChild(TERMS);
  76
  77                 if(terms == null){
  78                         return;
  79                 }
  80
  81                 for(IMemento term : terms.getChildren(TERM)){
  82                         String typeName = term.getString(CLASS);
  83                         Collection<UUID> hiddenTermUuids = new ArrayList<UUID>();
  84                         for(IMemento hide : term.getChildren(HIDE)){
  85                                 String uuidString = hide.getString(UUID_STRING);
  86                                 UUID uuid = UUID.fromString(uuidString);
  87                                 hiddenTermUuids.add(uuid);
  88                         }
  89                         hiddenTermsMap.put(typeName, hiddenTermUuids);
  90                 }
  91         }
  92
  93         /* (non-Javadoc)
  94          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextAboutToStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  95          */
  96         @Override
  97         public void contextStop(IMemento memento, IProgressMonitor monitor) {
  98                 saveTerms(memento, monitor);
  99         }
 100
 101         /* (non-Javadoc)
 102          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#workbenchShutdown(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 103          */
 104         @Override
 105         public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 106                 saveTerms(memento, monitor);
 107         }
 108
 109         private void saveTerms(IMemento memento, IProgressMonitor monitor){
 110                 if(memento == null) return;
 111
 112                 IMemento terms = memento.createChild(TERMS);
 113                 for (String preferredTerm : hiddenTermsMap.keySet()){
 114                         IMemento term = terms.createChild(TERM);
 115                         term.putString(CLASS, preferredTerm);
 116                         for(UUID uuid : hiddenTermsMap.get(preferredTerm)){
 117                                 IMemento hide = term.createChild(HIDE);
 118                                 hide.putString(UUID_STRING, uuid.toString());
 119                         }
 120                 }
 121         }
 122
 123         /**
 124          * Generic method to get term preferences for a term vocabulary
 125          *
 126          * @param initialTerms a {@link java.util.List} object.
 127          * @return a {@link java.util.List} object.
 128          */
 129         public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
 130
 131                 List<T> filteredTerms = new ArrayList<T>();
 132
 133                 String typeName = getTermClass(initialTerms);
 134                 Collection<UUID> hiddenTermUuids = hiddenTermsMap.get(typeName);
 135
 136                 if(hiddenTermUuids == null){
 137                         return initialTerms;
 138                 }
 139
 140                 for (T term : initialTerms){
 141                         if(! hiddenTermUuids.contains(term.getUuid())){
 142                                 filteredTerms.add(term);
 143                         }
 144                 }
 145
 146                 return filteredTerms;
 147         }
 148
 149         private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){
 150                 return initialTerms.iterator().next().getClass().getName();
 151         }
 152
 153         /**
 154          * <p>getPreferredSpecimenTypeDesignationStatus</p>
 155          *
 156          * @return a {@link java.util.List} object.
 157          */
 158         public List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getFilteredTerms(TermStore.getSpecimenTypeDesignationStatus());}
 159
 160         /**
 161          * <p>getPreferredNameTypeDesignationStatus</p>
 162          *
 163          * @return a {@link java.util.List} object.
 164          */
 165         public List<NameTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getFilteredTerms(TermStore.getNameTypeDesignationStatus()); }
 166
 167         /**
 168          * <p>getPreferredTaxonRelationshipTypes</p>
 169          *
 170          * @return a {@link java.util.List} object.
 171          */
 172         public List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getFilteredTerms(TermStore.getTaxonRelationshipTypes());}
 173
 174         /**
 175          * <p>getPreferredFeatures</p>
 176          *
 177          * @return a {@link java.util.List} object.
 178          */
 179         public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());}
 180
 181         /**
 182          * <p>getPreferredRanks</p>
 183          *
 184          * @return a {@link java.util.List} object.
 185          */
 186         public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());}
 187
 188         /**
 189          * <p>getPreferredPresenceAbsenceTerms</p>
 190          *
 191          * @return a {@link java.util.List} object.
 192          */
 193         public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());}
 194
 195         /**
 196          * <p>getPreferredNomenclaturalStatusTypes</p>
 197          *
 198          * @return a {@link java.util.List} object.
 199          */
 200         public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){    return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());}
 201
 202         /**
 203          * <p>getPreferredNameRelationshipTypes</p>
 204          *
 205          * @return a {@link java.util.List} object.
 206          */
 207         public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());}
 208
 209         /**
 210          * <p>getPreferredLanguages</p>
 211          *
 212          * @return a {@link java.util.List} object.
 213          */
 214         public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); }
 215
 216         /**
 217          * <p>getPreferredMarkerTypes</p>
 218          *
 219          * @return a {@link java.util.List} object.
 220          */
 221         public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); }
 222
 223         /**
 224          * <p>getPreferredExtensionTypes</p>
 225          *
 226          * @return a {@link java.util.List} object.
 227          */
 228         public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); }
 229
 230         /**
 231          * <p>getPreferredRightsTypes</p>
 232          *
 233          * @return a {@link java.util.List} object.
 234          */
 235         public List<RightsTerm> getPreferredRightsTypes() {     return getFilteredTerms(TermStore.getRightsTypes());}
 236
 237         /**
 238          * <p>getPreferredNamedAreaTypes</p>
 239          *
 240          * @return a {@link java.util.List} object.
 241          */
 242         public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); }
 243
 244         /**
 245          * <p>getPreferredAnnotationTypes</p>
 246          *
 247          * @return a {@link java.util.List} object.
 248          */
 249         public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); }
 250
 251         /**
 252          * <p>getPreferredStages</p>
 253          *
 254          * @return a {@link java.util.List} object.
 255          */
 256         public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); }
 257
 258         /**
 259          * <p>getPreferredPreservationMethods</p>
 260          *
 261          * @return a {@link java.util.List} object.
 262          */
 263         public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); }
 264
 265         /**
 266          * <p>getPreferredMeasurementUnits</p>
 267          *
 268          * @return a {@link java.util.List} object.
 269          */
 270         public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); }
 271
 272         /**
 273          * <p>getPreferredStates</p>
 274          *
 275          * @return a {@link java.util.List} object.
 276          */
 277         public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); }
 278
 279         /**
 280          * <p>getPreferredModifiers</p>
 281          *
 282          * @return a {@link java.util.List} object.
 283          */
 284         public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); }
 285
 286         /**
 287          * <p>getPreferredStatisticalMeasures</p>
 288          *
 289          * @return a {@link java.util.List} object.
 290          */
 291         public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); }
 292
 293         /**
 294          * <p>getPreferredScopes</p>
 295          *
 296          * @return a {@link java.util.List} object.
 297          */
 298         public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); }
 299
 300         /**
 301          * <p>getPreferredDeterminationModifiers</p>
 302          *
 303          * @return a {@link java.util.List} object.
 304          */
 305         public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); }
 306
 307         /**
 308          * Generic method to set term preferences
 309          *
 310          * @param preferredTerms a {@link java.util.List} object.
 311          * @param initialTerms a {@link java.util.List} object.
 312          * @param <T> a T object.
 313          */
 314         public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
 315                 String typeName = getTermClass(initialTerms);
 316
 317                 Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
 318
 319                 for(TermBase term : initialTerms){
 320                         if(! preferredTerms.contains(term)){
 321                                 undesiredTermUuids.add(term.getUuid());
 322                         }
 323                 }
 324
 325                 hiddenTermsMap.put(typeName, undesiredTermUuids);
 326         }
 327
 328         /**
 329          * <p>addTermToPreferredTerms</p>
 330          *
 331          * @param term a T object.
 332          * @param <T> a T object.
 333          */
 334         public <T extends TermBase> void addTermToPreferredTerms(T term){
 335
 336 //              VocabularyEnum vocabulary = VocabularyEnum.getVocabularyEnum(term.getClass());
 337 //
 338 //              getPreferenceStore().setValue(getPreferenceKey(term), VocabularyStore.getTermVocabulary(vocabulary).getTerms().contains(term));
 339 //
 340 //              firePreferencesChanged(term.getClass());
 341         }
 342 }