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.taxeditor.model.ContextListenerAdapter;
  27
  28 /**
  29  * @author n.hoffmann
  30  * @created Dec 7, 2010
  31  * @version 1.0
  32  */
  33 public class TermManager extends ContextListenerAdapter{
  34
  35         private static final String TERMS = "terms";
  36         private static final String TERM = "term";
  37         private static final String HIDE = "hide";
  38
  39         private static final String CLASS = "class";
  40         private static final String UUID_STRING = "uuid";
  41
  42         private final Map<String, Collection<UUID>> hiddenTermsMap = new HashMap<String, Collection<UUID>>();
  43
  44         public TermManager(){
  45                 CdmStore.getContextManager().addContextListener(this);
  46         }
  47
  48         /**
  49          *
  50          * @param clazz
  51          * @return
  52          */
  53         public List<DefinedTermBase<?>> getPreferredTerms(TermType termType){
  54             return getFilteredTerms(TermStore.getTerms(termType, null));
  55         }
  56
  57         /**
  58          *
  59          * @param clazz
  60          * @return
  61          */
  62         public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){
  63                 return getFilteredTerms(TermStore.getTerms(clazz));
  64         }
  65
  66         /* (non-Javadoc)
  67          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextStart(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  68          */
  69         @Override
  70         public void contextStart(IMemento memento, IProgressMonitor monitor) {
  71                 // read preferred terms from memento into an in memory representation
  72                 if(memento == null){
  73                         return;
  74                 }
  75
  76                 IMemento terms = memento.getChild(TERMS);
  77
  78                 if(terms == null){
  79                         return;
  80                 }
  81
  82                 for(IMemento term : terms.getChildren(TERM)){
  83                         String typeName = term.getString(CLASS);
  84                         Collection<UUID> hiddenTermUuids = new ArrayList<UUID>();
  85                         for(IMemento hide : term.getChildren(HIDE)){
  86                                 String uuidString = hide.getString(UUID_STRING);
  87                                 UUID uuid = UUID.fromString(uuidString);
  88                                 hiddenTermUuids.add(uuid);
  89                         }
  90                         hiddenTermsMap.put(typeName, hiddenTermUuids);
  91                 }
  92         }
  93
  94         /* (non-Javadoc)
  95          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#contextAboutToStop(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
  96          */
  97         @Override
  98         public void contextStop(IMemento memento, IProgressMonitor monitor) {
  99                 saveTerms(memento, monitor);
 100         }
 101
 102         /* (non-Javadoc)
 103          * @see eu.etaxonomy.taxeditor.model.ContextListenerAdapter#workbenchShutdown(org.eclipse.ui.IMemento, org.eclipse.core.runtime.IProgressMonitor)
 104          */
 105         @Override
 106         public void workbenchShutdown(IMemento memento, IProgressMonitor monitor) {
 107                 saveTerms(memento, monitor);
 108         }
 109
 110         private void saveTerms(IMemento memento, IProgressMonitor monitor){
 111                 if(memento == null) {
 112             return;
 113         }
 114
 115                 IMemento terms = memento.createChild(TERMS);
 116                 for (String preferredTerm : hiddenTermsMap.keySet()){
 117                         IMemento term = terms.createChild(TERM);
 118                         term.putString(CLASS, preferredTerm);
 119                         for(UUID uuid : hiddenTermsMap.get(preferredTerm)){
 120                                 IMemento hide = term.createChild(HIDE);
 121                                 hide.putString(UUID_STRING, uuid.toString());
 122                         }
 123                 }
 124         }
 125
 126         /**
 127          * Generic method to get term preferences for a term vocabulary
 128          *
 129          * @param initialTerms a {@link java.util.List} object.
 130          * @return a {@link java.util.List} object.
 131          */
 132         public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
 133
 134                 List<T> filteredTerms = new ArrayList<T>();
 135
 136                 String typeName = getTermClass(initialTerms);
 137                 Collection<UUID> hiddenTermUuids = hiddenTermsMap.get(typeName);
 138
 139                 if(hiddenTermUuids == null){
 140                         return initialTerms;
 141                 }
 142
 143                 for (T term : initialTerms){
 144                         if(! hiddenTermUuids.contains(term.getUuid())){
 145                                 filteredTerms.add(term);
 146                         }
 147                 }
 148
 149                 return filteredTerms;
 150         }
 151
 152         private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){
 153             if(!initialTerms.isEmpty()){
 154                 return initialTerms.iterator().next().getClass().getName();
 155             }
 156             return null;
 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> getPreferredRelationshipTypesWithInverses(){
 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
 213
 214 //
 215 //      /**
 216 //       * <p>getPreferredFeatures</p>
 217 //       *
 218 //       * @return a {@link java.util.List} object.
 219 //       */
 220 //      public List<Feature> getPreferredFeatures() { return getFilteredTerms(TermStore.getFeatures());}
 221 //
 222 //      /**
 223 //       * <p>getPreferredRanks</p>
 224 //       *
 225 //       * @return a {@link java.util.List} object.
 226 //       */
 227 //      public List<Rank> getPreferredRanks() { return getFilteredTerms(TermStore.getRanks());}
 228 //
 229 //      /**
 230 //       * <p>getPreferredPresenceAbsenceTerms</p>
 231 //       *
 232 //       * @return a {@link java.util.List} object.
 233 //       */
 234 //      public List<PresenceAbsenceTermBase> getPreferredPresenceAbsenceTerms(){ return getFilteredTerms(TermStore.getPresenceAbsenceTerms());}
 235 //
 236 //      /**
 237 //       * <p>getPreferredNomenclaturalStatusTypes</p>
 238 //       *
 239 //       * @return a {@link java.util.List} object.
 240 //       */
 241 //      public List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){    return getFilteredTerms(TermStore.getNomenclaturalStatusTypes());}
 242 //
 243 //      /**
 244 //       * <p>getPreferredNameRelationshipTypes</p>
 245 //       *
 246 //       * @return a {@link java.util.List} object.
 247 //       */
 248 //      public List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getFilteredTerms(TermStore.getNameRelationshipTypes());}
 249 //
 250 //      /**
 251 //       * <p>getPreferredLanguages</p>
 252 //       *
 253 //       * @return a {@link java.util.List} object.
 254 //       */
 255 //      public List<Language> getPreferredLanguages() { return getFilteredTerms(TermStore.getLanguages()); }
 256 //
 257 //      /**
 258 //       * <p>getPreferredMarkerTypes</p>
 259 //       *
 260 //       * @return a {@link java.util.List} object.
 261 //       */
 262 //      public List<MarkerType> getPreferredMarkerTypes() { return getFilteredTerms(TermStore.getNonTechnicalMarkerTypes()); }
 263 //
 264 //      /**
 265 //       * <p>getPreferredExtensionTypes</p>
 266 //       *
 267 //       * @return a {@link java.util.List} object.
 268 //       */
 269 //      public List<ExtensionType> getPreferredExtensionTypes() { return getFilteredTerms(TermStore.getExtensionTypes()); }
 270 //
 271 //      /**
 272 //       * <p>getPreferredRightsTypes</p>
 273 //       *
 274 //       * @return a {@link java.util.List} object.
 275 //       */
 276 //      public List<RightsType> getPreferredRightsTypes() {     return getFilteredTerms(TermStore.getRightsTypes());}
 277 //
 278 //      /**
 279 //       * <p>getPreferredNamedAreaTypes</p>
 280 //       *
 281 //       * @return a {@link java.util.List} object.
 282 //       */
 283 //      public List<NamedAreaType> getPreferredNamedAreaTypes() { return getFilteredTerms(TermStore.getNamedAreaTypes()); }
 284 //
 285 //      /**
 286 //       * <p>getPreferredNamedAreaTypes</p>
 287 //       *
 288 //       * @return a {@link java.util.List} object.
 289 //       */
 290 //      public List<NamedAreaLevel> getPreferredNamedAreaLevels() { return getFilteredTerms(TermStore.getNamedAreaLevels()); }
 291 //
 292 //      /**
 293 //       * <p>getPreferredAnnotationTypes</p>
 294 //       *
 295 //       * @return a {@link java.util.List} object.
 296 //       */
 297 //      public List<AnnotationType> getPreferredAnnotationTypes() { return getFilteredTerms(TermStore.getAnnotationTypes()); }
 298 //
 299 //      /**
 300 //       * <p>getPreferredStages</p>
 301 //       *
 302 //       * @return a {@link java.util.List} object.
 303 //       */
 304 //      public List<Stage> getPreferredStages() { return getFilteredTerms(TermStore.getStages()); }
 305 //
 306 //      /**
 307 //       * <p>getPreferredPreservationMethods</p>
 308 //       *
 309 //       * @return a {@link java.util.List} object.
 310 //       */
 311 //      public List<PreservationMethod> getPreferredPreservationMethods() { return getFilteredTerms(TermStore.getPreservationMethods()); }
 312 //
 313 //      /**
 314 //       * <p>getPreferredMeasurementUnits</p>
 315 //       *
 316 //       * @return a {@link java.util.List} object.
 317 //       */
 318 //      public List<MeasurementUnit> getPreferredMeasurementUnits() { return getFilteredTerms(TermStore.getMeasurementUnits()); }
 319 //
 320 //      /**
 321 //       * <p>getPreferredStates</p>
 322 //       *
 323 //       * @return a {@link java.util.List} object.
 324 //       */
 325 //      public List<State> getPreferredStates() { return getFilteredTerms(TermStore.getStates()); }
 326 //
 327 //      /**
 328 //       * <p>getPreferredModifiers</p>
 329 //       *
 330 //       * @return a {@link java.util.List} object.
 331 //       */
 332 //      public List<Modifier> getPreferredModifiers() { return getFilteredTerms(TermStore.getModifiers()); }
 333 //
 334 //      /**
 335 //       * <p>getPreferredStatisticalMeasures</p>
 336 //       *
 337 //       * @return a {@link java.util.List} object.
 338 //       */
 339 //      public List<StatisticalMeasure> getPreferredStatisticalMeasures() { return getFilteredTerms(TermStore.getStatisticalMeasures()); }
 340 //
 341 //      /**
 342 //       * <p>getPreferredScopes</p>
 343 //       *
 344 //       * @return a {@link java.util.List} object.
 345 //       */
 346 //      public List<Scope> getPreferredScopes() { return getFilteredTerms(TermStore.getScopes()); }
 347 //
 348 //      /**
 349 //       * <p>getPreferredDeterminationModifiers</p>
 350 //       *
 351 //       * @return a {@link java.util.List} object.
 352 //       */
 353 //      public List<DeterminationModifier> getPreferredDeterminationModifiers() { return getFilteredTerms(TermStore.getDeterminationModifiers()); }
 354 //
 355         /**
 356          * Generic method to set term preferences
 357          *
 358          * @param preferredTerms a {@link java.util.List} object.
 359          * @param initialTerms a {@link java.util.List} object.
 360          * @param <T> a T object.
 361          */
 362         public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
 363                 String typeName = getTermClass(initialTerms);
 364
 365                 Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
 366
 367                 for(TermBase term : initialTerms){
 368                         if(! preferredTerms.contains(term)){
 369                                 undesiredTermUuids.add(term.getUuid());
 370                         }
 371                 }
 372
 373                 hiddenTermsMap.put(typeName, undesiredTermUuids);
 374         }
 375 }