taxeditor-store/src/main/java/eu/etaxonomy/taxeditor/preference/PreferencesUtil.java

   1 /**
   2 * Copyright (C) 2007 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
  10 package eu.etaxonomy.taxeditor.preference;
  11
  12 import java.util.ArrayList;
  13 import java.util.Arrays;
  14 import java.util.List;
  15 import java.util.Set;
  16
  17 import org.apache.log4j.Logger;
  18 import org.eclipse.jface.preference.IPreferenceStore;
  19 import org.eclipse.ui.IEditorInput;
  20
  21 import eu.etaxonomy.cdm.api.service.config.ITaxonServiceConfigurator;
  22 import eu.etaxonomy.cdm.api.service.config.impl.TaxonServiceConfiguratorImpl;
  23 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  24 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  25 import eu.etaxonomy.cdm.model.common.ExtensionType;
  26 import eu.etaxonomy.cdm.model.common.ICdmBase;
  27 import eu.etaxonomy.cdm.model.common.IDefinedTerm;
  28 import eu.etaxonomy.cdm.model.common.Language;
  29 import eu.etaxonomy.cdm.model.common.MarkerType;
  30 import eu.etaxonomy.cdm.model.common.TermBase;
  31 import eu.etaxonomy.cdm.model.description.Feature;
  32 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  33 import eu.etaxonomy.cdm.model.media.RightsTerm;
  34 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  35 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  36 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  37 import eu.etaxonomy.cdm.model.name.Rank;
  38 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  39 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  40 import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
  41 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  42 import eu.etaxonomy.cdm.strategy.match.MatchException;
  43 import eu.etaxonomy.cdm.strategy.match.MatchMode;
  44 import eu.etaxonomy.taxeditor.model.NomenclaturalCodeHelper;
  45 import eu.etaxonomy.taxeditor.store.VocabularyStore;
  46 import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
  47
  48 /**
  49  * @author p.ciardelli
  50  * @created 05.12.2008
  51  * @version 1.0
  52  * @author n.hoffmann
  53  */
  54 public class PreferencesUtil {
  55         private static final Logger logger = Logger
  56                         .getLogger(PreferencesUtil.class);
  57
  58         public static final String PREFERRED_NOMENCLATURAL_CODE_KEY = "code";
  59
  60         public static final String TAXON_SERVICE_CONFIGURATOR_TAXA = "taxonServiceConfigurator.doTaxa";
  61         public static final String TAXON_SERVICE_CONFIGURATOR_SYNONYMS = "taxonServiceConfigurator.doSynonyms";
  62         public static final String TAXON_SERVICE_CONFIGURATOR_NAMES = "taxonServiceConfigurator.doNamesWithoutTaxa";
  63         public static final String TAXON_SERVICE_CONFIGURATOR_COMMON_NAMES = "taxonServiceConfigurator.doTaxaByCommonNames";
  64
  65         public static final String SHOW_DATASOURCE_CHOOSER = "dataSourceChooser.show";
  66
  67         public static final String PREFERRED_TERMS_CHANGE = "preferred_terms";
  68
  69         public static final String HIDE_BULKEDITOR_INFO = "bulkeditorInfo.hide";
  70
  71         public static final String EDIT_MARKER_TYPE_PREFIX = "editMarkerType";
  72
  73         public static final String MATCH_STRATEGY_PREFIX = "matchStrategy.";
  74
  75         /**
  76          *
  77          * @return
  78          */
  79         public static IPreferenceStore getPreferenceStore() {
  80                 return TaxeditorStorePlugin.getDefault().getPreferenceStore();
  81         }
  82
  83         /**
  84          *
  85          * @param preferredCode
  86          */
  87         public static void setPreferredNomenclaturalCode(NomenclaturalCode preferredCode) {
  88                 getPreferenceStore().setValue(PREFERRED_NOMENCLATURAL_CODE_KEY, getPreferenceKey(preferredCode));
  89         }
  90
  91         /**
  92          * @return
  93          */
  94         public static NomenclaturalCode getPreferredNomenclaturalCode() {
  95
  96                 for (NomenclaturalCode code : NomenclaturalCodeHelper.getAllCodes()) {
  97                         String preferredCode = getPreferenceStore().getString(PREFERRED_NOMENCLATURAL_CODE_KEY);
  98                         if (getPreferenceKey(code).equals(preferredCode)) {
  99                                 return code;
 100                         }
 101                 }
 102                 return null;
 103         }
 104
 105         /**
 106          * The ability to edit marker types in the BulkEditor is associated with an input type, e.g. references.
 107          *
 108          * @param input
 109          * @param markerType
 110          * @return
 111          */
 112         public static boolean getEditMarkerTypePreference(IEditorInput input, MarkerType markerType) {
 113                 return getPreferenceStore().getBoolean(getEditMarkerTypePrefKey(input, markerType));
 114         }
 115
 116         public static void setEditMarkerTypePreference(IEditorInput input, MarkerType markerType, boolean edit) {
 117                 getPreferenceStore().setValue(getEditMarkerTypePrefKey(input, markerType), edit);
 118         }
 119
 120         private static String getEditMarkerTypePrefKey(IEditorInput input, MarkerType markerType) {
 121                 markerType = (MarkerType) HibernateProxyHelper.deproxy(markerType);
 122                 return EDIT_MARKER_TYPE_PREFIX + "." + input.getClass().getName() + "." + markerType.getUuid().toString();
 123         }
 124
 125         /**
 126          * Get the match strategy for the given class that was stored in preferences
 127          * or the default strategy if it was not stored in preferences
 128          *
 129          * @param clazz
 130          * @return
 131          */
 132         public static IMatchStrategy getMatchStrategy(Class clazz){
 133                 String className = clazz.getName();
 134                 if(getPreferenceStore().getBoolean(MATCH_STRATEGY_PREFIX + className)){
 135                         IMatchStrategy matchStrategy = getDefaultMatchStrategy(clazz);
 136
 137                         for(String fieldName : matchStrategy.getMatchFieldPropertyNames()){
 138                                 String matchModeName = getPreferenceStore().getString(getMatchStrategyFieldName(className, fieldName));
 139                                 MatchMode matchMode = MatchMode.valueOf(matchModeName);
 140                                 try {
 141                                         matchStrategy.setMatchMode(fieldName, matchMode);
 142                                 } catch (MatchException e) {
 143                                         logger.error(e);
 144                                         throw new RuntimeException(e);
 145                                 }
 146                         }
 147
 148                         return matchStrategy;
 149                 }
 150                 return getDefaultMatchStrategy(clazz);
 151         }
 152
 153         /**
 154          * Stores a matchStrategy into the preference store.
 155          *
 156          * @param clazz
 157          */
 158         public static void setMatchStrategy(IMatchStrategy matchStrategy){
 159                 String className = matchStrategy.getMatchClass().getName();
 160                 getPreferenceStore().setValue(MATCH_STRATEGY_PREFIX + className, true);
 161
 162                 Set<String> matchFields = matchStrategy.getMatchFieldPropertyNames();
 163
 164                 for(String fieldName : matchFields){
 165                         getPreferenceStore().setValue(getMatchStrategyFieldName(className, fieldName),
 166                                         matchStrategy.getMatchMode(fieldName).name());
 167                 }
 168         }
 169
 170         /**
 171          * Helper method to create the preference property for a match field.
 172          *
 173          * @param className
 174          * @param fieldName
 175          * @return
 176          */
 177         private static String getMatchStrategyFieldName(String className, String fieldName){
 178                 return MATCH_STRATEGY_PREFIX + className  + "." +  fieldName;
 179         }
 180
 181         /**
 182          * Returns the default match strategy for a given class.
 183          *
 184          * @param clazz
 185          * @return
 186          */
 187         public static IMatchStrategy getDefaultMatchStrategy(Class clazz){
 188                 return DefaultMatchStrategy.NewInstance(clazz);
 189         }
 190
 191         /**
 192          * Generic method to get term preferences for a term vocabulary
 193          *
 194          * @param <T>
 195          * @param initialTerms
 196          * @return
 197          */
 198         public static <T extends DefinedTermBase> List<T> getPreferredTerms(Set<T> initialTerms){
 199
 200                 // set default for non existent preferences
 201                 defaultTerms(initialTerms);
 202
 203                 List<T> preferredTerms = new ArrayList<T>();
 204
 205                 for (T term : initialTerms){
 206                         if(getPreferenceStore().getBoolean(getPreferenceKey((ICdmBase) term))){
 207                                 preferredTerms.add(term);
 208                         }
 209                 }
 210
 211                 return preferredTerms;
 212         }
 213
 214         private static <T extends DefinedTermBase> boolean defaultTerms(Set<T> initialTerms){
 215                 // set default for non existen preferences
 216                 for(T term : initialTerms){
 217                         if(getPreferenceStore().getBoolean(term.getClass().getName())){
 218                                 break;
 219                         }else{
 220                                 getPreferenceStore().setValue(term.getClass().getName(), true);
 221                                 setPreferredTerms(new ArrayList(initialTerms), initialTerms);
 222                                 break;
 223                         }
 224                 }
 225                 return true;
 226         }
 227
 228
 229         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 230         public static List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getPreferredTerms(VocabularyStore.getSpecimenTypeDesignationStatus());}
 231
 232         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 233         public static List<SpecimenTypeDesignationStatus> getPreferredNameTypeDesignationStatus() { return getPreferredTerms(VocabularyStore.getNameTypeDesignationStatus());}
 234
 235         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 236         public static List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getPreferredTerms(VocabularyStore.getTaxonRelationshipTypes());}
 237
 238         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 239         public static List<Feature> getPreferredFeatures() { return getPreferredTerms(VocabularyStore.getFeatures());}
 240
 241         /** @return a <code>List</code> containing user preferred <code>Rank</code> terms */
 242         public static List<Rank> getPreferredRanks() { return getPreferredTerms(VocabularyStore.getRanks());}
 243
 244         /** @return a <code>List</code> containing user preferred  <code>PresenceAbsenceTermBase</code> terms */
 245         public static List<PresenceAbsenceTermBase<PresenceAbsenceTermBase<?>>> getPreferredPresenceAbsenceTerms(){ return getPreferredTerms(VocabularyStore.getPresenceAbsenceTerms());}
 246
 247         /** @return a <code>List</code> containing user preferred  <code>NomenclaturalStatusType</code> terms */
 248         public static List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){     return getPreferredTerms(VocabularyStore.getNomenclaturalStatusTypes());}
 249
 250         /** @return a <code>List</code> containing user preferred  <code>NameRelationshipType</code> terms */
 251         public static List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getPreferredTerms(VocabularyStore.getNameRelationshipTypes());}
 252
 253         /** @return a <code>List</code> containing user preferred  <code>Language</code> terms */
 254         public static List<Language> getPreferredLanguages() { return getPreferredTerms(VocabularyStore.getLanguages()); }
 255
 256         /** @return a <code>List</code> containing user preferred  <code>MarkerType</code> terms */
 257         public static List<MarkerType> getPreferredMarkerTypes() { return getPreferredTerms(VocabularyStore.getNonTechnicalMarkerTypes()); }
 258
 259         /** @return a <code>List</code> containing user preferred  <code>ExtensionType</code> terms */
 260         public static List<ExtensionType> getPreferredExtensionTypes() { return getPreferredTerms(VocabularyStore.getExtensionTypes()); }
 261
 262         /** @return     a <code>List</code> containing user preferred  <code>RightsType</code> terms  */
 263         public static List<RightsTerm> getPreferredRightsTypes() {      return getPreferredTerms(VocabularyStore.getRightsTypes());}
 264
 265
 266         /**
 267          * Generic method to set term preferences
 268          *
 269          * @param preferredTerms
 270          * @param initialTerms
 271          */
 272         public static <T extends DefinedTermBase> void setPreferredTerms(List<T> preferredTerms, Set<T> initialTerms){
 273                 for(TermBase term : initialTerms){
 274                         getPreferenceStore().setValue(getPreferenceKey(term), preferredTerms.contains(term));
 275                 }
 276         }
 277
 278         /**
 279          * Construct a unique key using the CdmBase object's uuid
 280          *
 281          * @param cdmBase
 282          * @return
 283          */
 284         private static String getPreferenceKey(ICdmBase cdmBase) {
 285                 cdmBase = (ICdmBase) HibernateProxyHelper.deproxy(cdmBase);
 286
 287                 String key = cdmBase.getClass().getName()
 288                                 . concat(".")
 289                                 . concat(cdmBase.getUuid().toString());
 290                 if (key.contains("javassist")) {
 291                         logger.info("proxy");
 292                 }
 293                 return key;
 294         }
 295
 296         /**
 297          * Construct a unique key using the CdmBase object's uuid
 298          *
 299          * @param cdmBase
 300          * @return
 301          */
 302         private static String getPreferenceKey(IDefinedTerm definedTerm) {
 303                 definedTerm = (IDefinedTerm) HibernateProxyHelper.deproxy(definedTerm);
 304                 String key = definedTerm.getClass().getName()
 305                                 . concat(".")
 306                                 . concat(definedTerm.getUuid().toString());
 307                 if (key.contains("javassist")) {
 308                         logger.warn("Trying to persist a preference based on a proxy class.");
 309                 }
 310                 return key;
 311         }
 312
 313         /**
 314          * Retrieves search preferences from the preference store
 315          *
 316          * @return an <code>ITaxonServiceConfigurator</code> to pass to search methods
 317          */
 318         public static ITaxonServiceConfigurator getSearchConfigurator() {
 319                 ITaxonServiceConfigurator configurator = initializeSearchConfigurator();
 320
 321                 configurator.setDoTaxa(getPreferenceStore().getBoolean(TAXON_SERVICE_CONFIGURATOR_TAXA));
 322                 configurator.setDoSynonyms(getPreferenceStore().getBoolean(TAXON_SERVICE_CONFIGURATOR_SYNONYMS));
 323                 configurator.setDoNamesWithoutTaxa(getPreferenceStore().getBoolean(TAXON_SERVICE_CONFIGURATOR_NAMES));
 324                 configurator.setDoTaxaByCommonNames(getPreferenceStore().getBoolean(TAXON_SERVICE_CONFIGURATOR_COMMON_NAMES));
 325
 326                 return configurator;
 327         }
 328
 329         /**
 330          * create new preferences, setting all search options to true
 331          * @return
 332          */
 333         public static ITaxonServiceConfigurator initializeSearchConfigurator(){
 334                 ITaxonServiceConfigurator configurator = TaxonServiceConfiguratorImpl.NewInstance();
 335
 336                 configurator.setDoTaxa(true);
 337                 configurator.setDoSynonyms(true);
 338                 configurator.setDoNamesWithoutTaxa(true);
 339                 configurator.setDoTaxaByCommonNames(true);
 340
 341                 configurator.setTaxonPropertyPath(Arrays.asList("$",
 342                                 "titleCache", "name", "name.$"));
 343
 344                 // DEFAULT VALUES
 345                 // match mode default only
 346                 configurator.setMatchMode(eu.etaxonomy.cdm.persistence.query.MatchMode.BEGINNING);
 347                 // i don't know what happens to sec at the moment
 348                 configurator.setSec(null);
 349                 // we set page number and size here as this should always be unlimited
 350                 configurator.setPageNumber(0);
 351                 // TODO currently limit results to 10000
 352                 configurator.setPageSize(10000);
 353
 354                 return configurator;
 355         }
 356
 357         /**
 358          * Store search preferences
 359          *
 360          * @param configurator
 361          */
 362         public static void setSearchConfigurator(ITaxonServiceConfigurator configurator){
 363                 getPreferenceStore().setValue(TAXON_SERVICE_CONFIGURATOR_TAXA, configurator.isDoTaxa());
 364                 getPreferenceStore().setValue(TAXON_SERVICE_CONFIGURATOR_SYNONYMS, configurator.isDoSynonyms());
 365                 getPreferenceStore().setValue(TAXON_SERVICE_CONFIGURATOR_NAMES, configurator.isDoNamesWithoutTaxa());
 366                 getPreferenceStore().setValue(TAXON_SERVICE_CONFIGURATOR_COMMON_NAMES, configurator.isDoTaxaByCommonNames());
 367         }
 368
 369         /**
 370          * @param class1
 371          */
 372         public static void firePreferencesChanged(Class clazz) {
 373                 getPreferenceStore().firePropertyChangeEvent(PREFERRED_TERMS_CHANGE, null, clazz);
 374         }
 375
 376         /**
 377          * Set default values for preferences
 378          */
 379         public static void setDefaults() {
 380                 getPreferenceStore().setDefault(TAXON_SERVICE_CONFIGURATOR_TAXA, true);
 381                 getPreferenceStore().setDefault(TAXON_SERVICE_CONFIGURATOR_SYNONYMS, true);
 382         }
 383 }