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