eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermStore.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.Arrays;
  14 import java.util.Collections;
  15 import java.util.Comparator;
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Set;
  19
  20 import eu.etaxonomy.cdm.api.service.ITermService;
  21 import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;
  22 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  23 import eu.etaxonomy.cdm.model.common.MarkerType;
  24 import eu.etaxonomy.cdm.model.common.TermType;
  25 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  26 import eu.etaxonomy.cdm.model.description.Feature;
  27 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
  28 import eu.etaxonomy.cdm.model.name.Rank;
  29 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  30 import eu.etaxonomy.taxeditor.model.DefaultTermComparator;
  31 import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;
  32 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  33
  34 /**
  35  * All terms may be accessed through this store.
  36  * Note: This is for internal use. When using vocabularies in the UI, try to use the preferred terms from
  37  * PreferenceUtil
  38  *
  39  * @author n.hoffmann
  40  * @created 25.06.2009
  41  * @version 1.0
  42  */
  43 public class TermStore {
  44
  45         /**
  46          * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given type currently available in the system.
  47          *
  48          * @param clazz a class that inherits from {@link DefinedTermBase}
  49          * @return an alphabetically sorted list of terms
  50          */
  51         public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz){
  52                 return getTerms(clazz, null, true);
  53         }
  54
  55         /**
  56          * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
  57          * currently available in the system.
  58          *
  59          * @param termType the term type
  60          * @return an alphabetically sorted list of terms
  61          */
  62         public static <TERM extends DefinedTermBase> List<TERM> getTerms(TermType termType, Comparator<TERM> comparator){
  63         return getTermsFromService(termType, comparator);
  64         }
  65
  66         /**
  67          * Returns an alphabetically sorted list of terms (anything that extends {@link DefinedTermBase}) of the given {@link TermType})
  68          * currently available in the system.
  69          *
  70          * @param termType the term type
  71          * @return an alphabetically sorted list of terms
  72          */
  73         public static <TERM extends DefinedTermBase> Set<TERM> getTerms(TermVocabulary<TERM> termVocabulary, Comparator<DefinedTermBase<?>> comparator){
  74             return termVocabulary.getTerms();
  75         }
  76
  77         /**
  78          * Returns a list of terms of the given type currently available in the system.
  79          * If <code>filtered</code> is set to <code>true</code>, all terms for certain types will be
  80          * gathered from edge cases.
  81          *
  82          * @param clazz a class that inherits from {@link DefinedTermBase}
  83          * @param comparator a {@link Comparator} that defines the sorting algorithm. If set to null, {@link DefaultTermComparator} will be used
  84          * @param filtered if set to true, some terms are filtered from the result (according to definition in {@link ITermStoreEdgeCase}s)
  85          * @return a sorted list of terms
  86          */
  87         public static <TERM extends DefinedTermBase> List<TERM> getTerms(Class<TERM> clazz, Comparator<TERM> comparator, boolean filtered){
  88                 List<TERM> terms = new ArrayList<TERM>();
  89
  90                 ITermStoreEdgeCase<TERM> edgeCase = getEdgeCase(clazz);
  91                 if(filtered && edgeCase != null){
  92                         terms = edgeCase.getTerms();
  93                 }else{
  94                         terms = getTermsFromService(clazz, comparator);
  95                 }
  96
  97                 return terms;
  98
  99         }
 100
 101         /**
 102          *
 103          * @param termClass
 104          * @param comparator
 105          * @return
 106          */
 107         private static <T extends DefinedTermBase> List<T> getTermsFromService(TermType termType, Comparator<T> comparator){
 108             if (comparator == null){
 109                 comparator = new DefaultTermComparator<T>();
 110             }
 111
 112             List<T> terms = CdmStore.getService(ITermService.class).listByTermType(termType, null, null, null, null);
 113             Collections.sort(terms, comparator);
 114             return terms;
 115         }
 116
 117         /**
 118          *
 119          * @param termClass
 120          * @param comparator
 121          * @return
 122          */
 123         private static <T extends DefinedTermBase> List<T> getTermsFromService(Class<T> termClass, Comparator<T> comparator){
 124                 if (comparator == null){
 125                         comparator = new DefaultTermComparator<T>();
 126                 }
 127
 128                 List<T> terms = CdmStore.getService(ITermService.class).list(termClass, null, null, null, null);
 129                 Collections.sort(terms, comparator);
 130                 return terms;
 131         }
 132
 133         /**
 134          * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 135          */
 136         public static void saveTerm(DefinedTermBase term){
 137                 CdmStore.getService(ITermService.class).saveOrUpdate(term);
 138         }
 139
 140         /**
 141          * <p>delete</p>
 142          *
 143          * @param selected a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 144          * @throws ReferencedObjectUndeletableException
 145          */
 146         public static void delete(DefinedTermBase selected) throws ReferencedObjectUndeletableException {
 147                 CdmStore.getService(ITermService.class).delete(selected);
 148         }
 149
 150         /**
 151          * Save a vacabulary to data store
 152          *
 153          * @param term a {@link eu.etaxonomy.cdm.model.common.DefinedTermBase} object.
 154          */
 155         public static void updateVocabulary(DefinedTermBase term) {
 156                 CdmStore.getService(ITermService.class).saveOrUpdate(term);
 157         }
 158
 159         /**
 160          * Handingling of special cases
 161          */
 162
 163         private static Set<ITermStoreEdgeCase<? extends DefinedTermBase>> termStoreEdgeCases = new HashSet<ITermStoreEdgeCase<? extends DefinedTermBase>>();
 164
 165         static {
 166                 termStoreEdgeCases.add(new ITermStoreEdgeCase<Feature>() {
 167
 168                         @Override
 169                         public Class<Feature> getTermClass() {
 170                                 return Feature.class;
 171                         }
 172
 173                         @Override
 174                         public List<Feature> getTerms() {
 175                                 List<Feature> features = TermStore.getTermsFromService(Feature.class, null);
 176                                 features.remove(Feature.IMAGE());
 177                                 return features;
 178                         }
 179                 });
 180                 termStoreEdgeCases.add(new ITermStoreEdgeCase<MarkerType>(){
 181
 182                         @Override
 183                         public Class<MarkerType> getTermClass() {
 184                                 return MarkerType.class;
 185                         }
 186
 187                         @Override
 188                         public List<MarkerType> getTerms() {
 189                                 // filter out non technical markers
 190                                 List<MarkerType> nonTechnicalMarkerTypes = new ArrayList<MarkerType>();
 191                                 List<MarkerType> markerTypes = TermStore.getTermsFromService(MarkerType.class, null);
 192
 193                                 for (Object type : markerTypes) {
 194                                         if (((MarkerType) type).isTechnical() == false) {
 195                                                 nonTechnicalMarkerTypes.add((MarkerType) type);
 196                                         }
 197                                 }
 198
 199                                 return nonTechnicalMarkerTypes;
 200                         }
 201
 202                 });
 203                 termStoreEdgeCases.add(new ITermStoreEdgeCase<Rank>() {
 204
 205                         @Override
 206                         public Class<Rank> getTermClass() {
 207                                 return Rank.class;
 208                         }
 209
 210                         @Override
 211                         public List<Rank> getTerms() {
 212                                 if(PreferencesUtil.getSortRanksHierarchichally()){
 213                                         return TermStore.getTermsFromService(Rank.class, new Comparator<Rank>(){
 214
 215                                                 @Override
 216                                                 public int compare(Rank o1, Rank o2) {
 217                                                         return o1.compareTo(o2);
 218                                                 }
 219
 220                                         });
 221                                 }else{
 222                                         return TermStore.getTermsFromService(Rank.class, null);
 223                                 }
 224                         }
 225
 226                 });
 227                 termStoreEdgeCases.add(new ITermStoreEdgeCase<PresenceAbsenceTerm>() {
 228
 229                         @Override
 230                         public Class<PresenceAbsenceTerm> getTermClass() {
 231                                 return PresenceAbsenceTerm.class;
 232                         }
 233
 234                         @Override
 235                         public List<PresenceAbsenceTerm> getTerms() {
 236                                 List<PresenceAbsenceTerm> presenceAbsenceTerms = TermStore.getTermsFromService(PresenceAbsenceTerm.class, null);
 237
 238                                 return presenceAbsenceTerms;
 239                         }
 240                 });
 241                 termStoreEdgeCases.add(new ITermStoreEdgeCase<TaxonRelationshipTypeInverseContainer>() {
 242
 243                         @Override
 244                         public Class<TaxonRelationshipTypeInverseContainer> getTermClass() {
 245                                 return TaxonRelationshipTypeInverseContainer.class;
 246                         }
 247
 248                         @Override
 249                         public List<TaxonRelationshipTypeInverseContainer> getTerms() {
 250                                 List<TaxonRelationshipType> excludeTaxonRelationshipTypes = Arrays.asList(new TaxonRelationshipType[]{
 251                                         TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN(),
 252                                         TaxonRelationshipType.MISAPPLIED_NAME_FOR(),
 253                                         TaxonRelationshipType.ALL_RELATIONSHIPS()
 254                                 });
 255
 256                                 List<TaxonRelationshipTypeInverseContainer> relationshipTypeInverseContainers = new ArrayList<TaxonRelationshipTypeInverseContainer>();
 257
 258                                 List<TaxonRelationshipType> relationshipTypes = TermStore.getTerms(TaxonRelationshipType.class);
 259
 260                                 relationshipTypes.removeAll(excludeTaxonRelationshipTypes);
 261
 262                                 for (TaxonRelationshipType relationshipType : relationshipTypes){
 263                                         if(!relationshipType.isSymmetric()){
 264                                                 TaxonRelationshipTypeInverseContainer inverseContainer = new TaxonRelationshipTypeInverseContainer(relationshipType, true);
 265                                                 relationshipTypeInverseContainers.add(inverseContainer);
 266                                         }
 267                                         TaxonRelationshipTypeInverseContainer container = new TaxonRelationshipTypeInverseContainer(relationshipType, false);
 268                                         relationshipTypeInverseContainers.add(container);
 269                                 }
 270
 271                                 return relationshipTypeInverseContainers;
 272                         }
 273                 });
 274         }
 275
 276         private static <T extends DefinedTermBase> ITermStoreEdgeCase<T> getEdgeCase(Class<T> termClass) {
 277
 278                 for (ITermStoreEdgeCase termStoreEdgeCase : termStoreEdgeCases){
 279                         if (termStoreEdgeCase.getTermClass().equals(termClass)){
 280                                 return termStoreEdgeCase;
 281                         }
 282                 }
 283
 284                 return null;
 285         }
 286
 287         private interface ITermStoreEdgeCase<TERM> {
 288
 289                 public abstract Class<TERM> getTermClass();
 290
 291                 public abstract List<TERM> getTerms();
 292
 293         }
 294 }