eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/CdmPreferenceCache.java

   1 /**
   2 * Copyright (C) 2018 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.preference;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collection;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.UUID;
  17
  18 import org.apache.log4j.Logger;
  19
  20 import eu.etaxonomy.cdm.api.application.ICdmRepository;
  21 import eu.etaxonomy.cdm.api.service.ITermService;
  22 import eu.etaxonomy.cdm.model.metadata.CdmPreference;
  23 import eu.etaxonomy.cdm.model.metadata.CdmPreference.PrefKey;
  24 import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
  25 import eu.etaxonomy.cdm.model.metadata.PreferenceResolver;
  26 import eu.etaxonomy.cdm.model.metadata.PreferenceSubject;
  27 import eu.etaxonomy.cdm.model.term.TermType;
  28 import eu.etaxonomy.cdm.persistence.dto.TermDto;
  29 import eu.etaxonomy.taxeditor.store.CdmStore;
  30
  31 /**
  32  * @author k.luther
  33  * @since 27.04.2018
  34  */
  35 public class CdmPreferenceCache {
  36     Map<String,List<CdmPreference>> preferenceCache = new HashMap<>();
  37
  38     private static CdmPreferenceCache instance;
  39
  40     private final static Logger logger = Logger.getLogger(CdmPreferenceCache.class);
  41
  42     public static CdmPreferenceCache instance(){
  43         if(instance == null){
  44             instance = new CdmPreferenceCache();
  45         }
  46         return instance;
  47     }
  48
  49     public CdmPreference get(String predicate){
  50         if (preferenceCache.get(predicate) != null){
  51             if (preferenceCache.get(predicate).size() > 1){
  52                 CdmPreference pref = PreferenceResolver.resolve(preferenceCache.get(predicate), CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.getByKey(predicate)));
  53                 return pref;
  54             }
  55             return preferenceCache.get(predicate).get(0);
  56         }
  57         return null;
  58     }
  59
  60     public List<CdmPreference> getAllForPredicate(String predicate){
  61         if (preferenceCache.get(predicate) != null){
  62             return preferenceCache.get(predicate);
  63
  64         }
  65         return null;
  66     }
  67
  68     //looking for the equal prefkey
  69     public CdmPreference get(PrefKey key){
  70         if (preferenceCache.containsKey(key.getPredicate())){
  71             for (CdmPreference pref: preferenceCache.get(key.getPredicate())){
  72                 if (pref.getSubjectString().equals(key.getSubject())){
  73                     return pref;
  74                 }
  75             }
  76
  77         }
  78         return null;
  79     }
  80
  81     public void put(CdmPreference pref){
  82         if (preferenceCache.containsKey(pref.getPredicate())){
  83             List<CdmPreference> cachedPreferences = preferenceCache.get(pref.getPredicate());
  84             CdmPreference prefToRemove = null;
  85             for (CdmPreference cachedPref:cachedPreferences){
  86                 if (pref.getKey().equals(cachedPref.getKey())){
  87                     prefToRemove = cachedPref;
  88                 }
  89             }
  90             cachedPreferences.remove(prefToRemove);
  91             cachedPreferences.add(pref);
  92         }else{
  93             List<CdmPreference> prefs = new ArrayList<>();
  94             prefs.add(pref);
  95             preferenceCache.put(pref.getPredicate(), prefs);
  96         }
  97     }
  98
  99     public boolean remove(CdmPreference pref){
 100         if (preferenceCache.containsKey(pref.getPredicate())){
 101             List<CdmPreference> cachedPreferences = preferenceCache.get(pref.getPredicate());
 102             CdmPreference prefToRemove = null;
 103             for (CdmPreference cachedPref:cachedPreferences){
 104                 if (pref.getKey().equals(cachedPref.getKey())){
 105                     prefToRemove = cachedPref;
 106                 }
 107             }
 108             cachedPreferences.remove(prefToRemove);
 109         }
 110         return true;
 111     }
 112
 113     public void getAllTaxEditorDBPreferences(){
 114         ICdmRepository controller;
 115         controller = CdmStore.getCurrentApplicationConfiguration();
 116         List<CdmPreference> allPreferences = controller.getPreferenceService().list();
 117         preferenceCache.clear();
 118
 119         for (CdmPreference pref: allPreferences){
 120             put(pref);
 121         }
 122
 123         loadAndSet(PreferencePredicate.AvailableDistributionStatus, TermType.PresenceAbsenceTerm);
 124         loadAndSet(PreferencePredicate.AvailableRanks, TermType.Rank);
 125         loadAndSet(PreferencePredicate.AvailableNomenclaturalStatus, TermType.NomenclaturalStatusType);
 126         loadAndSet(PreferencePredicate.AvailableNameRelationshipType, TermType.NameRelationshipType);
 127         loadAndSet(PreferencePredicate.AvailableLanguages, TermType.Language);
 128     }
 129
 130     private void loadAndSet(PreferencePredicate preferencePredicate, TermType termType) {
 131         PrefKey key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), preferencePredicate);
 132         if (get(key) != null){
 133             if (!PreferencesUtil.getOverrideForPreference(preferencePredicate.getKey()) || !get(key).isAllowOverride()){
 134                 //get terms for the uuids... and add them to the termManager as preferred terms
 135                 Collection<TermDto> dtos = createDtoList(key);
 136                 if (dtos != null){
 137                     CdmStore.getTermManager().setPreferredTermsByType(dtos, termType);
 138                 }
 139             }
 140         }
 141     }
 142
 143     public Collection<TermDto> createDtoList(PrefKey key) {
 144         ITermService termService = CdmStore.getService(ITermService.class);
 145         List<UUID> uuidList = createUuidList(key);
 146         Collection<TermDto> dtos = termService.findByUUIDsAsDto(uuidList);
 147         return dtos;
 148     }
 149
 150     public List<UUID> createUuidList(PrefKey key) {
 151         List<UUID> uuidList = new ArrayList<>();
 152         if (get(key).getValue() != null){
 153             String[] uuidArray =findBestMatching(key).getValue().split(";");
 154             for (String uuidString:uuidArray){
 155                 try {
 156                     uuidList.add(UUID.fromString(uuidString));
 157                 } catch (Exception e) {
 158                     logger.warn("Preference loading failed", e);
 159                 }
 160             }
 161         }
 162         return uuidList;
 163     }
 164
 165     public CdmPreference findBestMatching(PrefKey key) {
 166         List<CdmPreference> allPrefs = new ArrayList<>();
 167         for (String predicate: preferenceCache.keySet()){
 168             allPrefs.addAll(preferenceCache.get(predicate));
 169         }
 170         return PreferenceResolver.resolve(allPrefs, key);
 171     }
 172 }