X-Git-Url: https://dev.e-taxonomy.eu/gitweb/taxeditor.git/blobdiff_plain/b4af1c2e935612a9b2a6715eb918a8c596cd8082..c5527b351b89a4cab88cdc1586bbe3325fdfa36d:/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java

diff --git a/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java b/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java
index 04dd2513e..523a59bb3 100644
--- a/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java
+++ b/eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java
@@ -11,58 +11,132 @@ package eu.etaxonomy.taxeditor.store;
 
 import java.util.ArrayList;
 import java.util.Collection;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 import java.util.UUID;
 
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
-import eu.etaxonomy.cdm.model.common.TermBase;
-import eu.etaxonomy.cdm.model.common.TermType;
-import eu.etaxonomy.cdm.model.common.TermVocabulary;
+import eu.etaxonomy.cdm.model.term.DefinedTermBase;
+import eu.etaxonomy.cdm.model.term.TermBase;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.cdm.model.term.TermVocabulary;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.model.DefaultTermComparator;
 import eu.etaxonomy.taxeditor.model.TaxonRelationshipTypeInverseContainer;
 import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
 
 /**
  * @author n.hoffmann
  * @created Dec 7, 2010
- * @version 1.0
  */
 public class TermManager {
 
-	private static final String TERMS = "terms";
-	private static final String TERM = "term";
-	private static final String HIDE = "hide";
+    private Map<Object, List> cachedTermMap = new HashMap<>();
 
-	private static final String CLASS = "class";
-	private static final String UUID_STRING = "uuid";
+    //new cache for features!!
+    //dinstinguish preferences for both
+    //load at start
 
 	public TermManager(){
 	}
 
-	/**
-	 *
-	 * @param clazz
-	 * @return
-	 */
+	public void reset(){
+		cachedTermMap = new HashMap<>();
+	}
+
 	public <T extends DefinedTermBase> List<T> getPreferredTerms(TermType termType){
-	    return getFilteredTerms(TermStore.<T>getTerms(termType, null));
+	    List<?> terms = cachedTermMap.get(termType.getUuid());
+	    List<T> termBaseList = new ArrayList<>();
+	    if(terms==null || terms.isEmpty()){
+	        termBaseList = getFilteredTerms(TermStore.<T>getTerms(termType, null));
+	        if (termBaseList != null){
+	            cachedTermMap.put(termType.getUuid(), termBaseList);
+	        }
+	    }else{
+	        Iterator<?> iterator = terms.iterator();
+            List<UUID> uuids = new ArrayList<>();
+            while (iterator.hasNext()){
+                Object term = iterator.next();
+                if (term instanceof TermDto){
+                    TermDto dto = (TermDto)term;
+                    uuids.add(dto.getUuid());
+                }else {
+                    termBaseList.add((T)term);
+                }
+
+            }
+            if (!uuids.isEmpty()){
+                termBaseList.addAll(getTerms(uuids, termType));
+            }
+	    }
+        return termBaseList;
 	}
 
-	/**
-	 *
-	 * @param clazz
-	 * @return
-	 */
 	public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary){
-	    return getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary, null)));
+	    @SuppressWarnings("unchecked")
+        List<T> terms = cachedTermMap.get(termVocabulary.getUuid());
+	    if(terms==null){
+	        terms = getFilteredTerms(new ArrayList<>(TermStore.getTerms(termVocabulary,null)));
+	        cachedTermMap.put(termVocabulary.getUuid(), terms);
+	    }
+	    return terms;
 	}
 
