eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.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.Collection;
  14 import java.util.List;
  15 import java.util.UUID;
  16
  17 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  18 import eu.etaxonomy.cdm.model.common.TermBase;
  19 import eu.etaxonomy.cdm.model.common.TermType;
  20 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  21 import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;
  22 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  23
  24 /**
  25  * @author n.hoffmann
  26  * @created Dec 7, 2010
  27  * @version 1.0
  28  */
  29 public class TermManager {
  30
  31         private static final String TERMS = "terms";
  32         private static final String TERM = "term";
  33         private static final String HIDE = "hide";
  34
  35         private static final String CLASS = "class";
  36         private static final String UUID_STRING = "uuid";
  37
  38         public TermManager(){
  39         }
  40
  41         /**
  42          *
  43          * @param clazz
  44          * @return
  45          */
  46         public <T extends DefinedTermBase> List<T> getPreferredTerms(TermType termType){
  47             return getFilteredTerms(TermStore.<T>getTerms(termType, null));
  48         }
  49
  50         /**
  51          *
  52          * @param clazz
  53          * @return
  54          */
  55         public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary){
  56             return getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary, null)));
  57         }
  58
  59         /**
  60          *
  61          * @param clazz
  62          * @return
  63          */
  64         public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){
  65                 return getFilteredTerms(TermStore.getTerms(clazz));
  66         }
  67
  68         /**
  69          * Generic method to get term preferences for a term vocabulary
  70          *
  71          * @param initialTerms a {@link java.util.List} object.
  72          * @return a {@link java.util.List} object.
  73          */
  74         public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
  75
  76                 List<T> filteredTerms = new ArrayList<T>();
  77
  78                 for (T term : initialTerms){
  79
  80                         if (term instanceof TaxonRelationshipTypeInverseContainer){
  81                                 if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
  82                                         T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType();
  83                                         filteredTerms.add(type);
  84
  85                                 }
  86                         }
  87
  88                         if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
  89                                 filteredTerms.add(term);
  90                         }
  91                 }
  92
  93                 return filteredTerms;
  94         }
  95
  96     private <T extends TermBase> String getPrefName(T term) {
  97         return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
  98     }
  99
 100
 101         private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){
 102
 103                 String result = null;
 104                 if(!initialTerms.isEmpty()){
 105
 106                         //TODO: there should be a more generic solution!!
 107                 T entity = initialTerms.iterator().next();
 108                 if (entity instanceof TaxonRelationshipTypeInverseContainer){
 109                         result = ((TaxonRelationshipTypeInverseContainer) entity).getType().getClass().getName();
 110                 } else {
 111                         result = entity.getClass().getName();
 112                 }
 113                 return result;
 114             }
 115             return null;
 116         }
 117
 118         /**
 119          * Generic method to set term preferences
 120          *
 121          * @param preferredTerms a {@link java.util.List} object.
 122          * @param initialTerms a {@link java.util.List} object.
 123          * @param <T> a T object.
 124          */
 125         public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
 126         String typeName = getTermClass(initialTerms);
 127
 128                 Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
 129
 130                 for(TermBase term : initialTerms){
 131                         if(! preferredTerms.contains(term)){
 132                                 undesiredTermUuids.add(term.getUuid());
 133                                 PreferencesUtil.getPreferenceStore().setValue(getPrefName(term), true);
 134                         }else{
 135                             PreferencesUtil.getPreferenceStore().setValue(getPrefName(term), false);
 136                         }
 137
 138
 139                 }
 140         }
 141 }