eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java

   1 /**
   2 * Copyright (C) 2009 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.editor.definedterm.input;
  10
  11 import java.util.ArrayList;
  12 import java.util.Arrays;
  13 import java.util.HashSet;
  14 import java.util.List;
  15 import java.util.Set;
  16 import java.util.stream.Collectors;
  17
  18 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  19 import eu.etaxonomy.cdm.model.description.Feature;
  20 import eu.etaxonomy.cdm.model.term.DefinedTerm;
  21 import eu.etaxonomy.cdm.model.term.TermTree;
  22 import eu.etaxonomy.cdm.model.term.TermType;
  23 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  24 import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
  25 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
  26 import eu.etaxonomy.taxeditor.store.CdmStore;
  27 import eu.etaxonomy.taxeditor.store.TermStore;
  28
  29
  30
  31 /**
  32  * @author n.hoffmann
  33  * @date Jan 24, 2012
  34  *
  35  */
  36 public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm> {
  37
  38         private TermType termType;
  39         private Set<TermVocabularyDto> vocabularies;
  40
  41         // FIXME: the default feature should be move to CdmApplicationState
  42         //        where it is a singleton instance variable
  43         private static TermTree defaultFeatureTree = null;
  44         private static TermTree defaultNameFeatureTree = null;
  45
  46         private List<String> termClasses = Arrays.asList(new String[]{
  47                         DefinedTerm.class.getName()
  48         });
  49
  50         public TermEditorInput(TermType termType) {
  51                 this.termType = termType;
  52                 vocabularies = new HashSet<TermVocabularyDto>();
  53                 initialiseVocabularies();
  54         }
  55         public String getName() {
  56                 return termType.getLabel();
  57         }
  58
  59         @Override
  60         public List<String> getTermClasses() {
  61                 return termClasses;
  62         }
  63
  64         public TermType getTermType() {
  65                 return termType;
  66         }
  67
  68         public void initialiseVocabularies() {
  69                 if(vocabularies != null) {
  70                         vocabularies.clear();
  71                 }
  72                 List<TermVocabularyDto> vocs = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(termType, false);
  73                 vocabularies.addAll(vocs);
  74         }
  75
  76         public Set<TermVocabularyDto> getVocabularies() {
  77                 return vocabularies;
  78         }
  79
  80         public void updateDefaultFeatureTree() {
  81             for(TermVocabularyDto vocab : getVocabularies()) {
  82                 if(vocab != null && TermType.Feature.equals(vocab.getTermType())) {
  83                     defaultFeatureTree = null;
  84                     return;
  85                 }
  86             }
  87         }
  88
  89         @Override
  90     public Set<TermVocabularyDto>  getRootEntities() {
  91         return getVocabularies();
  92     }
  93
  94         @Override
  95     public void merge() {
  96             List<TermVocabulary> vocabularies = new ArrayList<>();
  97             getRootEntities().forEach(vocDto->vocabularies.add(CdmStore.getService(IVocabularyService.class).load(vocDto.getUuid())));
  98         CdmStore.getService(IVocabularyService.class).merge(vocabularies, true);
  99         updateDefaultFeatureTree();
 100     }
 101
 102     public static TermTree getDefaultFeatureTree() {
 103         if(defaultFeatureTree == null) {
 104             List<Feature> features = TermStore.getTerms(Feature.class);
 105 //            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
 106 //            List<Feature> nameFeatures = new ArrayList(voc.getTerms());
 107             List<Feature> taxonFeatures = features.stream().filter(f -> f.isAvailableForTaxon())
 108                     .collect(Collectors.toList());
 109 //            for (Feature feature: copy){
 110 //                if (nameFeatures.contains(feature)){
 111 //                    features.remove(feature);
 112 //                }
 113 //            }
 114             defaultFeatureTree = TermTree.NewInstance(taxonFeatures);
 115         }
 116         return defaultFeatureTree;
 117     }
 118
 119     public static void resetDefaultFeatureTree(){
 120         defaultFeatureTree = null;
 121     }
 122     public static TermTree getDefaultNameFeatureTree() {
 123         if(defaultNameFeatureTree == null) {
 124 //            List<TermVocabularyDto> vocs = new ArrayList<>();
 125 //            Set<CdmClass> availableFor = new HashSet<>();
 126 //            availableFor.add(CdmClass.TAXON_NAME);
 127 //            vocs = CdmStore.getService(IVocabularyService.class).findFeatureVocabularyDtoByTermTypes(availableFor);
 128 //            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
 129 //            List<Feature> nameFeatures = new ArrayList(voc.getTerms());
 130 //            nameFeatures.remove(Feature.PROTOLOGUE());
 131 //            PreferencesUtil.createPreferredFeatureTreeForNameDescription();
 132             defaultNameFeatureTree = PreferencesUtil.getPreferredFeatureTreeForNameDescription(true);
 133           //List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
 134 //            defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);
 135         }
 136         return defaultNameFeatureTree;
 137
 138     }
 139
 140     public static void resetDefaultNameFeatureTree(){
 141         defaultNameFeatureTree = null;
 142     }
 143
 144     /**
 145      * @return
 146      */
 147     public static TermTree<?> getPreferredNameFeatureTree(boolean createNew) {
 148
 149         return PreferencesUtil.getPreferredFeatureTreeForNameDescription(createNew);
 150
 151     }
 152
 153     public static TermTree<?> getPreferredTaxonFeatureTree(boolean createNew) {
 154
 155         return PreferencesUtil.getPreferredFeatureTreeForTaxonDescription(createNew);
 156
 157     }
 158 }