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.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.UUID;
  16
  17 import org.apache.log4j.Logger;
  18
  19 import eu.etaxonomy.cdm.api.application.ICdmRepository;
  20 import eu.etaxonomy.cdm.api.service.ITermService;
  21 import eu.etaxonomy.cdm.model.metadata.CdmPreference;
  22 import eu.etaxonomy.cdm.model.metadata.CdmPreference.PrefKey;
  23 import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
  24 import eu.etaxonomy.cdm.model.metadata.PreferenceResolver;
  25 import eu.etaxonomy.cdm.model.metadata.PreferenceSubject;
  26 import eu.etaxonomy.cdm.model.term.DefinedTermBase;
  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  */
  36 public class CdmPreferenceCache {
  37     Map<String,List<CdmPreference>> preferenceCache = new HashMap();
  38
  39     private static CdmPreferenceCache instance;
  40
  41     private final static Logger logger = Logger.getLogger(CdmPreferenceCache.class);
  42
  43
  44
  45     public static CdmPreferenceCache instance(){
  46         if(instance == null){
  47             instance = new CdmPreferenceCache();
  48         }
  49         return instance;
  50     }
  51
  52     public CdmPreference get(String predicate){
  53         if (preferenceCache.get(predicate) != null){
  54             List<CdmPreference> preferences = preferenceCache.get(predicate);
  55             if (preferenceCache.get(predicate).size() > 1){
  56                 CdmPreference pref = PreferenceResolver.resolve(preferenceCache.get(predicate), CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.getByKey(predicate)));
  57                 return pref;
  58             }
  59             return preferenceCache.get(predicate).get(0);
  60         }
  61         return null;
  62     }
  63
  64     public List<CdmPreference> getAllForPredicate(String predicate){
  65         if (preferenceCache.get(predicate) != null){
  66             return preferenceCache.get(predicate);
  67
  68         }
  69         return null;
  70     }
  71
  72     //looking for the equal prefkey
  73     public CdmPreference get(PrefKey key){
  74         if (preferenceCache.containsKey(key.getPredicate())){
  75             for (CdmPreference pref: preferenceCache.get(key.getPredicate())){
  76                 if (pref.getSubjectString().equals(key.getSubject())){
  77                     return pref;
  78                 }
  79             }
  80
  81         }
  82         return null;
  83     }
  84
  85     public void put(CdmPreference pref){
  86         if (preferenceCache.containsKey(pref.getPredicate())){
  87             List<CdmPreference> cachedPreferences = preferenceCache.get(pref.getPredicate());
  88             CdmPreference prefToRemove = null;
  89             for (CdmPreference cachedPref:cachedPreferences){
  90                 if (pref.getKey().equals(cachedPref.getKey())){
  91                     prefToRemove = cachedPref;
  92                 }
  93             }
  94             cachedPreferences.remove(prefToRemove);
  95             cachedPreferences.add(pref);
  96         }else{
  97             List<CdmPreference> prefs = new ArrayList();
  98             prefs.add(pref);
  99             preferenceCache.put(pref.getPredicate(), prefs);
 100         }
 101
 102
 103     }
 104
 105     public boolean remove(CdmPreference pref){
 106         if (preferenceCache.containsKey(pref.getPredicate())){
 107             List<CdmPreference> cachedPreferences = preferenceCache.get(pref.getPredicate());
 108             CdmPreference prefToRemove = null;
 109             for (CdmPreference cachedPref:cachedPreferences){
 110                 if (pref.getKey().equals(cachedPref.getKey())){
 111                     prefToRemove = cachedPref;
 112                 }
 113             }
 114             cachedPreferences.remove(prefToRemove);
 115         }
 116         return true;
 117
 118     }
 119
 120     public void getAllTaxEditorDBPreferences(){
 121         ICdmRepository controller;
 122         controller = CdmStore.getCurrentApplicationConfiguration();
 123         List<CdmPreference> allPreferences = controller.getPreferenceService().list();
 124         preferenceCache.clear();
 125
 126         for (CdmPreference pref: allPreferences){
 127             put(pref);
 128         }
 129
 130         PrefKey key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.AvailableDistributionStatus);
 131
 132         if (get(key) != null){
 133             if (!PreferencesUtil.getBooleanValue(PreferencesUtil.prefOverrideKey(PreferencePredicate.AvailableDistributionStatus.getKey())) || !get(key).isAllowOverride()){
 134                 //get terms for the uuids... and add them to the termManager as preferred terms
 135                 ITermService termService = CdmStore.getService(ITermService.class);
 136                 List<UUID> uuidList = new ArrayList();
 137                 if (get(key).getValue() != null){
 138                     String[] uuidArray =findBestMatching(key).getValue().split(";");
 139                     for (String uuidString:uuidArray){
 140                         try {
 141                             uuidList.add(UUID.fromString(uuidString));
 142                         } catch (Exception e) {
 143                             logger.warn("Preference loading failed", e);
 144                         }
 145                     }
 146                 }
 147
 148                 List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
 149                 List<TermDto> dtos = new ArrayList<>();
 150                 for (DefinedTermBase term: definedTermBases){
 151                     dtos.add(TermDto.fromTerm(term));
 152                 }
 153                 CdmStore.getTermManager().setPreferredTermsByType(dtos, TermType.PresenceAbsenceTerm);
 154             }
 155         }
 156          key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.AvailableRanks);
 157
 158         if (get(key) != null){
 159             if (!PreferencesUtil.getBooleanValue(PreferencesUtil.prefOverrideKey(PreferencePredicate.AvailableRanks.getKey())) || !get(key).isAllowOverride()){
 160                 //get terms for the uuids... and add them to the termManager as preferred terms
 161                 ITermService termService = CdmStore.getService(ITermService.class);
 162                 List<UUID> uuidList = new ArrayList();
 163                 if (get(key).getValue() != null){
 164                     String[] uuidArray =findBestMatching(key).getValue().split(";");
 165                     for (String uuidString:uuidArray){
 166                         try {
 167                             uuidList.add(UUID.fromString(uuidString));
 168                         } catch (Exception e) {
 169                             logger.warn("Preference loading failed", e);
 170                         }
 171                     }
 172                 }
 173
 174                 List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
 175                 List<TermDto> dtos = new ArrayList();
 176                 for (DefinedTermBase term: definedTermBases){
 177                     dtos.add(TermDto.fromTerm(term));
 178                 }
 179                 CdmStore.getTermManager().setPreferredTermsByType(dtos, TermType.Rank);
 180             }
 181         }
 182
 183         key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.AvailableNomenclaturalStatus);
 184
 185         if (get(key) != null){
 186             if (!PreferencesUtil.getBooleanValue(PreferencesUtil.prefOverrideKey(PreferencePredicate.AvailableNomenclaturalStatus.getKey())) || !get(key).isAllowOverride()){
 187                 //get terms for the uuids... and add them to the termManager as preferred terms
 188                 ITermService termService = CdmStore.getService(ITermService.class);
 189                 List<UUID> uuidList = new ArrayList();
 190                 if (get(key).getValue() != null){
 191                     String[] uuidArray =findBestMatching(key).getValue().split(";");
 192                     for (String uuidString:uuidArray){
 193                         try {
 194                             uuidList.add(UUID.fromString(uuidString));
 195                         } catch (Exception e) {
 196                             logger.warn("Preference loading failed", e);
 197                         }
 198                     }
 199                 }
 200
 201                 List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
 202                 List<TermDto> dtos = new ArrayList();
 203                 for (DefinedTermBase term: definedTermBases){
 204                     dtos.add(TermDto.fromTerm(term));
 205                 }
 206                 CdmStore.getTermManager().setPreferredTermsByType(dtos, TermType.NomenclaturalStatusType);
 207             }
 208         }
 209     }
 210
 211
 212
 213     public CdmPreference findBestMatching(PrefKey key) {
 214         List<CdmPreference> allPrefs = new ArrayList();
 215         for (String predicate: preferenceCache.keySet()){
 216             allPrefs.addAll(preferenceCache.get(predicate));
 217         }
 218        return PreferenceResolver.resolve(allPrefs, key);
 219
 220     }
 221
 222 }