Revision 8a7e7d33
Added by Katja Luther over 4 years ago
| eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/descriptive/e4/handler/DynamicFeatureMenuE4.java | ||
|---|---|---|
| 134 | 134 |
} |
| 135 | 135 |
|
| 136 | 136 |
if (featureTree == null) {
|
| 137 |
featureTree = TermEditorInput.getDefaultFeatureTree();
|
|
| 137 |
featureTree = TermEditorInput.getPreferredTaxonFeatureTree(false);
|
|
| 138 | 138 |
} |
| 139 | 139 |
if (description instanceof TaxonNameDescription){
|
| 140 |
featureTree = TermEditorInput.getPreferredNameFeatureTree(); |
|
| 140 |
featureTree = TermEditorInput.getPreferredNameFeatureTree(false);
|
|
| 141 | 141 |
|
| 142 | 142 |
} |
| 143 | 143 |
|
| eu.etaxonomy.taxeditor.store/OSGI-INF/l10n/bundle.properties | ||
|---|---|---|
| 270 | 270 |
|
| 271 | 271 |
page.name.59 = Name Features |
| 272 | 272 |
page.name.60 = Name Features |
| 273 |
page.name.160 = Taxon Features |
|
| 273 | 274 |
page.name.61 = Name Details View |
| 274 | 275 |
command.commandname.20 = Structure Tree (OWL) |
| 275 | 276 |
command.commandname.21 = OWL Term Export |
| eu.etaxonomy.taxeditor.store/OSGI-INF/l10n/bundle_de.properties | ||
|---|---|---|
| 270 | 270 |
|
| 271 | 271 |
page.name.59 = Namensmerkmale |
| 272 | 272 |
page.name.60 = Namensmerkmale |
| 273 |
page.name.160 = Taxon Merkmale |
|
| 273 | 274 |
page.name.61 = Name Details View |
| 274 | 275 |
command.commandname.20 = Struktur-Baum (OWL) |
| 275 | 276 |
command.commandname.21 = OWL-Term-Export |
| eu.etaxonomy.taxeditor.store/plugin.xml | ||
|---|---|---|
| 428 | 428 |
id="eu.etaxonomy.taxeditor.preferences.feature" |
| 429 | 429 |
name="%page.name.1"> |
| 430 | 430 |
</page> |
| 431 |
<page |
|
| 431 |
<!--<page
|
|
| 432 | 432 |
category="eu.etaxonomy.taxeditor.preferences.description" |
| 433 | 433 |
class="eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreferences" |
| 434 | 434 |
id="eu.etaxonomy.taxeditor.preferences.nameFeature" |
| 435 | 435 |
name="%page.name.59"> |
| 436 |
</page> |
|
| 436 |
</page>-->
|
|
| 437 | 437 |
<!--<page |
| 438 | 438 |
category="eu.etaxonomy.taxeditor.preferences.description" |
| 439 | 439 |
class="eu.etaxonomy.taxeditor.preference.menu.PresenceAbsenceMenuPreferences" |
| ... | ... | |
| 560 | 560 |
id="eu.etaxonomy.taxeditor.preferences.defaultFeatureTreePreferenecs" |
| 561 | 561 |
name="%page.name.22"> |
| 562 | 562 |
</page> |
| 563 |
<page |
|
| 564 |
category="eu.etaxonomy.taxeditor.preferences.description" |
|
| 565 |
class="eu.etaxonomy.taxeditor.preference.CommonNameVocabularyPreference" |
|
| 566 |
id="eu.etaxonomy.taxeditor.store.vocabularyPreference" |
|
| 567 |
name="%page.name.47"> |
|
| 568 |
</page> |
|
| 563 | 569 |
<page |
| 564 | 570 |
category="eu.etaxonomy.taxeditor.preference.defaultlanguagepditorpreferencePage" |
| 565 | 571 |
class="eu.etaxonomy.taxeditor.preference.LanguageRepresentationPreferencePage" |
| ... | ... | |
| 732 | 738 |
id="eu.etaxonomy.taxeditor.preferences.description" |
| 733 | 739 |
name="%page.name.0"> |
| 734 | 740 |
</page> |
| 741 |
|
|
| 735 | 742 |
<page |
| 736 | 743 |
category="eu.etaxonomy.taxeditor.preferences.description" |
| 737 |
class="eu.etaxonomy.taxeditor.preference.menu.FeatureMenuAdminPreferences"
|
|
| 738 |
id="eu.etaxonomy.taxeditor.preferences.feature"
|
|
| 739 |
name="%page.name.1">
|
|
| 744 |
class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.NameFeatureAdminMenuPreference"
|
|
| 745 |
id="eu.etaxonomy.taxeditor.preferences.nameAdminFeature"
|
|
| 746 |
name="%page.name.59">
|
|
| 740 | 747 |
</page> |
| 741 |
<page |
|
| 748 |
<page
|
|
| 742 | 749 |
category="eu.etaxonomy.taxeditor.preferences.description" |
| 743 |
class="eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuAdminPreferences"
|
|
| 744 |
id="eu.etaxonomy.taxeditor.preferences.nameFeature"
|
|
| 745 |
name="%page.name.59">
|
|
| 750 |
class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.FeatureAdminMenuPreference"
|
|
| 751 |
id="eu.etaxonomy.taxeditor.preferences.adminFeature"
|
|
| 752 |
name="%page.name.1">
|
|
| 746 | 753 |
</page> |
| 747 | 754 |
<page |
| 748 | 755 |
category="eu.etaxonomy.taxeditor.preferences.description" |
| ... | ... | |
| 799 | 806 |
name="%page.name.41"> |
| 800 | 807 |
</page> |
| 801 | 808 |
<page |
| 802 |
category="eu.etaxonomy.taxeditor.preferences.general"
|
|
| 803 |
class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.VocabularyAdminPreferences"
|
|
| 809 |
category="eu.etaxonomy.taxeditor.preferences.description"
|
|
| 810 |
class="eu.etaxonomy.taxeditor.databaseAdmin.preferencePage.CommonNameVocabularyAdminPreference"
|
|
| 804 | 811 |
id="eu.etaxonomy.taxeditor.store.vocabularyAdminPreference" |
| 805 | 812 |
name="%page.name.47"> |
| 806 | 813 |
</page> |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/preferencePage/FeatureAdminMenuPreference.java | ||
|---|---|---|
| 1 |
/** |
|
| 2 |
* Copyright (C) 2019 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.databaseAdmin.preferencePage; |
|
| 10 |
|
|
| 11 |
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate; |
|
| 12 |
import eu.etaxonomy.cdm.model.term.TermType; |
|
| 13 |
import eu.etaxonomy.taxeditor.preference.menu.FeatureMenuPreferences; |
|
| 14 |
|
|
| 15 |
/** |
|
| 16 |
* @author k.luther |
|
| 17 |
* @since 03.09.2019 |
|
| 18 |
*/ |
|
| 19 |
public class FeatureAdminMenuPreference extends FeatureMenuPreferences {
|
|
| 20 |
/** |
|
| 21 |
* <p>Constructor for FeatureMenuPreference.</p> |
|
| 22 |
*/ |
|
| 23 |
public FeatureAdminMenuPreference() {
|
|
| 24 |
super(); |
|
| 25 |
setLocalPref(false); |
|
| 26 |
setPredicate(PreferencePredicate.TaxonFeatures); |
|
| 27 |
type = TermType.Feature; |
|
| 28 |
} |
|
| 29 |
|
|
| 30 |
@Override |
|
| 31 |
public boolean performOk() {
|
|
| 32 |
if (!isApply()){
|
|
| 33 |
return true; |
|
| 34 |
} |
|
| 35 |
return performOkAdmin(); |
|
| 36 |
} |
|
| 37 |
|
|
| 38 |
|
|
| 39 |
} |
|
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/preferencePage/NameFeatureAdminMenuPreference.java | ||
|---|---|---|
| 1 |
/** |
|
| 2 |
* Copyright (C) 2019 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.databaseAdmin.preferencePage; |
|
| 10 |
|
|
| 11 |
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate; |
|
| 12 |
import eu.etaxonomy.cdm.model.term.TermType; |
|
| 13 |
import eu.etaxonomy.taxeditor.preference.PreferencesUtil; |
|
| 14 |
import eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreference; |
|
| 15 |
|
|
| 16 |
/** |
|
| 17 |
* @author k.luther |
|
| 18 |
* @since 03.09.2019 |
|
| 19 |
*/ |
|
| 20 |
public class NameFeatureAdminMenuPreference extends NameFeatureMenuPreference {
|
|
| 21 |
|
|
| 22 |
/** |
|
| 23 |
* <p>Constructor for NameFeatureMenuPreference.</p> |
|
| 24 |
*/ |
|
| 25 |
public NameFeatureAdminMenuPreference() {
|
|
| 26 |
super(); |
|
| 27 |
setLocalPref(false); |
|
| 28 |
setPredicate(PreferencePredicate.NameFeatures); |
|
| 29 |
type = TermType.Feature; |
|
| 30 |
} |
|
| 31 |
|
|
| 32 |
@Override |
|
| 33 |
public boolean performOk() {
|
|
| 34 |
if (!isApply()){
|
|
| 35 |
return true; |
|
| 36 |
} |
|
| 37 |
boolean result = performOkAdmin(); |
|
| 38 |
if (result){
|
|
| 39 |
if (result){
|
|
| 40 |
PreferencesUtil.createPreferredFeatureTreeForNameDescription(); |
|
| 41 |
} |
|
| 42 |
} |
|
| 43 |
return result; |
|
| 44 |
} |
|
| 45 |
|
|
| 46 |
|
|
| 47 |
} |
|
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/preferencePage/NameFeatureMenuAdminPreference.java | ||
|---|---|---|
| 1 |
/** |
|
| 2 |
* Copyright (C) 2019 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.databaseAdmin.preferencePage; |
|
| 10 |
|
|
| 11 |
import java.util.ArrayList; |
|
| 12 |
import java.util.List; |
|
| 13 |
import java.util.UUID; |
|
| 14 |
|
|
| 15 |
import org.apache.commons.lang.StringUtils; |
|
| 16 |
|
|
| 17 |
import eu.etaxonomy.cdm.api.service.ITermService; |
|
| 18 |
import eu.etaxonomy.cdm.model.metadata.CdmPreference; |
|
| 19 |
import eu.etaxonomy.cdm.model.term.DefinedTermBase; |
|
| 20 |
import eu.etaxonomy.cdm.persistence.dto.TermDto; |
|
| 21 |
import eu.etaxonomy.taxeditor.preference.LocalOrDefaultEnum; |
|
| 22 |
import eu.etaxonomy.taxeditor.preference.PreferencesUtil; |
|
| 23 |
import eu.etaxonomy.taxeditor.preference.menu.NameFeatureMenuPreference; |
|
| 24 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
|
| 25 |
|
|
| 26 |
/** |
|
| 27 |
* @author k.luther |
|
| 28 |
* @since 13.08.2019 |
|
| 29 |
*/ |
|
| 30 |
public class NameFeatureMenuAdminPreference extends NameFeatureMenuPreference implements IE4AdminPreferencePage {
|
|
| 31 |
|
|
| 32 |
@Override |
|
| 33 |
public boolean performOk() {
|
|
| 34 |
if (!isApply()){
|
|
| 35 |
return true; |
|
| 36 |
} |
|
| 37 |
Object[] checkedElements = treeComposite.getViewer().getCheckedElements(); |
|
| 38 |
List<UUID> listUIIDChecked = new ArrayList<>(); |
|
| 39 |
List<DefinedTermBase> preferredTerms = new ArrayList<>(); |
|
| 40 |
for (Object o : checkedElements) {
|
|
| 41 |
if(o instanceof TermDto){
|
|
| 42 |
TermDto termDto = (TermDto) o; |
|
| 43 |
listUIIDChecked.add(termDto.getUuid()); |
|
| 44 |
preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid())); |
|
| 45 |
} |
|
| 46 |
} |
|
| 47 |
String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$ |
|
| 48 |
if (StringUtils.isBlank(saveCheckedElements)){
|
|
| 49 |
saveCheckedElements = null; |
|
| 50 |
} |
|
| 51 |
CdmPreference savePref = CdmPreference.NewTaxEditorInstance(predicate, saveCheckedElements); |
|
| 52 |
String text = this.useLocalOrAdmin.getText(); |
|
| 53 |
if (text.equals(LocalOrDefaultEnum.Database.getLabel()) ){
|
|
| 54 |
savePref.setAllowOverride(false); |
|
| 55 |
}else if (text.equals(LocalOrDefaultEnum.AllowOverride.getLabel())){
|
|
| 56 |
savePref.setAllowOverride(true); |
|
| 57 |
} |
|
| 58 |
|
|
| 59 |
PreferencesUtil.setPreferenceToDB(savePref); |
|
| 60 |
PreferencesUtil.updateDBPreferences(); |
|
| 61 |
PreferencesUtil.firePreferencesChanged(this.getClass()); |
|
| 62 |
return true; |
|
| 63 |
} |
|
| 64 |
|
|
| 65 |
|
|
| 66 |
} |
|
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/databaseAdmin/preferencePage/TaxonNodeOrderAdminPreference.java | ||
|---|---|---|
| 1 |
/** |
|
| 2 |
* Copyright (C) 2019 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.databaseAdmin.preferencePage; |
|
| 10 |
|
|
| 11 |
import eu.etaxonomy.taxeditor.preference.OrderPreferences; |
|
| 12 |
|
|
| 13 |
/** |
|
| 14 |
* @author k.luther |
|
| 15 |
* @since 04.09.2019 |
|
| 16 |
*/ |
|
| 17 |
public class TaxonNodeOrderAdminPreference extends OrderPreferences {
|
|
| 18 |
|
|
| 19 |
} |
|
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/editor/definedterm/input/TermEditorInput.java | ||
|---|---|---|
| 102 | 102 |
public static TermTree getDefaultFeatureTree() {
|
| 103 | 103 |
if(defaultFeatureTree == null) {
|
| 104 | 104 |
List<Feature> features = TermStore.getTerms(Feature.class); |
| 105 |
List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null); |
|
| 105 |
TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()); |
|
| 106 |
List<Feature> nameFeatures = new ArrayList(voc.getTerms()); |
|
| 106 | 107 |
List<Feature> copy = new ArrayList(features); |
| 107 | 108 |
for (Feature feature: copy){
|
| 108 | 109 |
if (nameFeatures.contains(feature)){
|
| ... | ... | |
| 116 | 117 |
|
| 117 | 118 |
public static TermTree getDefaultNameFeatureTree() {
|
| 118 | 119 |
if(defaultNameFeatureTree == null) {
|
| 119 |
|
|
| 120 |
List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null); |
|
| 121 |
|
|
| 120 |
TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()); |
|
| 121 |
List<Feature> nameFeatures = new ArrayList(voc.getTerms()); |
|
| 122 |
nameFeatures.remove(Feature.PROTOLOGUE()); |
|
| 123 |
//List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null); |
|
| 122 | 124 |
defaultNameFeatureTree = TermTree.NewInstance(nameFeatures); |
| 123 | 125 |
} |
| 124 | 126 |
return defaultNameFeatureTree; |
| ... | ... | |
| 128 | 130 |
/** |
| 129 | 131 |
* @return |
| 130 | 132 |
*/ |
| 131 |
public static TermTree<?> getPreferredNameFeatureTree() {
|
|
| 133 |
public static TermTree<?> getPreferredNameFeatureTree(boolean createNew) {
|
|
| 134 |
|
|
| 135 |
return PreferencesUtil.getPreferredFeatureTreeForNameDescription(createNew); |
|
| 136 |
|
|
| 137 |
} |
|
| 138 |
|
|
| 139 |
public static TermTree<?> getPreferredTaxonFeatureTree(boolean createNew) {
|
|
| 132 | 140 |
|
| 133 |
return PreferencesUtil.getPreferredFeatureTreeForNameDescription();
|
|
| 141 |
return PreferencesUtil.getPreferredFeatureTreeForTaxonDescription(createNew);
|
|
| 134 | 142 |
|
| 135 | 143 |
} |
| 136 | 144 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/model/FeatureNodeContainerTree.java | ||
|---|---|---|
| 70 | 70 |
public void buildTree(){
|
| 71 | 71 |
List<TermNode> children = featureTree.getRootChildren(); |
| 72 | 72 |
|
| 73 |
// if(description.getElements().isEmpty()){
|
|
| 74 |
// return; |
|
| 75 |
// } |
|
| 76 |
|
|
| 77 | 73 |
for(TermNode featureNode : children){
|
| 78 | 74 |
root.findLeaves(featureNode); |
| 79 | 75 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/CdmPreferenceCache.java | ||
|---|---|---|
| 26 | 26 |
import eu.etaxonomy.cdm.model.term.DefinedTermBase; |
| 27 | 27 |
import eu.etaxonomy.cdm.model.term.TermType; |
| 28 | 28 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
| 29 |
import eu.etaxonomy.taxeditor.store.TermStore; |
|
| 30 | 29 |
|
| 31 | 30 |
/** |
| 32 | 31 |
* @author k.luther |
| ... | ... | |
| 146 | 145 |
} |
| 147 | 146 |
|
| 148 | 147 |
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null); |
| 149 |
CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.PresenceAbsenceTerm, null));
|
|
| 148 |
CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.PresenceAbsenceTerm);
|
|
| 150 | 149 |
} |
| 151 | 150 |
} |
| 152 | 151 |
key = CdmPreference.NewKey(PreferenceSubject.NewTaxEditorInstance(), PreferencePredicate.AvailableRanks); |
| ... | ... | |
| 168 | 167 |
} |
| 169 | 168 |
|
| 170 | 169 |
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null); |
| 171 |
CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.Rank, null));
|
|
| 170 |
CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.Rank);
|
|
| 172 | 171 |
} |
| 173 | 172 |
} |
| 174 | 173 |
|
| ... | ... | |
| 191 | 190 |
} |
| 192 | 191 |
|
| 193 | 192 |
List<DefinedTermBase> definedTermBases = termService.load(uuidList, null); |
| 194 |
CdmStore.getTermManager().setPreferredTerms(definedTermBases, TermStore.getTerms(TermType.NomenclaturalStatusType, null));
|
|
| 193 |
CdmStore.getTermManager().setPreferredTermsByType(definedTermBases, TermType.NomenclaturalStatusType);
|
|
| 195 | 194 |
} |
| 196 | 195 |
} |
| 197 | 196 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/GeneralTermPreference.java | ||
|---|---|---|
| 45 | 45 |
import eu.etaxonomy.taxeditor.preference.menu.CdmPreferencePage; |
| 46 | 46 |
import eu.etaxonomy.taxeditor.preference.wizard.CheckBoxTreeComposite; |
| 47 | 47 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
| 48 |
import eu.etaxonomy.taxeditor.store.TermStore; |
|
| 49 | 48 |
|
| 50 | 49 |
/** |
| 51 | 50 |
* @author k.luther |
| ... | ... | |
| 212 | 211 |
if (listValue.isEmpty()){
|
| 213 | 212 |
List<DefinedTermBase> terms = CdmStore.getTermManager().getAllTerms(type, null); |
| 214 | 213 |
for (DefinedTermBase term: terms){
|
| 215 |
termlist.add(TermDto.fromTerm(term, true)); |
|
| 214 |
if (!(term instanceof eu.etaxonomy.cdm.model.description.Character)){
|
|
| 215 |
termlist.add(TermDto.fromTerm(term, true)); |
|
| 216 |
} |
|
| 216 | 217 |
} |
| 217 | 218 |
} |
| 218 | 219 |
|
| ... | ... | |
| 324 | 325 |
if (vocabularies.size() == 1){
|
| 325 | 326 |
CdmStore.getTermManager().setPreferredTermsByDto(preferredTermDtos, vocabularies.get(0)); |
| 326 | 327 |
}else{
|
| 327 |
CdmStore.getTermManager().setPreferredTerms(preferredTerms, TermStore.getTerms(type, null)); |
|
| 328 |
CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, type); |
|
| 329 |
} |
|
| 330 |
PreferencesUtil.firePreferencesChanged(this.getClass()); |
|
| 331 |
return true; |
|
| 332 |
} |
|
| 333 |
|
|
| 334 |
protected boolean performOkAdmin() {
|
|
| 335 |
Object[] checkedElements = treeComposite.getViewer().getCheckedElements(); |
|
| 336 |
List<UUID> listUIIDChecked = new ArrayList<>(); |
|
| 337 |
List<DefinedTermBase> preferredTerms = new ArrayList<>(); |
|
| 338 |
for (Object o : checkedElements) {
|
|
| 339 |
if(o instanceof TermDto){
|
|
| 340 |
TermDto termDto = (TermDto) o; |
|
| 341 |
listUIIDChecked.add(termDto.getUuid()); |
|
| 342 |
preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid())); |
|
| 343 |
} |
|
| 344 |
} |
|
| 345 |
String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$ |
|
| 346 |
if (StringUtils.isBlank(saveCheckedElements)){
|
|
| 347 |
saveCheckedElements = null; |
|
| 348 |
} |
|
| 349 |
CdmPreference savePref = CdmPreference.NewTaxEditorInstance(predicate, saveCheckedElements); |
|
| 350 |
String text = this.useLocalOrAdmin.getText(); |
|
| 351 |
if (text.equals(LocalOrDefaultEnum.Database.getLabel()) ){
|
|
| 352 |
savePref.setAllowOverride(false); |
|
| 353 |
}else if (text.equals(LocalOrDefaultEnum.AllowOverride.getLabel())){
|
|
| 354 |
savePref.setAllowOverride(true); |
|
| 328 | 355 |
} |
| 356 |
|
|
| 357 |
PreferencesUtil.setPreferenceToDB(savePref); |
|
| 358 |
PreferencesUtil.updateDBPreferences(); |
|
| 329 | 359 |
PreferencesUtil.firePreferencesChanged(this.getClass()); |
| 330 | 360 |
return true; |
| 331 | 361 |
} |
| 362 |
|
|
| 332 | 363 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/ListComponent.java | ||
|---|---|---|
| 72 | 72 |
this.isAdmin= isAdmin; |
| 73 | 73 |
this.preferencePage = parentPage; |
| 74 | 74 |
providerListPreference = PreferencesUtil.getPreferenceFromDB(PreferencePredicate.BioCaseProvider); |
| 75 |
if (!isAdmin && !providerListPreference.isAllowOverride()){
|
|
| 75 |
if (!isAdmin && providerListPreference != null && !providerListPreference.isAllowOverride()){
|
|
| 76 | 76 |
Label editingNotAllowed = new Label(parent, style); |
| 77 | 77 |
editingNotAllowed.setText(Messages.AbcdImportProvider_description_not_available); |
| 78 | 78 |
return ; |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/OrderPreferences.java | ||
|---|---|---|
| 95 | 95 |
|
| 96 | 96 |
@Override |
| 97 | 97 |
public boolean performOk() {
|
| 98 |
if (this.orderActivated != null){
|
|
| 98 |
if (isApply()){
|
|
| 99 | 99 |
PreferencesUtil.setSortNodes(this.orderActivated); |
| 100 | 100 |
PreferencesUtil.setStoreNavigatorState(isRestoreTaxonNavigator); |
| 101 | 101 |
MessageDialog.openInformation(getShell(), null, Messages.OrderPreferencePage_PleaseReopenNavigator); |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/PreferencesUtil.java | ||
|---|---|---|
| 22 | 22 |
import java.util.List; |
| 23 | 23 |
import java.util.Map; |
| 24 | 24 |
import java.util.Properties; |
| 25 |
import java.util.Set; |
|
| 25 | 26 |
import java.util.StringTokenizer; |
| 26 | 27 |
import java.util.UUID; |
| 27 | 28 |
|
| ... | ... | |
| 65 | 66 |
import eu.etaxonomy.cdm.model.term.ISimpleTerm; |
| 66 | 67 |
import eu.etaxonomy.cdm.model.term.TermBase; |
| 67 | 68 |
import eu.etaxonomy.cdm.model.term.TermTree; |
| 69 |
import eu.etaxonomy.cdm.model.term.TermType; |
|
| 70 |
import eu.etaxonomy.cdm.model.term.TermVocabulary; |
|
| 68 | 71 |
import eu.etaxonomy.cdm.model.term.VocabularyEnum; |
| 69 | 72 |
import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy; |
| 70 | 73 |
import eu.etaxonomy.cdm.strategy.match.FieldMatcher; |
| 71 | 74 |
import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; |
| 72 | 75 |
import eu.etaxonomy.cdm.strategy.match.MatchException; |
| 73 | 76 |
import eu.etaxonomy.cdm.strategy.match.MatchMode; |
| 77 |
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput; |
|
| 74 | 78 |
import eu.etaxonomy.taxeditor.model.AbstractUtility; |
| 75 | 79 |
import eu.etaxonomy.taxeditor.model.MessagingUtils; |
| 76 | 80 |
import eu.etaxonomy.taxeditor.model.NomenclaturalCodeHelper; |
| ... | ... | |
| 98 | 102 |
public static final String P2_REPOSITORY_FIELDS_DELIM = ";"; |
| 99 | 103 |
public static final String SUBJECT_DELIM = "/"; |
| 100 | 104 |
|
| 101 |
private static TermTree preferredNameFeatureTree; |
|
| 105 |
private static TermTree<Feature> preferredNameFeatureTree; |
|
| 106 |
|
|
| 107 |
private static TermTree<Feature> preferredTaxonFeatureTree; |
|
| 102 | 108 |
|
| 103 | 109 |
private final static Logger logger = Logger.getLogger(PreferencesUtil.class); |
| 104 | 110 |
|
| ... | ... | |
| 248 | 254 |
CdmPreference pref = null; |
| 249 | 255 |
// |
| 250 | 256 |
pref = cache.get(name); |
| 251 |
if (pref == null ){
|
|
| 252 |
//get default value for Predicate |
|
| 253 |
IPreferencePredicate pred = PreferencePredicate.getByKey(name); |
|
| 254 |
if (pred != null){
|
|
| 255 |
if (pred.getDefaultValue() != null){
|
|
| 256 |
pref = CdmPreference.NewTaxEditorInstance(pred, pred.getDefaultValue().toString()); |
|
| 257 |
}else{
|
|
| 258 |
pref = CdmPreference.NewTaxEditorInstance(pred, null); |
|
| 259 |
} |
|
| 260 |
pref.setAllowOverride(true); |
|
| 261 |
} |
|
| 262 |
} |
|
| 257 |
// if (pref == null ){
|
|
| 258 |
// //get default value for Predicate
|
|
| 259 |
// IPreferencePredicate pred = PreferencePredicate.getByKey(name);
|
|
| 260 |
// if (pred != null){
|
|
| 261 |
// if (pred.getDefaultValue() != null){
|
|
| 262 |
// pref = CdmPreference.NewTaxEditorInstance(pred, pred.getDefaultValue().toString());
|
|
| 263 |
// }else{
|
|
| 264 |
// pref = CdmPreference.NewTaxEditorInstance(pred, null);
|
|
| 265 |
// }
|
|
| 266 |
// pref.setAllowOverride(true);
|
|
| 267 |
// }
|
|
| 268 |
// }
|
|
| 263 | 269 |
return pref; |
| 264 | 270 |
} |
| 265 | 271 |
|
| ... | ... | |
| 480 | 486 |
String preferredCode; |
| 481 | 487 |
if(pref == null || (pref.isAllowOverride() && getBooleanValue(prefOverrideKey(PreferencePredicate.NomenclaturalCode.getKey())))){
|
| 482 | 488 |
preferredCode = getStringValue( |
| 483 |
PreferencePredicate.NomenclaturalCode.getKey(), true);
|
|
| 489 |
PreferencePredicate.NomenclaturalCode.getKey()); |
|
| 484 | 490 |
|
| 485 | 491 |
}else{
|
| 486 | 492 |
preferredCode = pref.getValue(); |
| ... | ... | |
| 982 | 988 |
} |
| 983 | 989 |
TermTree tree = CdmStore.getService( |
| 984 | 990 |
ITermTreeService.class).load(UUID.fromString(uuidString)); |
| 985 |
if (tree.getId() == 0) {
|
|
| 991 |
|
|
| 992 |
if (tree == null || tree.getId() == 0) {
|
|
| 986 | 993 |
return null; |
| 987 | 994 |
} |
| 988 | 995 |
return tree; |
| ... | ... | |
| 1764 | 1771 |
/** |
| 1765 | 1772 |
* |
| 1766 | 1773 |
*/ |
| 1767 |
public static TermTree getPreferredFeatureTreeForNameDescription() {
|
|
| 1768 |
if(preferredNameFeatureTree != null){
|
|
| 1774 |
public static TermTree getPreferredFeatureTreeForNameDescription(boolean createNew) {
|
|
| 1775 |
if(preferredNameFeatureTree != null && !createNew){
|
|
| 1769 | 1776 |
return preferredNameFeatureTree; |
| 1770 | 1777 |
} |
| 1771 | 1778 |
createPreferredFeatureTreeForNameDescription(); |
| ... | ... | |
| 1779 | 1786 |
CdmPreference pref = cache.get(PreferencePredicate.NameFeatures.getKey()); |
| 1780 | 1787 |
List<Feature> terms; |
| 1781 | 1788 |
boolean override = PreferencesUtil.getBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.NameFeatures.getKey())); |
| 1782 |
if (pref != null ){
|
|
| 1783 |
List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getValue()); |
|
| 1789 |
List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getPredicate()); |
|
| 1790 |
if (uuids != null && !uuids.isEmpty()){
|
|
| 1791 |
|
|
| 1784 | 1792 |
terms = CdmStore.getTermManager().getTerms(uuids, Feature.class); |
| 1785 |
}else if (override){
|
|
| 1786 |
terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid())); |
|
| 1793 |
// }else if (override){
|
|
| 1794 |
// List<TermDto> termDtos= CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid())); |
|
| 1795 |
// List<UUID> uuidList = new ArrayList<>(); |
|
| 1796 |
// |
|
| 1797 |
// for (Object term: termDtos){
|
|
| 1798 |
// if (term instanceof TermDto){
|
|
| 1799 |
// uuidList.add(((TermDto)term).getUuid()); |
|
| 1800 |
// } |
|
| 1801 |
// } |
|
| 1802 |
// if (!uuidList.isEmpty()){
|
|
| 1803 |
// terms = CdmStore.getTermManager().getTerms(uuidList, Feature.class); |
|
| 1804 |
// }else{
|
|
| 1805 |
// terms = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid())); |
|
| 1806 |
// } |
|
| 1807 |
// |
|
| 1808 |
|
|
| 1809 |
|
|
| 1787 | 1810 |
}else{
|
| 1788 | 1811 |
terms = new ArrayList(); |
| 1789 | 1812 |
terms.addAll(TermStore.getTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null)); |
| 1813 |
|
|
| 1790 | 1814 |
} |
| 1791 | 1815 |
terms.remove(Feature.PROTOLOGUE()); |
| 1792 |
preferredNameFeatureTree = TermTree.NewInstance(terms); |
|
| 1816 |
if (terms.isEmpty()){
|
|
| 1817 |
preferredNameFeatureTree = TermEditorInput.getDefaultNameFeatureTree(); |
|
| 1818 |
}else{
|
|
| 1819 |
preferredNameFeatureTree = TermTree.NewInstance(terms); |
|
| 1820 |
} |
|
| 1793 | 1821 |
|
| 1794 | 1822 |
|
| 1795 | 1823 |
} |
| ... | ... | |
| 1810 | 1838 |
|
| 1811 | 1839 |
} |
| 1812 | 1840 |
|
| 1841 |
/** |
|
| 1842 |
* @return |
|
| 1843 |
*/ |
|
| 1844 |
public static TermTree<?> getPreferredFeatureTreeForTaxonDescription(boolean createNew) {
|
|
| 1845 |
if(preferredTaxonFeatureTree != null && !createNew){
|
|
| 1846 |
return preferredTaxonFeatureTree; |
|
| 1847 |
} |
|
| 1848 |
createPreferredFeatureTreeForTaxonDescription(); |
|
| 1849 |
return preferredTaxonFeatureTree; |
|
| 1850 |
|
|
| 1851 |
} |
|
| 1852 |
|
|
| 1853 |
public static void createPreferredFeatureTreeForTaxonDescription() {
|
|
| 1854 |
|
|
| 1855 |
CdmPreferenceCache cache = CdmPreferenceCache.instance(); |
|
| 1856 |
CdmPreference pref = cache.get(PreferencePredicate.TaxonFeatures.getKey()); |
|
| 1857 |
List<Feature> terms; |
|
| 1858 |
boolean override = PreferencesUtil.getBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.TaxonFeatures.getKey())); |
|
| 1859 |
if (pref != null && !override){
|
|
| 1860 |
List<UUID> uuids = PreferencesUtil.createUUIDListFromStringPref(pref.getValue()); |
|
| 1861 |
terms = CdmStore.getTermManager().getTerms(uuids, Feature.class); |
|
| 1862 |
}else if (override){
|
|
| 1863 |
terms= CdmStore.getTermManager().getPreferredTerms(TermType.Feature); |
|
| 1864 |
TermVocabulary nameVocabulary = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()); |
|
| 1865 |
Set<Feature> nameFeature = nameVocabulary.getTerms(); |
|
| 1866 |
terms.removeAll(nameFeature); |
|
| 1867 |
|
|
| 1868 |
}else{
|
|
| 1869 |
terms= CdmStore.getTermManager().getPreferredTerms(TermType.Feature); |
|
| 1870 |
TermVocabulary nameVocabulary = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()); |
|
| 1871 |
Set<Feature> nameFeature = nameVocabulary.getTerms(); |
|
| 1872 |
terms.removeAll(nameFeature); |
|
| 1873 |
|
|
| 1874 |
} |
|
| 1875 |
|
|
| 1876 |
if (terms.isEmpty()){
|
|
| 1877 |
preferredTaxonFeatureTree = TermEditorInput.getDefaultFeatureTree(); |
|
| 1878 |
}else{
|
|
| 1879 |
preferredTaxonFeatureTree = TermTree.NewInstance(terms); |
|
| 1880 |
} |
|
| 1881 |
|
|
| 1882 |
|
|
| 1883 |
} |
|
| 1884 |
|
|
| 1885 |
|
|
| 1813 | 1886 |
|
| 1814 | 1887 |
|
| 1815 | 1888 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/RankPreference.java | ||
|---|---|---|
| 22 | 22 |
import eu.etaxonomy.cdm.persistence.dto.TermDto; |
| 23 | 23 |
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto; |
| 24 | 24 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
| 25 |
import eu.etaxonomy.taxeditor.store.TermStore; |
|
| 26 | 25 |
|
| 27 | 26 |
/** |
| 28 | 27 |
* @author k.luther |
| ... | ... | |
| 87 | 86 |
PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.AvailableRanks.getKey()), true); |
| 88 | 87 |
} |
| 89 | 88 |
|
| 90 |
CdmStore.getTermManager().setPreferredTerms(preferredTerms, TermStore.getTerms(TermType.Rank, null));
|
|
| 89 |
CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, TermType.Rank);
|
|
| 91 | 90 |
PreferencesUtil.firePreferencesChanged(this.getClass()); |
| 92 | 91 |
return true; |
| 93 | 92 |
|
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/menu/FeatureMenuPreferences.java | ||
|---|---|---|
| 8 | 8 |
*/ |
| 9 | 9 |
package eu.etaxonomy.taxeditor.preference.menu; |
| 10 | 10 |
|
| 11 |
import java.util.ArrayList; |
|
| 12 |
import java.util.List; |
|
| 13 |
|
|
| 14 |
import eu.etaxonomy.cdm.api.service.IVocabularyService; |
|
| 15 |
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate; |
|
| 11 | 16 |
import eu.etaxonomy.cdm.model.term.TermType; |
| 12 |
import eu.etaxonomy.cdm.model.description.Feature; |
|
| 13 |
import eu.etaxonomy.taxeditor.l10n.Messages; |
|
| 17 |
import eu.etaxonomy.cdm.model.term.VocabularyEnum; |
|
| 18 |
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto; |
|
| 19 |
import eu.etaxonomy.taxeditor.editor.definedterm.input.TermEditorInput; |
|
| 20 |
import eu.etaxonomy.taxeditor.preference.GeneralTermPreference; |
|
| 21 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
|
| 14 | 22 |
|
| 15 | 23 |
/** |
| 16 | 24 |
* <p>FeatureMenuPreferences class.</p> |
| ... | ... | |
| 20 | 28 |
* @created 17.09.2008 |
| 21 | 29 |
* @version 1.0 |
| 22 | 30 |
*/ |
| 23 |
public class FeatureMenuPreferences extends AbstractMenuPreferences<Feature> {
|
|
| 24 |
|
|
| 25 |
/** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.preferences.feat"{trunked}</code> */
|
|
| 26 |
public static final String PLUGIN_ID = "eu.etaxonomy.taxeditor.preferences.feature"; //$NON-NLS-1$ |
|
| 27 |
|
|
| 28 |
/** |
|
| 29 |
* <p>Constructor for FeatureMenuPreferences.</p> |
|
| 30 |
*/ |
|
| 31 |
public FeatureMenuPreferences() {
|
|
| 32 |
super("Feature Preferences", //$NON-NLS-1$
|
|
| 33 |
Messages.FeatureMenuPreferences_display, |
|
| 34 |
false); |
|
| 35 |
} |
|
| 36 |
|
|
| 37 |
/* (non-Javadoc) |
|
| 38 |
* @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass() |
|
| 39 |
*/ |
|
| 40 |
/** {@inheritDoc} */
|
|
| 41 |
@Override |
|
| 42 |
protected TermType getTermType() {
|
|
| 43 |
return TermType.Feature; |
|
| 44 |
} |
|
| 31 |
public class FeatureMenuPreferences extends GeneralTermPreference{
|
|
| 32 |
|
|
| 33 |
/** Constant <code>PLUGIN_ID="eu.etaxonomy.taxeditor.preferences.feat"{trunked}</code> */
|
|
| 34 |
public static final String PLUGIN_ID = "eu.etaxonomy.taxeditor.preferences.nameFeature"; //$NON-NLS-1$ |
|
| 35 |
|
|
| 36 |
/** |
|
| 37 |
* <p>Constructor for FeatureMenuPreference.</p> |
|
| 38 |
*/ |
|
| 39 |
public FeatureMenuPreferences() {
|
|
| 40 |
super(); |
|
| 41 |
setLocalPref(true); |
|
| 42 |
setPredicate(PreferencePredicate.TaxonFeatures); |
|
| 43 |
type = TermType.Feature; |
|
| 44 |
} |
|
| 45 |
|
|
| 46 |
@Override |
|
| 47 |
protected List<TermVocabularyDto> getVocabulariesFromPreference() {
|
|
| 48 |
// TODO Auto-generated method stub |
|
| 49 |
return null; |
|
| 50 |
} |
|
| 51 |
|
|
| 52 |
@Override |
|
| 53 |
public boolean performOk(){
|
|
| 54 |
boolean result = super.performOk(); |
|
| 55 |
if (result){
|
|
| 56 |
TermEditorInput.getPreferredTaxonFeatureTree(true); |
|
| 57 |
} |
|
| 58 |
return true; |
|
| 59 |
|
|
| 60 |
} |
|
| 61 |
|
|
| 62 |
@Override |
|
| 63 |
protected void initialiseVocabularies() {
|
|
| 64 |
|
|
| 65 |
super.initialiseVocabularies(); |
|
| 66 |
List<TermVocabularyDto> vocs = new ArrayList<>(); |
|
| 67 |
vocs.add(CdmStore.getService(IVocabularyService.class).findVocabularyDtoByVocabularyUuid(VocabularyEnum.NameFeature.getUuid())); |
|
| 68 |
this.getVocabularies().removeAll(vocs); |
|
| 69 |
|
|
| 70 |
} |
|
| 71 |
|
|
| 72 |
|
|
| 73 |
|
|
| 45 | 74 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/menu/NameTypeDesignationStatusMenuPreferences.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package eu.etaxonomy.taxeditor.preference.menu; |
| 11 | 11 |
|
| 12 |
import java.util.List; |
|
| 13 |
|
|
| 14 |
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate; |
|
| 12 | 15 |
import eu.etaxonomy.cdm.model.term.TermType; |
| 13 |
import eu.etaxonomy.cdm.model.name.NameTypeDesignationStatus;
|
|
| 14 |
import eu.etaxonomy.taxeditor.l10n.Messages;
|
|
| 16 |
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;
|
|
| 17 |
import eu.etaxonomy.taxeditor.preference.GeneralTermPreference;
|
|
| 15 | 18 |
|
| 16 | 19 |
/** |
| 17 | 20 |
* <p>NameTypeDesignationStatusMenuPreferences class.</p> |
| ... | ... | |
| 21 | 24 |
* @version 1.0 |
| 22 | 25 |
*/ |
| 23 | 26 |
public class NameTypeDesignationStatusMenuPreferences extends |
| 24 |
AbstractMenuPreferences<NameTypeDesignationStatus> {
|
|
| 25 |
/** |
|
| 26 |
* <p>Constructor for NameTypeDesignationStatusMenuPreferences.</p> |
|
| 27 |
*/ |
|
| 28 |
public NameTypeDesignationStatusMenuPreferences() {
|
|
| 29 |
super("Name Type Designation Status Preferences", //$NON-NLS-1$
|
|
| 30 |
Messages.NameTypeDesignationStatusMenuPreferences_configure, |
|
| 31 |
false); |
|
| 32 |
} |
|
| 33 |
|
|
| 34 |
/* (non-Javadoc) |
|
| 35 |
* @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass() |
|
| 36 |
*/ |
|
| 37 |
/** {@inheritDoc} */
|
|
| 38 |
@Override |
|
| 39 |
protected TermType getTermType() {
|
|
| 40 |
return TermType.NameTypeDesignationStatus; |
|
| 41 |
} |
|
| 27 |
GeneralTermPreference {
|
|
| 28 |
/** |
|
| 29 |
* <p>Constructor for NameTypeDesignationStatusMenuPreferences.</p> |
|
| 30 |
*/ |
|
| 31 |
public NameTypeDesignationStatusMenuPreferences() {
|
|
| 32 |
super(); |
|
| 33 |
setLocalPref(true); |
|
| 34 |
setPredicate(PreferencePredicate.NameTypeDesignationStatus); |
|
| 35 |
type = TermType.NameTypeDesignationStatus; |
|
| 36 |
} |
|
| 42 | 37 |
|
| 38 |
/** |
|
| 39 |
* {@inheritDoc}
|
|
| 40 |
*/ |
|
| 41 |
@Override |
|
| 42 |
protected List<TermVocabularyDto> getVocabulariesFromPreference() {
|
|
| 43 |
// TODO Auto-generated method stub |
|
| 44 |
return null; |
|
| 45 |
} |
|
| 43 | 46 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/preference/menu/SpecimenTypeDesignationStatusMenuPreferences.java | ||
|---|---|---|
| 9 | 9 |
|
| 10 | 10 |
package eu.etaxonomy.taxeditor.preference.menu; |
| 11 | 11 |
|
| 12 |
import java.util.ArrayList; |
|
| 13 |
import java.util.List; |
|
| 14 |
import java.util.UUID; |
|
| 15 |
|
|
| 16 |
import org.apache.commons.lang.StringUtils; |
|
| 17 |
|
|
| 18 |
import eu.etaxonomy.cdm.api.service.ITermService; |
|
| 19 |
import eu.etaxonomy.cdm.model.metadata.PreferencePredicate; |
|
| 20 |
import eu.etaxonomy.cdm.model.term.DefinedTermBase; |
|
| 12 | 21 |
import eu.etaxonomy.cdm.model.term.TermType; |
| 13 |
import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus; |
|
| 14 |
import eu.etaxonomy.taxeditor.l10n.Messages; |
|
| 22 |
import eu.etaxonomy.cdm.persistence.dto.TermDto; |
|
| 23 |
import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto; |
|
| 24 |
import eu.etaxonomy.taxeditor.preference.GeneralTermPreference; |
|
| 25 |
import eu.etaxonomy.taxeditor.preference.LocalOrDefaultEnum; |
|
| 26 |
import eu.etaxonomy.taxeditor.preference.PreferencesUtil; |
|
| 27 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
|
| 15 | 28 |
|
| 16 | 29 |
/** |
| 17 | 30 |
* <p>SpecimenTypeDesignationStatusMenuPreferences class.</p> |
| ... | ... | |
| 21 | 34 |
* @version 1.0 |
| 22 | 35 |
*/ |
| 23 | 36 |
public class SpecimenTypeDesignationStatusMenuPreferences extends |
| 24 |
AbstractMenuPreferences<SpecimenTypeDesignationStatus> {
|
|
| 25 |
/** |
|
| 26 |
* <p>Constructor for SpecimenTypeDesignationStatusMenuPreferences.</p> |
|
| 27 |
*/ |
|
| 28 |
public SpecimenTypeDesignationStatusMenuPreferences() {
|
|
| 29 |
super("Specimen Type Designation Status Preferences", //$NON-NLS-1$
|
|
| 30 |
Messages.SpecimenTypeDesignationStatusMenuPreferences_configure, |
|
| 31 |
false); |
|
| 32 |
} |
|
| 33 |
|
|
| 34 |
/* (non-Javadoc) |
|
| 35 |
* @see eu.etaxonomy.taxeditor.preference.menu.AbstractMenuPreferences#getTermClass() |
|
| 36 |
*/ |
|
| 37 |
/** {@inheritDoc} */
|
|
| 38 |
@Override |
|
| 39 |
protected TermType getTermType() {
|
|
| 40 |
return TermType.SpecimenTypeDesignationStatus; |
|
| 41 |
} |
|
| 37 |
GeneralTermPreference {
|
|
| 38 |
/** |
|
| 39 |
* <p>Constructor for SpecimenTypeDesignationStatusMenuPreferences.</p> |
|
| 40 |
*/ |
|
| 41 |
public SpecimenTypeDesignationStatusMenuPreferences() {
|
|
| 42 |
super(); |
|
| 43 |
setLocalPref(true); |
|
| 44 |
setPredicate(PreferencePredicate.SpecimenTypeDesignationStatus); |
|
| 45 |
type = TermType.SpecimenTypeDesignationStatus; |
|
| 46 |
} |
|
| 47 |
|
|
| 48 |
|
|
| 49 |
|
|
| 50 |
/** |
|
| 51 |
* {@inheritDoc}
|
|
| 52 |
*/ |
|
| 53 |
@Override |
|
| 54 |
protected List<TermVocabularyDto> getVocabulariesFromPreference() {
|
|
| 55 |
// TODO Auto-generated method stub |
|
| 56 |
return null; |
|
| 57 |
} |
|
| 58 |
|
|
| 59 |
|
|
| 60 |
@Override |
|
| 61 |
public boolean performOk() {
|
|
| 62 |
if (!isApply()){
|
|
| 63 |
return true; |
|
| 64 |
} |
|
| 65 |
Object[] checkedElements = treeComposite.getViewer().getCheckedElements(); |
|
| 66 |
List<UUID> listUIIDChecked = new ArrayList<>(); |
|
| 67 |
List<DefinedTermBase> preferredTerms = new ArrayList<>(); |
|
| 68 |
for (Object o : checkedElements) {
|
|
| 69 |
if(o instanceof TermDto){
|
|
| 70 |
TermDto termDto = (TermDto) o; |
|
| 71 |
listUIIDChecked.add(termDto.getUuid()); |
|
| 72 |
preferredTerms.add(CdmStore.getService(ITermService.class).load(termDto.getUuid())); |
|
| 73 |
} |
|
| 74 |
} |
|
| 75 |
String saveCheckedElements = StringUtils.join(listUIIDChecked, ";"); //$NON-NLS-1$ |
|
| 76 |
|
|
| 77 |
PreferencesUtil.setStringValue(PreferencePredicate.SpecimenTypeDesignationStatus.getKey(), saveCheckedElements); |
|
| 78 |
String text = this.useLocalOrAdmin.getText(); |
|
| 79 |
if (text.equals(LocalOrDefaultEnum.Database.getLabel()) || text.equals(LocalOrDefaultEnum.Default.getLabel())){
|
|
| 80 |
PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.SpecimenTypeDesignationStatus.getKey()), false); |
|
| 81 |
}else if (text.equals(LocalOrDefaultEnum.Local.getLabel())){
|
|
| 82 |
PreferencesUtil.setBooleanValue(PreferencesUtil.createOverridePreferenceString(PreferencePredicate.SpecimenTypeDesignationStatus.getKey()), true); |
|
| 83 |
} |
|
| 84 |
|
|
| 85 |
CdmStore.getTermManager().setPreferredTermsByType(preferredTerms, TermType.SpecimenTypeDesignationStatus); |
|
| 86 |
PreferencesUtil.firePreferencesChanged(this.getClass()); |
|
| 87 |
return true; |
|
| 42 | 88 |
|
| 89 |
} |
|
| 43 | 90 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/TermManager.java | ||
|---|---|---|
| 13 | 13 |
import java.util.Collection; |
| 14 | 14 |
import java.util.Comparator; |
| 15 | 15 |
import java.util.HashMap; |
| 16 |
import java.util.Iterator; |
|
| 16 | 17 |
import java.util.List; |
| 17 | 18 |
import java.util.Map; |
| 18 | 19 |
import java.util.UUID; |
| ... | ... | |
| 91 | 92 |
comp = new DefaultTermComparator<T>(); |
| 92 | 93 |
} |
| 93 | 94 |
List terms = cachedTermMap.get(termVocabulary.getUuid()); |
| 95 |
List<T> termBaseList = new ArrayList(); |
|
| 94 | 96 |
if(terms==null){
|
| 95 | 97 |
terms = getFilteredTerms(new ArrayList<T>(TermStore.getTerms(termVocabulary,comp))); |
| 96 | 98 |
cachedTermMap.put(termVocabulary.getUuid(), terms); |
| 99 |
}else{
|
|
| 100 |
Iterator iterator = terms.iterator(); |
|
| 101 |
DefinedTermBase termBase = null; |
|
| 102 |
List<UUID> uuids = new ArrayList(); |
|
| 103 |
while (iterator.hasNext()){
|
|
| 104 |
Object term = iterator.next(); |
|
| 105 |
if (term instanceof TermDto){
|
|
| 106 |
TermDto dto = (TermDto)term; |
|
| 107 |
uuids.add(dto.getUuid()); |
|
| 108 |
}else {
|
|
| 109 |
termBaseList.add((T)term); |
|
| 110 |
} |
|
| 111 |
|
|
| 112 |
} |
|
| 113 |
if (!uuids.isEmpty()){
|
|
| 114 |
termBaseList.addAll(this.getTerms(uuids, DefinedTermBase.class)); |
|
| 115 |
} |
|
| 116 |
|
|
| 97 | 117 |
} |
| 98 |
terms.sort(comp); |
|
| 118 |
termBaseList.sort(comp); |
|
| 119 |
terms = termBaseList; |
|
| 99 | 120 |
return terms; |
| 100 | 121 |
} |
| 101 | 122 |
/** |
| ... | ... | |
| 137 | 158 |
filteredTerms.add(term); |
| 138 | 159 |
} |
| 139 | 160 |
} |
| 161 |
if (filteredTerms.isEmpty()){
|
|
| 162 |
return initialTerms; |
|
| 163 |
} |
|
| 140 | 164 |
|
| 141 | 165 |
return filteredTerms; |
| 142 | 166 |
} |
| ... | ... | |
| 191 | 215 |
} |
| 192 | 216 |
clearTermMapForTermVoc(voc.getUuid()); |
| 193 | 217 |
|
| 218 |
|
|
| 219 |
|
|
| 194 | 220 |
} |
| 195 | 221 |
|
| 222 |
|
|
| 223 |
/** |
|
| 224 |
* Generic method to set term preferences |
|
| 225 |
* |
|
| 226 |
* @param preferredTerms a {@link java.util.List} object.
|
|
| 227 |
* @param initialTerms a {@link java.util.List} object.
|
|
| 228 |
* @param <T> a T object. |
|
| 229 |
*/ |
|
| 230 |
public <T extends DefinedTermBase> void setPreferredTermsByType(Collection<T> preferredTerms, TermType type){
|
|
| 231 |
|
|
| 232 |
|
|
| 233 |
Collection<UUID> undesiredTermUuids = new ArrayList<UUID>(); |
|
| 234 |
List<DefinedTermBase> oldValues = getPreferredTerms(type); |
|
| 235 |
for (DefinedTermBase term: oldValues){
|
|
| 236 |
PreferencesUtil.setBooleanValue(getPrefName(term), false); |
|
| 237 |
} |
|
| 238 |
for(TermBase term : preferredTerms){
|
|
| 239 |
PreferencesUtil.setBooleanValue(getPrefName(term), true); |
|
| 240 |
|
|
| 241 |
} |
|
| 242 |
|
|
| 243 |
clearTermMapForTermType(type); |
|
| 244 |
|
|
| 245 |
|
|
| 246 |
|
|
| 247 |
} |
|
| 196 | 248 |
/** |
| 197 | 249 |
* Generic method to set term preferences |
| 198 | 250 |
* |
| ... | ... | |
| 205 | 257 |
|
| 206 | 258 |
Collection<UUID> undesiredTermUuids = new ArrayList<UUID>(); |
| 207 | 259 |
|
| 208 |
for(TermDto term : vocDto.getTerms()){
|
|
| 260 |
for(TermDto term : preferredTerms){
|
|
| 209 | 261 |
if(!preferredTerms.contains(term)){
|
| 210 | 262 |
undesiredTermUuids.add(term.getUuid()); |
| 211 | 263 |
PreferencesUtil.setBooleanValue(getPrefNameByDto(term), false); |
| ... | ... | |
| 215 | 267 |
} |
| 216 | 268 |
//if (initialTerms.iterator().hasNext()){
|
| 217 | 269 |
clearTermMapForTermVoc(vocDto.getUuid()); |
| 270 |
List<TermDto> list = new ArrayList<>(preferredTerms); |
|
| 271 |
cachedTermMap.put(vocDto.getUuid(), list); |
|
| 218 | 272 |
//} |
| 219 | 273 |
|
| 220 | 274 |
} |
| eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/ui/section/name/NomenclaturalStatusElement.java | ||
|---|---|---|
| 13 | 13 |
|
| 14 | 14 |
import org.eclipse.swt.events.SelectionListener; |
| 15 | 15 |
|
| 16 |
import eu.etaxonomy.cdm.api.service.IVocabularyService; |
|
| 17 | 16 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatus; |
| 18 | 17 |
import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType; |
| 19 |
import eu.etaxonomy.cdm.model.term.TermVocabulary; |
|
| 20 |
import eu.etaxonomy.cdm.model.term.VocabularyEnum; |
|
| 21 |
import eu.etaxonomy.taxeditor.store.CdmStore; |
|
| 18 |
import eu.etaxonomy.cdm.model.term.TermType; |
|
| 22 | 19 |
import eu.etaxonomy.taxeditor.ui.combo.term.TermComboElement; |
| 23 | 20 |
import eu.etaxonomy.taxeditor.ui.element.AbstractFormSection; |
| 24 | 21 |
import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory; |
| ... | ... | |
| 50 | 47 |
/** {@inheritDoc} */
|
| 51 | 48 |
@Override |
| 52 | 49 |
public void createControls(ICdmFormElement element, int style) {
|
| 53 |
TermVocabulary vocabulary = CdmStore.getService(IVocabularyService.class).find(VocabularyEnum.NomenclaturalStatusType.getUuid()); |
|
| 50 |
//TermVocabulary vocabulary = CdmStore.getService(IVocabularyService.class).find(VocabularyEnum.NomenclaturalStatusType.getUuid());
|
|
| 54 | 51 |
|
| 55 | 52 |
Comparator<NomenclaturalStatusType> termComparator= new Comparator<NomenclaturalStatusType>() {
|
| 56 | 53 |
|
| ... | ... | |
| 79 | 76 |
} |
| 80 | 77 |
}; |
| 81 | 78 |
|
| 82 |
nomenclaturalStatusTypeCombo = formFactory.createDefinedTermComboElement(vocabulary, this, "Status", null,true, style, true);
|
|
| 79 |
nomenclaturalStatusTypeCombo = formFactory.createDefinedTermComboElement(TermType.NomenclaturalStatusType, this, "Status", null,true, style, true);
|
|
| 83 | 80 |
nomenclaturalStatusTypeCombo.setTermComparator(termComparator); |
| 84 | 81 |
ruleConsideredText = formFactory.createTextWithLabelElement(this, "Rule Considered", "", style); |
| 85 | 82 |
|
Also available in: Unified diff
fix preferences and term issues