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