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

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