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.HashSet;
  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
  20 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  21 import eu.etaxonomy.cdm.model.common.TermBase;
  22 import eu.etaxonomy.cdm.model.description.Feature;
  23 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  24 import eu.etaxonomy.cdm.model.name.BotanicalName;
  25 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  26 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  27 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  28 import eu.etaxonomy.cdm.model.name.NonViralName;
  29 import eu.etaxonomy.cdm.model.name.Rank;
  30 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  31 import eu.etaxonomy.cdm.model.name.ZoologicalName;
  32 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  33 import eu.etaxonomy.taxeditor.model.Resources;
  34 import eu.etaxonomy.taxeditor.store.VocabularyStore;
  35 import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
  36
  37 /**
  38  * @author p.ciardelli
  39  * @created 05.12.2008
  40  * @version 1.0
  41  * @author n.hoffmann
  42  */
  43 public class PreferencesUtil {
  44         private static final Logger logger = Logger
  45                         .getLogger(PreferencesUtil.class);
  46
  47         /**
  48          *
  49          * @return
  50          */
  51         public static IPreferenceStore getPreferenceStore() {
  52                 return TaxeditorStorePlugin.getDefault().getPreferenceStore();
  53         }
  54
  55         /**
  56          *
  57          * @return
  58          */
  59         private static String getNameCodePreference() {
  60                 try{
  61                         return getPreferenceStore().getString(Resources.CODE_PREFERENCE);
  62                 }catch(NullPointerException e){
  63                         logger.warn("PreferenceStore was not available. That is OK if you are running a unit test. Setting ICBN as default code.");
  64                         return Resources.CODE_PREFERENCE_ICBN;
  65                 }
  66         }
  67
  68         /**
  69          *
  70          * @param preferredCode
  71          */
  72         public static void setNomenclaturalCode(String preferredCode) {
  73                 getPreferenceStore().setValue(Resources.CODE_PREFERENCE, preferredCode);
  74         }
  75
  76         /**
  77          *
  78          */
  79         public static void setDefaultNomenclaturalCode() {
  80                 setNomenclaturalCode(Resources.DEFAULT_CODE_PREFERENCE);
  81         }
  82
  83         /**
  84          *
  85          * @return
  86          */
  87         public static String getPreferredNomenclaturalCodeAsString() {
  88                 String nameCodePreference = getNameCodePreference();
  89
  90                 if (nameCodePreference.equals(Resources.CODE_PREFERENCE_ICBN)) {
  91                         return "International Code of Botanical Nomenclature (ICBN)";
  92                 } else if (nameCodePreference.equals(Resources.CODE_PREFERENCE_ICZN)) {
  93                         return "International Code of Zoological Nomenclature (ICZN)";
  94                 }
  95                 return null;
  96         }
  97
  98         /**
  99          * @return
 100          */
 101         public static NomenclaturalCode getPreferredNomenclaturalCode() {
 102
 103                 String nameCodePreference = getNameCodePreference();
 104
 105                 if (nameCodePreference.equals(Resources.CODE_PREFERENCE_ICBN)) {
 106                         return NomenclaturalCode.ICBN;
 107                 } else if (nameCodePreference.equals(Resources.CODE_PREFERENCE_ICZN)) {
 108                         return NomenclaturalCode.ICZN;
 109                 }
 110                 return null;
 111         }
 112
 113
 114         /**
 115          * Returns a new name object that conforms to the nomenclatural
 116          * code specified in user preferences.
 117          *
 118          * @return
 119          */
 120         public static NonViralName<?> getInstanceOfPreferredNameClass() {
 121                 NomenclaturalCode code = getPreferredNomenclaturalCode();
 122
 123                 // Check whether name code preference needs to be initialized
 124                 if (code == null) {
 125                         setDefaultNomenclaturalCode();
 126                 }
 127
 128                 if (code.equals(NomenclaturalCode.ICBN)) {
 129                         return BotanicalName.NewInstance(null);
 130                 } else if (code.equals(NomenclaturalCode.ICZN)) {
 131                         return ZoologicalName.NewInstance(null);
 132                 }
 133                 return NonViralName.NewInstance(null);
 134         }
 135
 136         /**
 137          * Generic method to get term preferences for a term vocabulary
 138          *
 139          * @param <T>
 140          * @param initialTerms
 141          * @return
 142          */
 143         public static <T extends DefinedTermBase> List<T> getPreferredTerms(Set<T> initialTerms){
 144
 145                 // set default for non existent preferences
 146                 defaultTerms(initialTerms);
 147
 148                 List<T> preferredTerms = new ArrayList<T>();
 149
 150                 for (T term : initialTerms){
 151                         if(getPreferenceStore().getBoolean(getPreferenceKey(term))){
 152                                 preferredTerms.add(term);
 153                         }
 154                 }
 155
 156                 return preferredTerms;
 157         }
 158
 159         private static <T extends DefinedTermBase> boolean defaultTerms(Set<T> initialTerms){
 160                 // set default for non existen preferences
 161                 for(T term : initialTerms){
 162                         if(getPreferenceStore().getBoolean(term.getClass().getName())){
 163                                 break;
 164                         }else{
 165                                 getPreferenceStore().setValue(term.getClass().getName(), true);
 166                                 setPreferredTerms(new ArrayList(initialTerms), initialTerms);
 167                                 break;
 168                         }
 169                 }
 170                 return true;
 171         }
 172
 173
 174         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 175         public static List<SpecimenTypeDesignationStatus> getPreferredSpecimenTypeDesignationStatus() { return getPreferredTerms(VocabularyStore.getSpecimenTypeDesignationStatus());}
 176
 177         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 178         public static List<TaxonRelationshipType> getPreferredTaxonRelationshipTypes() { return getPreferredTerms(VocabularyStore.getTaxonRelationshipTypes());}
 179
 180         /** @return a <code>List</code> containing user preferred <code>Feature</code> terms */
 181         public static List<Feature> getPreferredFeatures() { return getPreferredTerms(VocabularyStore.getFeatures());}
 182
 183         /** @return a <code>List</code> containing user preferred <code>Rank</code> terms */
 184         public static List<Rank> getPreferredRanks() { return getPreferredTerms(VocabularyStore.getRanks());}
 185
 186         /** @return a <code>List</code> containing user preferred  <code>PresenceAbsenceTermBase</code> terms */
 187         public static List<PresenceAbsenceTermBase<PresenceAbsenceTermBase<?>>> getPreferredPresenceAbsenceTerms(){ return getPreferredTerms(VocabularyStore.getPresenceAbsenceTerms());}
 188
 189         /** @return a <code>List</code> containing user preferred  <code>NomenclaturalStatusType</code> terms */
 190         public static List<NomenclaturalStatusType> getPreferredNomenclaturalStatusTypes(){     return getPreferredTerms(VocabularyStore.getNomenclaturalStatusTypes());}
 191
 192         /** @return a <code>List</code> containing user preferred  <code>NameRelationshipType</code> terms */
 193         public static List<NameRelationshipType> getPreferredNameRelationshipTypes(){ return getPreferredTerms(VocabularyStore.getNameRelationshipTypes());}
 194
 195
 196         /**
 197          * Generic method to set term preferences
 198          *
 199          * @param preferredTerms
 200          * @param initalTerms
 201          */
 202         public static <T extends DefinedTermBase> void setPreferredTerms(List<T> preferredTerms, Set<T> initalTerms){
 203                 for(TermBase term : initalTerms){
 204                         getPreferenceStore().setValue(getPreferenceKey(term), preferredTerms.contains(term));
 205                 }
 206         }
 207
 208         /**
 209          * Construct a unique key using the terms uuid
 210          *
 211          * @param term
 212          * @return
 213          */
 214         private static String getPreferenceKey(TermBase term) {
 215                 return term.getClass().getName()
 216                                 . concat(".")
 217                                 . concat(term.getUuid().toString());
 218         }
 219 }