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