Merge branch 'release/5.18.0'

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

diff --git a/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java b/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java
index 670f45a407be085149fde52ca028a28864f6b609..8c9887a050c92c8601fec79c8cf08367790713ec 100644 (file)
--- a/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java
+++ b/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java
@@ -13,14 +13,16 @@ import java.util.Arrays;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import eu.etaxonomy.cdm.api.service.IVocabularyService;
-import eu.etaxonomy.cdm.model.common.DefinedTerm;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.TermType;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
 import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.description.FeatureTree;
+import eu.etaxonomy.cdm.model.term.DefinedTerm;
+import eu.etaxonomy.cdm.model.term.TermTree;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.cdm.model.term.TermVocabulary;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
 import eu.etaxonomy.taxeditor.store.CdmStore;
 import eu.etaxonomy.taxeditor.store.TermStore;
 
@@ -34,11 +36,12 @@ import eu.etaxonomy.taxeditor.store.TermStore;
 public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm> {
 
        private TermType termType;
-       private Set<TermVocabulary<DefinedTermBase>> vocabularies;
+       private Set<TermVocabularyDto> vocabularies;
 
        // FIXME: the default feature should be move to CdmApplicationState
        //        where it is a singleton instance variable
-       private static FeatureTree defaultFeatureTree = null;
+       private static TermTree defaultFeatureTree = null;
+       private static TermTree defaultNameFeatureTree = null;
 
        private List<String> termClasses = Arrays.asList(new String[]{
                        DefinedTerm.class.getName()
@@ -46,16 +49,13 @@ public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm>
 
        public TermEditorInput(TermType termType) {
                this.termType = termType;
-               vocabularies = new HashSet<TermVocabulary<DefinedTermBase>>();
+               vocabularies = new HashSet<TermVocabularyDto>();
                initialiseVocabularies();
        }
        public String getName() {
-               return termType.getMessage();
+               return termType.getLabel();
        }
 
-       /* (non-Javadoc)
-        * @see eu.etaxonomy.taxeditor.editor.definedterm.input.AbstractDefinedTermEditorInput#getTermClasses()
-        */
        @Override
        public List<String> getTermClasses() {
                return termClasses;
@@ -69,43 +69,90 @@ public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm>
                if(vocabularies != null) {
                        vocabularies.clear();
                }
-               List<TermVocabulary<DefinedTermBase>> vocs = CdmStore.getService(IVocabularyService.class).findByTermType(termType,
-                       Arrays.asList("terms", "terms.level"));
+               List<TermVocabularyDto> vocs = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(termType, false);
                vocabularies.addAll(vocs);
        }
 
-       public Set<TermVocabulary<DefinedTermBase>> getVocabularies() {
+       public Set<TermVocabularyDto> getVocabularies() {
                return vocabularies;
        }
 
        public void updateDefaultFeatureTree() {
-           for(TermVocabulary vocab : getVocabularies()) {
+           for(TermVocabularyDto vocab : getVocabularies()) {
                if(vocab != null && TermType.Feature.equals(vocab.getTermType())) {
                    defaultFeatureTree = null;
                    return;
                }
            }
        }
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public Set<TermVocabulary<DefinedTermBase>>  getRootEntities() {
+
+       @Override
+    public Set<TermVocabularyDto>  getRootEntities() {
         return getVocabularies();
     }
-    /**
-     * {@inheritDoc}
-     */
-    @Override
+
+       @Override
     public void merge() {
-        CdmStore.getService(IVocabularyService.class).merge(new ArrayList<TermVocabulary>(getRootEntities()), true);
+           List<TermVocabulary> vocabularies = new ArrayList<>();
+           getRootEntities().forEach(vocDto->vocabularies.add(CdmStore.getService(IVocabularyService.class).load(vocDto.getUuid())));
+        CdmStore.getService(IVocabularyService.class).merge(vocabularies, true);
         updateDefaultFeatureTree();
     }
 
-    public static FeatureTree getDefaultFeatureTree() {
+    public static TermTree getDefaultFeatureTree() {
         if(defaultFeatureTree == null) {
-            defaultFeatureTree = FeatureTree.NewInstance(TermStore.getTerms(Feature.class));
+            List<Feature> features = TermStore.getTerms(Feature.class);
+//            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+//            List<Feature> nameFeatures = new ArrayList(voc.getTerms());
+            List<Feature> taxonFeatures = features.stream().filter(f -> f.isAvailableForTaxon())
+                    .collect(Collectors.toList());
+//            for (Feature feature: copy){
+//                if (nameFeatures.contains(feature)){
+//                    features.remove(feature);
+//                }
+//            }
+            defaultFeatureTree = TermTree.NewInstance(taxonFeatures);
         }
         return defaultFeatureTree;
     }
+
+    public static void resetDefaultFeatureTree(){
+        defaultFeatureTree = null;
+    }
+    public static TermTree getDefaultNameFeatureTree() {
+        if(defaultNameFeatureTree == null) {
+//            List<TermVocabularyDto> vocs = new ArrayList<>();
+//            Set<CdmClass> availableFor = new HashSet<>();
+//            availableFor.add(CdmClass.TAXON_NAME);
+//            vocs = CdmStore.getService(IVocabularyService.class).findFeatureVocabularyDtoByTermTypes(availableFor);
+//            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+//            List<Feature> nameFeatures = new ArrayList(voc.getTerms());
+//            nameFeatures.remove(Feature.PROTOLOGUE());
+//            PreferencesUtil.createPreferredFeatureTreeForNameDescription();
+            defaultNameFeatureTree = PreferencesUtil.getPreferredFeatureTreeForNameDescription(true);
+          //List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
+//            defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);
+        }
+        return defaultNameFeatureTree;
+
+    }
+
+    public static void resetDefaultNameFeatureTree(){
+        defaultNameFeatureTree = null;
+    }
+
+    /**
+     * @return
+     */
+    public static TermTree<?> getPreferredNameFeatureTree(boolean createNew) {
+
+        return PreferencesUtil.getPreferredFeatureTreeForNameDescription(createNew);
+
+    }
+
+    public static TermTree<?> getPreferredTaxonFeatureTree(boolean createNew) {
+
+        return PreferencesUtil.getPreferredFeatureTreeForTaxonDescription(createNew);
+
+    }
 }