-	/**
-	 *
-	 * @param clazz
-	 * @return
-	 */
+   public List<TermDto> getPreferredTerms(TermVocabularyDto termVocabularyDto){
+       @SuppressWarnings("unchecked")
+       List<TermDto> terms = cachedTermMap.get(termVocabularyDto.getUuid());
+       if(terms==null || terms.isEmpty()){
+           terms = getFilteredTermDtos(new ArrayList<>(termVocabularyDto.getTerms()));
+           cachedTermMap.put(termVocabularyDto.getUuid(), terms);
+       }
+       return terms;
+   }
+
+   public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary,
+           Comparator comp){
+       if (comp == null){
+           comp = new DefaultTermComparator<T>();
+       }
+       @SuppressWarnings("unchecked")
+    List<T> terms = cachedTermMap.get(termVocabulary.getUuid());
+       List<T> termBaseList = new ArrayList<>();
+       if(terms==null){
+           termBaseList = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary, comp)));
+           cachedTermMap.put(termVocabulary.getUuid(), termBaseList);
+       }else{
+           Iterator<?> iterator = terms.iterator();
+           List<UUID> uuids = new ArrayList<>();
+           while (iterator.hasNext()){
+               Object term = iterator.next();
+               if (term instanceof TermDto){
+                   TermDto dto = (TermDto)term;
+                   uuids.add(dto.getUuid());
+               }else {
+                   termBaseList.add((T)term);
+               }
+           }
+
+           if (!uuids.isEmpty()){
+               termBaseList.addAll(this.getTerms(uuids, DefinedTermBase.class));
+           }
+
+       }
+       termBaseList.sort(comp);
+       terms = termBaseList;
+       return terms;
+   }
+
 	public <T extends DefinedTermBase> List<T> getPreferredTerms(Class<T> clazz){
-		return getFilteredTerms(TermStore.getTerms(clazz));
+	    @SuppressWarnings("unchecked")
+        List<T> terms = cachedTermMap.get(clazz);
+	    if(terms==null){
+	        terms = getFilteredTerms(TermStore.getTerms(clazz));
+	        cachedTermMap.put(clazz, terms);
+	    }
+	    return terms;
 	}
 
 	/**
@@ -72,45 +146,84 @@ public class TermManager {
 	 * @return a {@link java.util.List} object.
 	 */
 	public <T extends DefinedTermBase> List<T> getFilteredTerms(List<T> initialTerms){
-
-		List<T> filteredTerms = new ArrayList<T>();
+		List<T> filteredTerms = new ArrayList<>();
+		if (initialTerms == null || initialTerms.isEmpty()){
+		    return filteredTerms;
+		}
 
 		for (T term : initialTerms){
-
 			if (term instanceof TaxonRelationshipTypeInverseContainer){
-				if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
+				if(!PreferencesUtil.getBooleanValue(getPrefName(term), true)){
 					T type = (T)((TaxonRelationshipTypeInverseContainer) term).getType();
 					filteredTerms.add(type);
-
 				}
 			}
 
-			if(!PreferencesUtil.getPreferenceStore().getBoolean(getPrefName(term))){
+			if(PreferencesUtil.getBooleanValue(getPrefName(term), true)){
 				filteredTerms.add(term);
 			}
 		}
+		if (filteredTerms.isEmpty()){
+		    //check for dtos
+		    List<TermDto> preferredTerms = null;
+		    if (initialTerms.get(0).getVocabulary() != null){
+		        preferredTerms = cachedTermMap.get(initialTerms.get(0).getVocabulary().getUuid());
+		    }
+		    if (preferredTerms == null){
+		        preferredTerms = cachedTermMap.get(initialTerms.get(0).getTermType());
+		    }
+		    if (preferredTerms == null){
+		        return initialTerms;
+		    }
+		    for (T term : initialTerms){
+	            if (preferredTerms.contains(TermDto.fromTerm(term))){
+	                filteredTerms.add(term);
+	            }
+	        }
+		    if (filteredTerms.isEmpty()){
+		        return initialTerms;
+		    }
+		}
 
 		return filteredTerms;
 	}
 
+	/**
+     * Generic method to get term preferences for a term vocabulary
+     *
+     * @param initialTerms a {@link java.util.List} object.
+     * @return a {@link java.util.List} object.
+     */
+    public List<TermDto> getFilteredTermDtos(List<TermDto> initialTerms){
+
+        List<TermDto> filteredTerms = new ArrayList<>();
+
+        for (TermDto term : initialTerms){
+            //TODO:inverse terms!!
+            if(PreferencesUtil.getBooleanValue(getPrefNameByDto(term))){
+                filteredTerms.add(term);
+            }
+        }
+        if (filteredTerms.isEmpty()){
+            return initialTerms;
+        }
+
+        return filteredTerms;
+    }
+
     private <T extends TermBase> String getPrefName(T term) {
         return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
     }
 
+    private String getPrefNameByDto(TermDto term) {
+        return term.getTermType()!=null?term.getTermType().toString()+term.getUuid().toString():""+term.getUuid().toString();
+    }
 
-	private <T extends DefinedTermBase> String getTermClass(Collection<T> initialTerms){
+	private <T extends DefinedTermBase> TermVocabulary<T> getTermVocabulary(Collection<T> initialTerms){
 
-		String result = null;
 		if(!initialTerms.isEmpty()){
-
-			//TODO: there should be a more generic solution!!
 	    	T entity = initialTerms.iterator().next();
-	    	if (entity instanceof TaxonRelationshipTypeInverseContainer){
-	    		result = ((TaxonRelationshipTypeInverseContainer) entity).getType().getClass().getName();
-	    	} else {
-	    		result = entity.getClass().getName();
-	    	}
-	        return result;
+	        return entity.getVocabulary();
 	    }
 	    return null;
 	}
@@ -123,19 +236,143 @@ public class TermManager {
 	 * @param <T> a T object.
 	 */
 	public <T extends DefinedTermBase> void setPreferredTerms(Collection<T> preferredTerms, Collection<T> initialTerms){
-	String typeName = getTermClass(initialTerms);
-
-		Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
-
+	    TermVocabulary<T> voc = getTermVocabulary(initialTerms);
+		Collection<UUID> undesiredTermUuids = new ArrayList<>();
 		for(TermBase term : initialTerms){
 			if(! preferredTerms.contains(term)){
 				undesiredTermUuids.add(term.getUuid());
-				PreferencesUtil.getPreferenceStore().setValue(getPrefName(term), true);
+				PreferencesUtil.setBooleanValue(getPrefName(term), false);
 			}else{
-			    PreferencesUtil.getPreferenceStore().setValue(getPrefName(term), false);
+			    PreferencesUtil.setBooleanValue(getPrefName(term), true);
 			}
+		}
+		clearTermMapForTermVoc(voc.getUuid());
+	}
 
+	/**
+     * Generic method to set term preferences
+     *
+     * @param preferredTerms a {@link java.util.List} object.
+     * @param initialTerms a {@link java.util.List} object.
+     * @param <T> a T object.
+     */
+    public  void setPreferredTermsByType(Collection<TermDto> preferredTerms, TermType type){
+        List<?> oldValues = getPreferredTerms(type);
+        if (oldValues != null){
+            for (Object term: oldValues){
+                if (term instanceof TermDto){
+                    PreferencesUtil.setBooleanValue(getPrefNameByDto((TermDto)term), false);
+                }else{
+                    PreferencesUtil.setBooleanValue(getPrefName((DefinedTermBase)term), false);
+                }
+            }
+        }
+//        for(TermDto term : preferredTerms){
+//           PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
+//
+//        }
 
-		}
+        clearTermMapForTermType(type);
+        List<TermDto> list = new ArrayList<>(preferredTerms);
+        cachedTermMap.put(type, list);
+    }
+
+    /**
+     * Generic method to set term preferences
+     *
+     * @param preferredTerms a {@link java.util.List} object.
+     * @param initialTerms a {@link java.util.List} object.
+     * @param <T> a T object.
+     */
+    public void setPreferredTermsByDto(Collection<TermDto> preferredTerms, TermVocabularyDto vocDto){
+
+        List<TermDto> oldValues = getPreferredTerms(vocDto);
+        for (TermDto term: oldValues){
+            PreferencesUtil.setBooleanValue(getPrefNameByDto(term), false);
+        }
+        TermType type = null;
+        boolean allSameType = true;
+        for(TermDto term : preferredTerms){
+            PreferencesUtil.setBooleanValue(getPrefNameByDto(term), true);
+           if (type == null){
+               type = term.getTermType();
+           }else if (!type.equals(term.getTermType())){
+               allSameType = false;
+           }
+        }
+
+        //if (initialTerms.iterator().hasNext()){
+            clearTermMapForTermVoc(vocDto.getUuid());
+            List<TermDto> list = new ArrayList<>(preferredTerms);
+            cachedTermMap.put(vocDto.getUuid(), list);
+            if (allSameType){
+                cachedTermMap.put(type, list);
+            }
+        //}
+    }
+
+
+	public <T extends DefinedTermBase> void clearTermMapForTermVoc(UUID vocUuid){
+	    cachedTermMap.remove(vocUuid);
 	}
+
+	public void clearTermMapForTermType(TermType termType){
+        cachedTermMap.remove(termType);
+    }
+
+	/**
+     * Generic method to get term preferences for a term vocabulary
+     *
+     * @param initialTerms a {@link java.util.List} object.
+     * @return a {@link java.util.List} object.
+     */
+    public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, Class clazz){
+
+        List<T> filteredTerms = new ArrayList<>();
+        @SuppressWarnings("unchecked")
+		List<T> terms = TermStore.getTerms(clazz);
+        if (uuidList == null || uuidList.isEmpty()){
+            return terms;
+        }
+        for (T term : terms){
+            if(uuidList.contains(term.getUuid())){
+                filteredTerms.add(term);
+            }
+        }
+
+        return filteredTerms;
+    }
+
+    /**
+     * Generic method to get term preferences for a term vocabulary
+     *
+     * @param initialTerms a {@link java.util.List} object.
+     * @return a {@link java.util.List} object.
+     */
+    public <T extends DefinedTermBase> List<T> getTerms(List<UUID> uuidList, TermType type){
+
+        List<T> filteredTerms = new ArrayList<>();
+        List<T> terms = TermStore.getTerms(type, null);
+        if (uuidList == null || uuidList.isEmpty()){
+            return terms;
+        }
+        for (T term : terms){
+            if(uuidList.contains(term.getUuid())){
+                filteredTerms.add(term);
+            }
+        }
+
+        return filteredTerms;
+    }
+
+    /**
+     * Generic method to get term preferences for a term vocabulary
+     *
+     * @param initialTerms a {@link java.util.List} object.
+     * @return a {@link java.util.List} object.
+     */
+    public <T extends DefinedTermBase> List<T> getAllTerms(TermType type, Comparator comparator){
+        List<T> terms = TermStore.getTerms(type, comparator);
+        return terms;
+    }
 }