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