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