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.Comparator;
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.UUID;
  20
  21 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  22 import eu.etaxonomy.cdm.model.term.TermBase;
  23 import eu.etaxonomy.cdm.model.term.TermType;
  24 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  25 import eu.etaxonomy.cdm.persistence.dto.TermDto;
  26 import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
  27 import eu.etaxonomy.taxeditor.model.DefaultTermComparator;
  28 import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;
  29 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  30
  31 /**
  32  * @author n.hoffmann
  33  * @created Dec 7, 2010
  34  * @version 1.0
  35  */
  36 public class TermManager {
  37
  38         private static final String TERMS = "terms";
  39         private static final String TERM = "term";
  40         private static final String HIDE = "hide";
  41
  42         private static final String CLASS = "class";
  43         private static final String UUID_STRING = "uuid";
  44
  45
  46     private Map<Object, List> cachedTermMap = new HashMap<>();
  47
  48
  49     //new cache for features!!
  50     //dinstinguish preferences for both
  51     //load at start
  52
  53         public TermManager(){
  54         }
  55
  56         /**
  57          *
  58          * @param clazz
  59          * @return
  60          */
  61         public <T extends DefinedTermBase> List<T> getPreferredTerms(TermType termType){
  62             List terms = cachedTermMap.get(termType);
  63             if(terms==null || terms.isEmpty()){
  64                 terms = getFilteredTerms(TermStore.<T>getTerms(termType, null));
  65                 cachedTermMap.put(termType, terms);
  66             }
  67         return terms;
  68         }
  69
  70         /**
  71          *
  72          * @param clazz
  73          * @return
  74          */
  75         public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary){
  76             List terms = cachedTermMap.get(termVocabulary.getUuid());
  77             if(terms==null){
  78                 terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,null)));
  79                 cachedTermMap.put(termVocabulary.getUuid(), terms);
  80             }
  81             return terms;
  82         }
  83
  84         /**
  85     *
  86     * @param clazz
  87     * @return
  88     */
  89    public List<TermDto> getPreferredTerms(TermVocabularyDto termVocabularyDto){
  90        List terms = cachedTermMap.get(termVocabularyDto.getUuid());
  91        if(terms==null){
  92            terms = getFilteredTermDtos(new ArrayList<>(termVocabularyDto.getTerms()));
  93            cachedTermMap.put(termVocabularyDto.getUuid(), terms);
  94        }
  95        return terms;
  96    }
  97
  98         /**
  99     *
 100     * @param clazz
 101     * @return
 102     */
 103    public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary, Comparator comp){
 104        if (comp == null){
 105            comp = new DefaultTermComparator<T>();
 106        }
 107        List terms = cachedTermMap.get(termVocabulary.getUuid());
 108        List<T> termBaseList = new ArrayList();
 109        if(terms==null){
 110            terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,comp)));
 111            cachedTermMap.put(termVocabulary.getUuid(), terms);
 112        }else{
 113            Iterator iterator = terms.iterator();
 114            DefinedTermBase termBase = null;
 115            List<UUID> uuids = new ArrayList();
 116            while (iterator.hasNext()){
 117                Object term = iterator.next();
 118                if (term instanceof TermDto){
 119                    TermDto dto = (TermDto)term;
 120                    uuids.add(dto.getUuid());
 121                }else {
 122                    termBaseList.add((T)term);
 123                }
 124
 125            }
 126            if (!uuids.isEmpty()){
 127                termBaseList.addAll(this.getTerms(uuids, DefinedTermBase.class));
 128            }
 129
 130        }
 131        termBaseList.sort(comp);
 132        terms = termBaseList;
 133        return terms;
 134    }
 135         /**
 136          *
 137          * @param clazz
 138          * @return
 139          */
 140         public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){
 141             List terms = cachedTermMap.get(clazz);
 142             if(terms==null){
 143                 terms = getFilteredTerms(TermStore.getTerms(clazz));
 144                 cachedTermMap.put(clazz, terms);
 145
 146             }
 147             return terms;
 148         }
 149
 150         /**
 151          * Generic method to get term preferences for a term vocabulary
 152          *
 153          * @param initialTerms a {@link java.util.List} object.
 154          * @return a {@link java.util.List} object.
 155          */
 156         public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
 157
 158                 List<T> filteredTerms = new ArrayList<T>();
 159
 160                 for (T term : initialTerms){
 161
 162                         if (term instanceof TaxonRelationshipTypeInverseContainer){
 163                                 if(!PreferencesUtil.getBooleanValue(getPrefName(term))){
 164                                         T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType();
 165                                         filteredTerms.add(type);
 166
 167                                 }
 168                         }
 169
 170                         if(PreferencesUtil.getBooleanValue(getPrefName(term))){
 171                                 filteredTerms.add(term);
 172                         }
 173                 }
 174                 if (filteredTerms.isEmpty()){
 175                     return initialTerms;
 176                 }
 177
 178                 return filteredTerms;
 179         }
 180
 181         /**
 182      * Generic method to get term preferences for a term vocabulary
 183      *
 184      * @param initialTerms a {@link java.util.List} object.
 185      * @return a {@link java.util.List} object.
 186      */
 187     public List<TermDto> getFilteredTermDtos(List<TermDto> initialTerms){
 188
 189         List<TermDto> filteredTerms = new ArrayList();
 190
 191         for (TermDto term : initialTerms){
 192
 193            //TODO:inverse terms!!
 194
 195             if(PreferencesUtil.getBooleanValue(getPrefNameByDto(term))){
 196                 filteredTerms.add(term);
 197             }
 198         }
 199         if (filteredTerms.isEmpty()){
 200             return initialTerms;
 201         }
 202
 203         return filteredTerms;
 204     }
 205
 206     private <T extends TermBase> String getPrefName(T term) {
 207         return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
 208     }
 209     private String getPrefNameByDto(TermDto term) {
 210         return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
 211     }
 212
 213         private <T extends DefinedTermBase> TermVocabulary<T> getTermVocabulary(Collection<T> initialTerms){
 214
 215                 TermType result = null;
 216                 if(!initialTerms.isEmpty()){
 217                 T entity = initialTerms.iterator().next();
 218                 return entity.getVocabulary();
 219             }
 220             return null;
 221         }
 222
 223         private  TermVocabularyDto getTermVocabularyByDto(Collection<TermDto> initialTerms){
 224
 225         TermType result = null;
 226         if(!initialTerms.isEmpty()){
 227             TermDto entity = initialTerms.iterator().next();
 228             return entity.getVocabularyDto();
 229         }
 230         return null;
 231     }
 232
 233
 234         /**
 235          * Generic method to set term preferences
 236          *
 237          * @param preferredTerms a {@link java.util.List} object.
 238          * @param initialTerms a {@link java.util.List} object.
 239          * @param <T> a T object.
 240          */
 241         public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
 242             TermVocabulary<T> voc = getTermVocabulary(initialTerms);
 243
 244                 Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
 245
 246                 for(TermBase term : initialTerms){
 247                         if(! preferredTerms.contains(term)){
 248                                 undesiredTermUuids.add(term.getUuid());
 249                                 PreferencesUtil.setBooleanValue(getPrefName(term), false);
 250                         }else{
 251                             PreferencesUtil.setBooleanValue(getPrefName(term), true);
 252                         }
 253                 }
 254                 clearTermMapForTermVoc(voc.getUuid());
 255
 256
 257
 258         }
 259
 260
 261            /**
 262      * Generic method to set term preferences
 263      *
 264      * @param preferredTerms a {@link java.util.List} object.
 265      * @param initialTerms a {@link java.util.List} object.
 266      * @param <T> a T object.
 267      */
 268     public <T extends DefinedTermBase> void setPreferredTermsByType(Collection<T> preferredTerms, TermType type){
 269
 270
 271
 272         List<DefinedTermBase> oldValues = getPreferredTerms(type);
 273         for (DefinedTermBase term: oldValues){
 274             PreferencesUtil.setBooleanValue(getPrefName(term), false);
 275         }
 276         for(TermBase term : preferredTerms){
 277            PreferencesUtil.setBooleanValue(getPrefName(term), true);
 278
 279         }
 280
 281         clearTermMapForTermType(type);
 282         List<DefinedTermBase> list = new ArrayList<>(preferredTerms);
 283         cachedTermMap.put(type.getUuid(), list);
 284
 285
 286
 287     }
 288         /**
 289      * Generic method to set term preferences
 290      *
 291      * @param preferredTerms a {@link java.util.List} object.
 292      * @param initialTerms a {@link java.util.List} object.
 293      * @param <T> a T object.
 294      */
 295     public void setPreferredTermsByDto(Collection<TermDto> preferredTerms, TermVocabularyDto vocDto){
 296
 297         List<TermDto> oldValues = getPreferredTerms(vocDto);
 298         for (TermDto term: oldValues){
 299             PreferencesUtil.setBooleanValue(getPrefNameByDto(term), false);
 300         }
 301         for(TermDto term : preferredTerms){
 302            PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
 303
 304         }
 305
 306         //if (initialTerms.iterator().hasNext()){
 307             clearTermMapForTermVoc(vocDto.getUuid());
 308             List<TermDto> list = new ArrayList<>(preferredTerms);
 309             cachedTermMap.put(vocDto.getUuid(), list);
 310         //}
 311
 312     }
 313
 314
 315         public <T extends DefinedTermBase> void clearTermMapForTermVoc(UUID vocUuid){
 316             cachedTermMap.remove(vocUuid);
 317         }
 318
 319         public void clearTermMapForTermType(TermType termType){
 320         cachedTermMap.remove(termType);
 321     }
 322
 323         /**
 324      * Generic method to get term preferences for a term vocabulary
 325      *
 326      * @param initialTerms a {@link java.util.List} object.
 327      * @return a {@link java.util.List} object.
 328      */
 329     public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, Class clazz){
 330
 331         List<T> filteredTerms = new ArrayList<T>();
 332         List<T> terms = TermStore.getTerms(clazz);
 333         if (uuidList == null || uuidList.isEmpty()){
 334             return terms;
 335         }
 336         for (T term : terms){
 337             if(uuidList.contains(term.getUuid())){
 338                 filteredTerms.add(term);
 339             }
 340         }
 341
 342         return filteredTerms;
 343     }
 344
 345     /**
 346      * Generic method to get term preferences for a term vocabulary
 347      *
 348      * @param initialTerms a {@link java.util.List} object.
 349      * @return a {@link java.util.List} object.
 350      */
 351     public <T extends DefinedTermBase> List<T> getAllTerms(TermType type, Comparator comparator){
 352         List<T> terms = TermStore.getTerms(type, comparator);
 353         return terms;
 354     }
 355 }