}
if (featureTree == null) {
- featureTree = TermEditorInput.getDefaultFeatureTree();
+ featureTree = TermEditorInput.getPreferredTaxonFeatureTree(false);
}
if (description instanceof TaxonNameDescription){
- featureTree = TermEditorInput.getPreferredNameFeatureTree();
+ featureTree = TermEditorInput.getPreferredNameFeatureTree(false);
}
\r
page.name.59 = Name Features\r
page.name.60 = Name Features\r
+page.name.160 = Taxon Features\r
page.name.61 = Name Details View
command.commandname.20 = Structure Tree (OWL)
command.commandname.21 = OWL Term Export
page.name.59 = Namensmerkmale
page.name.60 = Namensmerkmale
+page.name.160 = Taxon Merkmale
page.name.61 = Name Details View
command.commandname.20 = Struktur-Baum (OWL)
command.commandname.21 = OWL-Term-Export
id="eu.etaxonomy.taxeditor.preferences.feature"
name="%page.name.1">
</page>
- <page
+ <!--<page
category="eu.etaxonomy.taxeditor.preferences.description"
class="eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreferences"
id="eu.etaxonomy.taxeditor.preferences.nameFeature"
name="%page.name.59">
- </page>
+ </page>-->
<!--<page
category="eu.etaxonomy.taxeditor.preferences.description"
class="eu.etaxonomy.taxeditor.preference.menu.PresenceAbsenceMenuPreferences"
id="eu.etaxonomy.taxeditor.preferences.defaultFeatureTreePreferenecs"
name="%page.name.22">
</page>
+ <page
+ category="eu.etaxonomy.taxeditor.preferences.description"
+ class="eu.etaxonomy.taxeditor.preference.CommonNameVocabularyPreference"
+ id="eu.etaxonomy.taxeditor.store.vocabularyPreference"
+ name="%page.name.47">
+ </page>
<page
category="eu.etaxonomy.taxeditor.preference.defaultlanguagepditorpreferencePage"
class="eu.etaxonomy.taxeditor.preference.LanguageRepresentationPreferencePage"
id="eu.etaxonomy.taxeditor.preferences.description"
name="%page.name.0">
</page>
+
<page
category="eu.etaxonomy.taxeditor.preferences.description"
- class="eu.etaxonomy.taxeditor.preference.menu.FeatureMenuAdminPreferences"
- id="eu.etaxonomy.taxeditor.preferences.feature"
- name="%page.name.1">
+ class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.NameFeatureAdminMenuPreference"
+ id="eu.etaxonomy.taxeditor.preferences.nameAdminFeature"
+ name="%page.name.59">
</page>
- <page
category="eu.etaxonomy.taxeditor.preferences.description"
- class="eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuAdminPreferences"
- id="eu.etaxonomy.taxeditor.preferences.nameFeature"
- name="%page.name.59">
+ class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.FeatureAdminMenuPreference"
+ id="eu.etaxonomy.taxeditor.preferences.adminFeature"
+ name="%page.name.1">
</page>
<page
category="eu.etaxonomy.taxeditor.preferences.description"
name="%page.name.41">
</page>
<page
- category="eu.etaxonomy.taxeditor.preferences.general"
- class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.VocabularyAdminPreferences"
+ category="eu.etaxonomy.taxeditor.preferences.description"
+ class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.CommonNameVocabularyAdminPreference"
id="eu.etaxonomy.taxeditor.store.vocabularyAdminPreference"
name="%page.name.47">
</page>
--- /dev/null
+/**
+* Copyright (C) 2019 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.taxeditor.databaseAdmin.preferencePage;
+
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.taxeditor.preference.menu.FeatureMenuPreferences;
+
+/**
+ * @author k.luther
+ * @since 03.09.2019
+ */
+public class FeatureAdminMenuPreference extends FeatureMenuPreferences {
+ /**
+ * <p>Constructor for FeatureMenuPreference.</p>
+ */
+ public FeatureAdminMenuPreference() {
+ super();
+ setLocalPref(false);
+ setPredicate(PreferencePredicate.TaxonFeatures);
+ type = TermType.Feature;
+ }
+
+ @Override
+ public boolean performOk() {
+ if (!isApply()){
+ return true;
+ }
+ return performOkAdmin();
+ }
+
+
+}
--- /dev/null
+/**
+* Copyright (C) 2019 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.taxeditor.databaseAdmin.preferencePage;
+
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
+import eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreference;
+
+/**
+ * @author k.luther
+ * @since 03.09.2019
+ */
+public class NameFeatureAdminMenuPreference extends NameFeatureMenuPreference {
+
+ /**
+ * <p>Constructor for NameFeatureMenuPreference.</p>
+ */
+ public NameFeatureAdminMenuPreference() {
+ super();
+ setLocalPref(false);
+ setPredicate(PreferencePredicate.NameFeatures);
+ type = TermType.Feature;
+ }
+
+ @Override
+ public boolean performOk() {
+ if (!isApply()){
+ return true;
+ }
+ boolean result = performOkAdmin();
+ if (result){
+ if (result){
+ PreferencesUtil.createPreferredFeatureTreeForNameDescription();
+ }
+ }
+ return result;
+ }
+
+
+}
+++ /dev/null
-/**
-* Copyright (C) 2019 EDIT
-* European Distributed Institute of Taxonomy
-* http://www.e-taxonomy.eu
-*
-* The contents of this file are subject to the Mozilla Public License Version 1.1
-* See LICENSE.TXT at the top of this package for the full license terms.
-*/
-package eu.etaxonomy.taxeditor.databaseAdmin.preferencePage;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.UUID;
-
-import org.apache.commons.lang.StringUtils;
-
-import eu.etaxonomy.cdm.api.service.ITermService;
-import eu.etaxonomy.cdm.model.metadata.CdmPreference;
-import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.persistence.dto.TermDto;
-import eu.etaxonomy.taxeditor.preference.LocalOrDefaultEnum;
-import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
-import eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreference;
-import eu.etaxonomy.taxeditor.store.CdmStore;
-
-/**
- * @author k.luther
- * @since 13.08.2019
- */
-public class NameFeatureMenuAdminPreference extends NameFeatureMenuPreference implements IE4AdminPreferencePage {
-
- @Override
- public boolean performOk() {
- if (!isApply()){
- return true;
- }
- Object[] checkedElements = treeComposite.getViewer().getCheckedElements();
- List<UUID> listUIIDChecked = new ArrayList<>();
- List<DefinedTermBase> preferredTerms = new ArrayList<>();
- for (Object o : checkedElements) {
- if(o instanceof TermDto){
- TermDto termDto = (TermDto) o;
- listUIIDChecked.add(termDto.getUuid());
- preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid()));
- }
- }
- String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$
- if (StringUtils.isBlank(saveCheckedElements)){
- saveCheckedElements = null;
- }
- CdmPreference savePref = CdmPreference.NewTaxEditorInstance(predicate, saveCheckedElements);
- String text = this.useLocalOrAdmin.getText();
- if (text.equals(LocalOrDefaultEnum.Database.getLabel()) ){
- savePref.setAllowOverride(false);
- }else if (text.equals(LocalOrDefaultEnum.AllowOverride.getLabel())){
- savePref.setAllowOverride(true);
- }
-
- PreferencesUtil.setPreferenceToDB(savePref);
- PreferencesUtil.updateDBPreferences();
- PreferencesUtil.firePreferencesChanged(this.getClass());
- return true;
- }
-
-
-}
--- /dev/null
+/**
+* Copyright (C) 2019 EDIT
+* European Distributed Institute of Taxonomy
+* http://www.e-taxonomy.eu
+*
+* The contents of this file are subject to the Mozilla Public License Version 1.1
+* See LICENSE.TXT at the top of this package for the full license terms.
+*/
+package eu.etaxonomy.taxeditor.databaseAdmin.preferencePage;
+
+import eu.etaxonomy.taxeditor.preference.OrderPreferences;
+
+/**
+ * @author k.luther
+ * @since 04.09.2019
+ */
+public class TaxonNodeOrderAdminPreference extends OrderPreferences {
+
+}
public static TermTree getDefaultFeatureTree() {
if(defaultFeatureTree == null) {
List<Feature> features = TermStore.getTerms(Feature.class);
- List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
+ TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+ List<Feature> nameFeatures = new ArrayList(voc.getTerms());
List<Feature> copy = new ArrayList(features);
for (Feature feature: copy){
if (nameFeatures.contains(feature)){
public static TermTree getDefaultNameFeatureTree() {
if(defaultNameFeatureTree == null) {
-
- List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
-
+ TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+ List<Feature> nameFeatures = new ArrayList(voc.getTerms());
+ nameFeatures.remove(Feature.PROTOLOGUE());
+ //List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);
defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);
}
return defaultNameFeatureTree;
/**
* @return
*/
- public static TermTree<?> getPreferredNameFeatureTree() {
+ public static TermTree<?> getPreferredNameFeatureTree(boolean createNew) {
+
+ return PreferencesUtil.getPreferredFeatureTreeForNameDescription(createNew);
+
+ }
+
+ public static TermTree<?> getPreferredTaxonFeatureTree(boolean createNew) {
- return PreferencesUtil.getPreferredFeatureTreeForNameDescription();
+ return PreferencesUtil.getPreferredFeatureTreeForTaxonDescription(createNew);
}
}
public void buildTree(){
List<TermNode> children = featureTree.getRootChildren();
-// if(description.getElements().isEmpty()){
-// return;
-// }
-
for(TermNode featureNode : children){
root.findLeaves(featureNode);
}
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.store.TermStore;
/**
* @author k.luther
}
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
- CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.PresenceAbsenceTerm, null));
+ CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.PresenceAbsenceTerm);
}
}
key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.AvailableRanks);
}
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
- CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.Rank, null));
+ CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.Rank);
}
}
}
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null);
- CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.NomenclaturalStatusType, null));
+ CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.NomenclaturalStatusType);
}
}
}
import eu.etaxonomy.taxeditor.preference.menu.CdmPreferencePage;
import eu.etaxonomy.taxeditor.preference.wizard.CheckBoxTreeComposite;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.store.TermStore;
/**
* @author k.luther
if (listValue.isEmpty()){
List<DefinedTermBase> terms = CdmStore.getTermManager().getAllTerms(type, null);
for (DefinedTermBase term: terms){
- termlist.add(TermDto.fromTerm(term, true));
+ if (!(term instanceof eu.etaxonomy.cdm.model.description.Character)){
+ termlist.add(TermDto.fromTerm(term, true));
+ }
}
}
if (vocabularies.size() == 1){
CdmStore.getTermManager().setPreferredTermsByDto(preferredTermDtos, vocabularies.get(0));
}else{
- CdmStore.getTermManager().setPreferredTerms(preferredTerms, TermStore.getTerms(type, null));
+ CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, type);
+ }
+ PreferencesUtil.firePreferencesChanged(this.getClass());
+ return true;
+ }
+
+ protected boolean performOkAdmin() {
+ Object[] checkedElements = treeComposite.getViewer().getCheckedElements();
+ List<UUID> listUIIDChecked = new ArrayList<>();
+ List<DefinedTermBase> preferredTerms = new ArrayList<>();
+ for (Object o : checkedElements) {
+ if(o instanceof TermDto){
+ TermDto termDto = (TermDto) o;
+ listUIIDChecked.add(termDto.getUuid());
+ preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid()));
+ }
+ }
+ String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$
+ if (StringUtils.isBlank(saveCheckedElements)){
+ saveCheckedElements = null;
+ }
+ CdmPreference savePref = CdmPreference.NewTaxEditorInstance(predicate, saveCheckedElements);
+ String text = this.useLocalOrAdmin.getText();
+ if (text.equals(LocalOrDefaultEnum.Database.getLabel()) ){
+ savePref.setAllowOverride(false);
+ }else if (text.equals(LocalOrDefaultEnum.AllowOverride.getLabel())){
+ savePref.setAllowOverride(true);
}
+
+ PreferencesUtil.setPreferenceToDB(savePref);
+ PreferencesUtil.updateDBPreferences();
PreferencesUtil.firePreferencesChanged(this.getClass());
return true;
}
+
}
this.isAdmin= isAdmin;
this.preferencePage = parentPage;
providerListPreference = PreferencesUtil.getPreferenceFromDB(PreferencePredicate.BioCaseProvider);
- if (!isAdmin && !providerListPreference.isAllowOverride()){
+ if (!isAdmin && providerListPreference != null && !providerListPreference.isAllowOverride()){
Label editingNotAllowed = new Label(parent, style);
editingNotAllowed.setText(Messages.AbcdImportProvider_description_not_available);
return ;
\r
@Override\r
public boolean performOk() {\r
- if (this.orderActivated != null){\r
+ if (isApply()){\r
PreferencesUtil.setSortNodes(this.orderActivated);\r
PreferencesUtil.setStoreNavigatorState(isRestoreTaxonNavigator);\r
MessageDialog.openInformation(getShell(), null, Messages.OrderPreferencePage_PleaseReopenNavigator);\r
import java.util.List;
import java.util.Map;
import java.util.Properties;
+import java.util.Set;
import java.util.StringTokenizer;
import java.util.UUID;
import eu.etaxonomy.cdm.model.term.ISimpleTerm;
import eu.etaxonomy.cdm.model.term.TermBase;
import eu.etaxonomy.cdm.model.term.TermTree;
+import eu.etaxonomy.cdm.model.term.TermType;
+import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.term.VocabularyEnum;
import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.FieldMatcher;
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
import eu.etaxonomy.cdm.strategy.match.MatchException;
import eu.etaxonomy.cdm.strategy.match.MatchMode;
+import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
import eu.etaxonomy.taxeditor.model.AbstractUtility;
import eu.etaxonomy.taxeditor.model.MessagingUtils;
import eu.etaxonomy.taxeditor.model.NomenclaturalCodeHelper;
public static final String P2_REPOSITORY_FIELDS_DELIM = ";";
public static final String SUBJECT_DELIM = "/";
- private static TermTree preferredNameFeatureTree;
+ private static TermTree<Feature> preferredNameFeatureTree;
+
+ private static TermTree<Feature> preferredTaxonFeatureTree;
private final static Logger logger = Logger.getLogger(PreferencesUtil.class);
CdmPreference pref = null;
//
pref = cache.get(name);
- if (pref == null ){
- //get default value for Predicate
- IPreferencePredicate pred = PreferencePredicate.getByKey(name);
- if (pred != null){
- if (pred.getDefaultValue() != null){
- pref = CdmPreference.NewTaxEditorInstance(pred, pred.getDefaultValue().toString());
- }else{
- pref = CdmPreference.NewTaxEditorInstance(pred, null);
- }
- pref.setAllowOverride(true);
- }
- }
+// if (pref == null ){
+// //get default value for Predicate
+// IPreferencePredicate pred = PreferencePredicate.getByKey(name);
+// if (pred != null){
+// if (pred.getDefaultValue() != null){
+// pref = CdmPreference.NewTaxEditorInstance(pred, pred.getDefaultValue().toString());
+// }else{
+// pref = CdmPreference.NewTaxEditorInstance(pred, null);
+// }
+// pref.setAllowOverride(true);
+// }
+// }
return pref;
}
String preferredCode;
if(pref == null || (pref.isAllowOverride() && getBooleanValue(prefOverrideKey(PreferencePredicate.NomenclaturalCode.getKey())))){
preferredCode = getStringValue(
- PreferencePredicate.NomenclaturalCode.getKey(), true);
+ PreferencePredicate.NomenclaturalCode.getKey());
}else{
preferredCode = pref.getValue();
}
TermTree tree = CdmStore.getService(
ITermTreeService.class).load(UUID.fromString(uuidString));
- if (tree.getId() == 0) {
+
+ if (tree == null || tree.getId() == 0) {
return null;
}
return tree;
/**
*
*/
- public static TermTree getPreferredFeatureTreeForNameDescription() {
- if(preferredNameFeatureTree != null){
+ public static TermTree getPreferredFeatureTreeForNameDescription(boolean createNew) {
+ if(preferredNameFeatureTree != null && !createNew){
return preferredNameFeatureTree;
}
createPreferredFeatureTreeForNameDescription();
CdmPreference pref = cache.get(PreferencePredicate.NameFeatures.getKey());
List<Feature> terms;
boolean override = PreferencesUtil.getBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.NameFeatures.getKey()));
- if (pref != null ){
- List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getValue());
+ List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getPredicate());
+ if (uuids != null && !uuids.isEmpty()){
+
terms = CdmStore.getTermManager().getTerms(uuids, Feature.class);
- }else if (override){
- terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
+// }else if (override){
+// List<TermDto> termDtos= CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
+// List<UUID> uuidList = new ArrayList<>();
+//
+// for (Object term: termDtos){
+// if (term instanceof TermDto){
+// uuidList.add(((TermDto)term).getUuid());
+// }
+// }
+// if (!uuidList.isEmpty()){
+// terms = CdmStore.getTermManager().getTerms(uuidList, Feature.class);
+// }else{
+// terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()));
+// }
+//
+
+
}else{
terms = new ArrayList();
terms.addAll(TermStore.getTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null));
+
}
terms.remove(Feature.PROTOLOGUE());
- preferredNameFeatureTree = TermTree.NewInstance(terms);
+ if (terms.isEmpty()){
+ preferredNameFeatureTree = TermEditorInput.getDefaultNameFeatureTree();
+ }else{
+ preferredNameFeatureTree = TermTree.NewInstance(terms);
+ }
}
}
+ /**
+ * @return
+ */
+ public static TermTree<?> getPreferredFeatureTreeForTaxonDescription(boolean createNew) {
+ if(preferredTaxonFeatureTree != null && !createNew){
+ return preferredTaxonFeatureTree;
+ }
+ createPreferredFeatureTreeForTaxonDescription();
+ return preferredTaxonFeatureTree;
+
+ }
+
+ public static void createPreferredFeatureTreeForTaxonDescription() {
+
+ CdmPreferenceCache cache = CdmPreferenceCache.instance();
+ CdmPreference pref = cache.get(PreferencePredicate.TaxonFeatures.getKey());
+ List<Feature> terms;
+ boolean override = PreferencesUtil.getBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.TaxonFeatures.getKey()));
+ if (pref != null && !override){
+ List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getValue());
+ terms = CdmStore.getTermManager().getTerms(uuids, Feature.class);
+ }else if (override){
+ terms= CdmStore.getTermManager().getPreferredTerms(TermType.Feature);
+ TermVocabulary nameVocabulary = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+ Set<Feature> nameFeature = nameVocabulary.getTerms();
+ terms.removeAll(nameFeature);
+
+ }else{
+ terms= CdmStore.getTermManager().getPreferredTerms(TermType.Feature);
+ TermVocabulary nameVocabulary = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());
+ Set<Feature> nameFeature = nameVocabulary.getTerms();
+ terms.removeAll(nameFeature);
+
+ }
+
+ if (terms.isEmpty()){
+ preferredTaxonFeatureTree = TermEditorInput.getDefaultFeatureTree();
+ }else{
+ preferredTaxonFeatureTree = TermTree.NewInstance(terms);
+ }
+
+
+ }
+
+
}
import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
import eu.etaxonomy.taxeditor.store.CdmStore;
-import eu.etaxonomy.taxeditor.store.TermStore;
/**
* @author k.luther
PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.AvailableRanks.getKey()), true);
}
- CdmStore.getTermManager().setPreferredTerms(preferredTerms, TermStore.getTerms(TermType.Rank, null));
+ CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, TermType.Rank);
PreferencesUtil.firePreferencesChanged(this.getClass());
return true;
*/
package eu.etaxonomy.taxeditor.preference.menu;
+import java.util.ArrayList;
+import java.util.List;
+
+import eu.etaxonomy.cdm.api.service.IVocabularyService;
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.taxeditor.l10n.Messages;
+import eu.etaxonomy.cdm.model.term.VocabularyEnum;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput;
+import eu.etaxonomy.taxeditor.preference.GeneralTermPreference;
+import eu.etaxonomy.taxeditor.store.CdmStore;
/**
* <p>FeatureMenuPreferences class.</p>
* @created 17.09.2008
* @version 1.0
*/
-public class FeatureMenuPreferences extends AbstractMenuPreferences<Feature> {
-
- /** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.preferences.feat"{trunked}</code> */
- public static final String PLUGIN_ID = "eu.etaxonomy.taxeditor.preferences.feature"; //$NON-NLS-1$
-
- /**
- * <p>Constructor for FeatureMenuPreferences.</p>
- */
- public FeatureMenuPreferences() {
- super("Feature Preferences", //$NON-NLS-1$
- Messages.FeatureMenuPreferences_display,
- false);
- }
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass()
- */
- /** {@inheritDoc} */
- @Override
- protected TermType getTermType() {
- return TermType.Feature;
- }
+public class FeatureMenuPreferences extends GeneralTermPreference{
+
+ /** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.preferences.feat"{trunked}</code> */
+ public static final String PLUGIN_ID = "eu.etaxonomy.taxeditor.preferences.nameFeature"; //$NON-NLS-1$
+
+ /**
+ * <p>Constructor for FeatureMenuPreference.</p>
+ */
+ public FeatureMenuPreferences() {
+ super();
+ setLocalPref(true);
+ setPredicate(PreferencePredicate.TaxonFeatures);
+ type = TermType.Feature;
+ }
+
+ @Override
+ protected List<TermVocabularyDto> getVocabulariesFromPreference() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+ @Override
+ public boolean performOk(){
+ boolean result = super.performOk();
+ if (result){
+ TermEditorInput.getPreferredTaxonFeatureTree(true);
+ }
+ return true;
+
+ }
+
+ @Override
+ protected void initialiseVocabularies() {
+
+ super.initialiseVocabularies();
+ List<TermVocabularyDto> vocs = new ArrayList<>();
+ vocs.add(CdmStore.getService(IVocabularyService.class).findVocabularyDtoByVocabularyUuid(VocabularyEnum.NameFeature.getUuid()));
+ this.getVocabularies().removeAll(vocs);
+
+ }
+
+
+
}
package eu.etaxonomy.taxeditor.preference.menu;
+import java.util.List;
+
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
-import eu.etaxonomy.taxeditor.l10n.Messages;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.preference.GeneralTermPreference;
/**
* <p>NameTypeDesignationStatusMenuPreferences class.</p>
* @version 1.0
*/
public class NameTypeDesignationStatusMenuPreferences extends
- AbstractMenuPreferences<NameTypeDesignationStatus> {
- /**
- * <p>Constructor for NameTypeDesignationStatusMenuPreferences.</p>
- */
- public NameTypeDesignationStatusMenuPreferences() {
- super("Name Type Designation Status Preferences", //$NON-NLS-1$
- Messages.NameTypeDesignationStatusMenuPreferences_configure,
- false);
- }
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass()
- */
- /** {@inheritDoc} */
- @Override
- protected TermType getTermType() {
- return TermType.NameTypeDesignationStatus;
- }
+ GeneralTermPreference {
+ /**
+ * <p>Constructor for NameTypeDesignationStatusMenuPreferences.</p>
+ */
+ public NameTypeDesignationStatusMenuPreferences() {
+ super();
+ setLocalPref(true);
+ setPredicate(PreferencePredicate.NameTypeDesignationStatus);
+ type = TermType.NameTypeDesignationStatus;
+ }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected List<TermVocabularyDto> getVocabulariesFromPreference() {
+ // TODO Auto-generated method stub
+ return null;
+ }
}
package eu.etaxonomy.taxeditor.preference.menu;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+import org.apache.commons.lang.StringUtils;
+
+import eu.etaxonomy.cdm.api.service.ITermService;
+import eu.etaxonomy.cdm.model.metadata.PreferencePredicate;
+import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermType;
-import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
-import eu.etaxonomy.taxeditor.l10n.Messages;
+import eu.etaxonomy.cdm.persistence.dto.TermDto;
+import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
+import eu.etaxonomy.taxeditor.preference.GeneralTermPreference;
+import eu.etaxonomy.taxeditor.preference.LocalOrDefaultEnum;
+import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
+import eu.etaxonomy.taxeditor.store.CdmStore;
/**
* <p>SpecimenTypeDesignationStatusMenuPreferences class.</p>
* @version 1.0
*/
public class SpecimenTypeDesignationStatusMenuPreferences extends
- AbstractMenuPreferences<SpecimenTypeDesignationStatus> {
- /**
- * <p>Constructor for SpecimenTypeDesignationStatusMenuPreferences.</p>
- */
- public SpecimenTypeDesignationStatusMenuPreferences() {
- super("Specimen Type Designation Status Preferences", //$NON-NLS-1$
- Messages.SpecimenTypeDesignationStatusMenuPreferences_configure,
- false);
- }
-
- /* (non-Javadoc)
- * @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass()
- */
- /** {@inheritDoc} */
- @Override
- protected TermType getTermType() {
- return TermType.SpecimenTypeDesignationStatus;
- }
+ GeneralTermPreference {
+ /**
+ * <p>Constructor for SpecimenTypeDesignationStatusMenuPreferences.</p>
+ */
+ public SpecimenTypeDesignationStatusMenuPreferences() {
+ super();
+ setLocalPref(true);
+ setPredicate(PreferencePredicate.SpecimenTypeDesignationStatus);
+ type = TermType.SpecimenTypeDesignationStatus;
+ }
+
+
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ protected List<TermVocabularyDto> getVocabulariesFromPreference() {
+ // TODO Auto-generated method stub
+ return null;
+ }
+
+
+ @Override
+ public boolean performOk() {
+ if (!isApply()){
+ return true;
+ }
+ Object[] checkedElements = treeComposite.getViewer().getCheckedElements();
+ List<UUID> listUIIDChecked = new ArrayList<>();
+ List<DefinedTermBase> preferredTerms = new ArrayList<>();
+ for (Object o : checkedElements) {
+ if(o instanceof TermDto){
+ TermDto termDto = (TermDto) o;
+ listUIIDChecked.add(termDto.getUuid());
+ preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid()));
+ }
+ }
+ String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$
+
+ PreferencesUtil.setStringValue(PreferencePredicate.SpecimenTypeDesignationStatus.getKey(), saveCheckedElements);
+ String text = this.useLocalOrAdmin.getText();
+ if (text.equals(LocalOrDefaultEnum.Database.getLabel()) || text.equals(LocalOrDefaultEnum.Default.getLabel())){
+ PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.SpecimenTypeDesignationStatus.getKey()), false);
+ }else if (text.equals(LocalOrDefaultEnum.Local.getLabel())){
+ PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.SpecimenTypeDesignationStatus.getKey()), true);
+ }
+
+ CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, TermType.SpecimenTypeDesignationStatus);
+ PreferencesUtil.firePreferencesChanged(this.getClass());
+ return true;
+ }
}
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;
comp = new DefaultTermComparator<T>();
}
List terms = cachedTermMap.get(termVocabulary.getUuid());
+ List<T> termBaseList = new ArrayList();
if(terms==null){
terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,comp)));
cachedTermMap.put(termVocabulary.getUuid(), terms);
+ }else{
+ Iterator iterator = terms.iterator();
+ DefinedTermBase termBase = null;
+ 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));
+ }
+
}
- terms.sort(comp);
+ termBaseList.sort(comp);
+ terms = termBaseList;
return terms;
}
/**
filteredTerms.add(term);
}
}
+ if (filteredTerms.isEmpty()){
+ return initialTerms;
+ }
return filteredTerms;
}
}
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 <T extends DefinedTermBase> void setPreferredTermsByType(Collection<T> preferredTerms, TermType type){
+
+
+ Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
+ List<DefinedTermBase> oldValues = getPreferredTerms(type);
+ for (DefinedTermBase term: oldValues){
+ PreferencesUtil.setBooleanValue(getPrefName(term), false);
+ }
+ for(TermBase term : preferredTerms){
+ PreferencesUtil.setBooleanValue(getPrefName(term), true);
+
+ }
+
+ clearTermMapForTermType(type);
+
+
+
+ }
/**
* Generic method to set term preferences
*
Collection<UUID> undesiredTermUuids = new ArrayList<UUID>();
- for(TermDto term : vocDto.getTerms()){
+ for(TermDto term : preferredTerms){
if(!preferredTerms.contains(term)){
undesiredTermUuids.add(term.getUuid());
PreferencesUtil.setBooleanValue(getPrefNameByDto(term), false);
}
//if (initialTerms.iterator().hasNext()){
clearTermMapForTermVoc(vocDto.getUuid());
+ List<TermDto> list = new ArrayList<>(preferredTerms);
+ cachedTermMap.put(vocDto.getUuid(), list);
//}
}
import org.eclipse.swt.events.SelectionListener;
-import eu.etaxonomy.cdm.api.service.IVocabularyService;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
-import eu.etaxonomy.cdm.model.term.TermVocabulary;
-import eu.etaxonomy.cdm.model.term.VocabularyEnum;
-import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.taxeditor.ui.combo.term.TermComboElement;
import eu.etaxonomy.taxeditor.ui.element.AbstractFormSection;
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;
/** {@inheritDoc} */
@Override
public void createControls(ICdmFormElement element, int style) {
- TermVocabulary vocabulary = CdmStore.getService(IVocabularyService.class).find(VocabularyEnum.NomenclaturalStatusType.getUuid());
+ //TermVocabulary vocabulary = CdmStore.getService(IVocabularyService.class).find(VocabularyEnum.NomenclaturalStatusType.getUuid());
Comparator<NomenclaturalStatusType> termComparator= new Comparator<NomenclaturalStatusType>() {
}
};
- nomenclaturalStatusTypeCombo = formFactory.createDefinedTermComboElement(vocabulary, this, "Status", null,true, style, true);
+ nomenclaturalStatusTypeCombo = formFactory.createDefinedTermComboElement(TermType.NomenclaturalStatusType, this, "Status", null,true, style, true);
nomenclaturalStatusTypeCombo.setTermComparator(termComparator);
ruleConsideredText = formFactory.createTextWithLabelElement(this, "Rule Considered", "", style);
BGBM BDI Projects / taxeditor.git / commitdiff