}\r
}\r
if (object instanceof TermNodeDto) {\r
- if (((TermNodeDto) object).getTree().isManaged()) {\r
+ if (((TermNodeDto) object).isExternallyManaged()) {\r
return false;\r
}\r
}\r
*/
package eu.etaxonomy.taxeditor.editor.definedterm;
-import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
public Collection<? extends TermDto> getChildTerms(TermCollectionDto voc) {
Collection<TermDto> children = getVocabularyToChildTermMap().get(voc);
if (children == null) {
- children = new ArrayList<>(CdmStore.getService(IVocabularyService.class).getCompleteTermHierarchy(voc));
- getVocabularyToChildTermMap().put(voc, children);
+ children = CdmStore.getService(IVocabularyService.class).getCompleteTermHierarchy(voc);
+ getVocabularyToChildTermMap().put(voc, children);
}
return children;
}
String label2 = "";
if (e1 instanceof TermNodeDto ){
- if (((TermNodeDto)e1).getTree().isOrderRelevant()){
+ if (((TermNodeDto)e1).isOrderRelevant()){
return 0;
}
}else if (e1 instanceof TermNode){
public static final String MOVE_FAILED_STANDARD_TERM = Messages.DefinedTermDropAdapterE4_MOVE_FAILED_STANDARD_TERM;
public static final String MOVE_FAILED_TO_STANDARD_VOC = Messages.DefinedTermDropAdapterE4_MOVE_FAILED_TO_STANDARD_VOC;
public static final String MOVE_FAILED_TO_MANAGED_VOC = Messages.DefinedTermDropAdapterE4_MOVE_FAILED_TO_MANAGED_VOC;
- public static final String MOVE_FAILED_TO_MANAGED_TERM = Messages.DefinedTermDropAdapterE4_MOVE_FAILED_TO_MANAGED_TERM;
+ public static final String MOVE_FAILED_TO_MANAGED_TERM = Messages.DefinedTermDropAdapterE4_MOVE_FAILED_MANAGED_TERM;
private final DefinedTermEditorE4 editor;
if(target instanceof TermVocabularyDto && (getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON || ((TermVocabularyDto)target).isManaged())){
valid = false;
}
- if (target instanceof TermDto && ((((TermDto)target).getOrderIndex() == null && getCurrentLocation() == ViewerDropAdapter.LOCATION_AFTER)||(((TermDto)target).isManaged()))){
+ if (target instanceof TermDto && ((((TermDto)target).getOrderIndex() == null && getCurrentLocation() == ViewerDropAdapter.LOCATION_AFTER)||(((TermDto)target).isManaged()) || (((TermDto)target).getVocabularyDto().isManaged()))){
valid = false;
}
UUID vocabularyUuid = null;
if(firstElement instanceof TermDto){
- if (((TermDto)firstElement).isManaged()) {
+ if (((TermDto)firstElement).isManaged() || ((TermDto)firstElement).getVocabularyDto().isManaged()) {
return false;
}
vocabularyUuid = ((TermDto) firstElement).getVocabularyUuid();
(firstElement instanceof AbstractTermDto);
UUID vocabularyUuid = null;
if(firstElement instanceof TermDto){
- if (((TermDto)firstElement).isManaged()) {
+ if (((TermDto)firstElement).isManaged() || ((TermDto)firstElement).getVocabularyDto().isManaged()) {
return false;
}
vocabularyUuid = ((TermDto) firstElement).getVocabularyUuid();
}
return termBaseList;
}
+
+ public <T extends DefinedTermBase>List<TermDto> getPreferredTermsAsDto(TermType termType) {
+ List<?> terms = cachedTermMap.get(termType.getUuid());
+ List<TermDto> termsAsDto = new ArrayList<>();
+ if (terms == null || terms.isEmpty()) {
+ List<T> termBaseList = new ArrayList<>();
+ termBaseList = getFilteredTerms(TermStore.<T> getTerms(termType, null));
+ if (termBaseList != null) {
+ cachedTermMap.put(termType.getUuid(), termBaseList);
+ }
+ for (T term:termBaseList) {
+ termsAsDto.add(TermDto.fromTerm(term));
+ }
+ } else {
+ List<TermDto> termBaseList = new ArrayList<>();
+ Iterator<?> iterator = terms.iterator();
+ List<UUID> uuids = new ArrayList<>();
+ while (iterator.hasNext()) {
+ Object term = iterator.next();
+ if (term instanceof TermDto) {
+ TermDto dto = (TermDto) term;
+ termsAsDto.add(dto);
+ } else {
+ termsAsDto.add(TermDto.fromTerm((T)term));
+ }
+ }
+
+ }
+ return termsAsDto;
+ }
public <T extends DefinedTermBase> List<T> getPreferredTerms(TermVocabulary<T> termVocabulary) {
@SuppressWarnings("unchecked")
}
return terms;
}
+
+ public <T extends DefinedTermBase> List<TermDto> getPreferredTermsAsDto(Class<T> clazz) {
+ @SuppressWarnings("unchecked")
+ List<T> terms = cachedTermMap.get(clazz);
+ List<TermDto> termsAsDto = new ArrayList<>();
+ if (terms == null) {
+ terms = getFilteredTerms(TermStore.getTerms(clazz));
+ cachedTermMap.put(clazz, terms);
+ }
+ for (T term: terms) {
+ termsAsDto.add(TermDto.fromTerm(term));
+ }
+ return termsAsDto;
+ }
/**
* Generic method to get term preferences for a term vocabulary
return filteredTerms;
}
+
+ /**
+ * Generic method to get term preferences for a term vocabulary
+ *
+ * @param initialTerms
+ * a {@link java.util.List} object.
+ * @return a {@link java.util.List} object.
+ */
+ public <T extends DefinedTermBase> List<TermDto> getFilteredTermsAsDto(List<TermDto> initialTerms) {
+ List<TermDto> filteredTerms = new ArrayList<>();
+ if (initialTerms == null || initialTerms.isEmpty()) {
+ return filteredTerms;
+ }
+
+ for (TermDto term : initialTerms) {
+ if (PreferencesUtil.getBooleanValue(getPrefNameByDto(term), true)) {
+ filteredTerms.add(term);
+ }
+ }
+ if (filteredTerms.isEmpty()) {
+ // check for dtos
+ List<TermDto> preferredTerms = null;
+ if (initialTerms.get(0).getVocabularyUuid() != null) {
+ preferredTerms = cachedTermMap.get(initialTerms.get(0).getVocabularyUuid());
+ }
+ if (preferredTerms == null) {
+ preferredTerms = cachedTermMap.get(initialTerms.get(0).getTermType().getUuid());
+ }
+ if (preferredTerms == null) {
+ return initialTerms;
+ }
+ for (TermDto term : initialTerms) {
+ if (preferredTerms.contains(term)) {
+ filteredTerms.add(term);
+ }
+ }
+ if (filteredTerms.isEmpty()) {
+ return initialTerms;
+ }
+ }
+
+ return filteredTerms;
+ }
+
public <T extends DefinedTermBase> List<T> createTermListFromString(String stringValue, TermType type) {
List<String> checked = new ArrayList<>();
&& ((IStructuredSelection) viewer.getSelection()).toList()
.stream().allMatch(element -> element instanceof TermNodeDto)
&& ((IStructuredSelection) viewer.getSelection()).toList()
- .stream().allMatch(element -> !((TermNodeDto)element).getTree().isManaged());
+ .stream().allMatch(element -> !((TermNodeDto)element).isExternallyManaged());
}else {
event.doit = !viewer.getSelection().isEmpty()
&& ((IStructuredSelection) viewer.getSelection()).toList()
target = ((TermTreeDto) currentTarget).getRoot();
}
else if(currentTarget instanceof TermNodeDto){
- if (((TermNodeDto) currentTarget).getTree().isManaged() ) {
+ if (((TermNodeDto) currentTarget).isExternallyManaged() ) {
return false;
}
target = (TermNodeDto) currentTarget;
AddFeatureOperation operation = new AddFeatureOperation(
termDto.getUuid(),
target.getUuid(), position, editor, editor);
- TermNodeDto newDto = new TermNodeDto(termDto, target, position, target.getTree(), null, 0, null, null);
+ TermNodeDto newDto = new TermNodeDto(termDto, target, position, null, null, 0, null, null);
editor.setDirty();
editor.addOperation(operation);
TermTreeDto rootTree = null;
if (getSelectedObject() instanceof TermNodeDto){
TermNodeDto selectedNode = (TermNodeDto)getSelectedObject();
- rootTree = selectedNode.getTree();
+ rootTree = (TermTreeDto) editor.getTreeDtoForUuid(selectedNode.getTreeUuid());
+
}
if(target instanceof TermTreeDto && getCurrentLocation()!=ViewerDropAdapter.LOCATION_ON){
return false;
if (target == null){
return false;
}
- if (target instanceof TermNodeDto && ((TermNodeDto)target).getTree().isFlat() && getCurrentLocation() == LOCATION_ON){
+ if (target instanceof TermNodeDto && ((TermNodeDto)target).isFlat() && getCurrentLocation() == LOCATION_ON){
return false;
}
TermDto term = null;
private boolean checkDuplication(Object target, TermTreeDto rootTree, TermDto term) {
TermTreeDto targetTree = null;
if (target instanceof TermNodeDto){
- targetTree = ((TermNodeDto)target).getTree();
+ targetTree = (TermTreeDto) editor.getTreeDtoForUuid(((TermNodeDto)target).getTreeUuid());
}else if (target instanceof TermTreeDto){
targetTree = (TermTreeDto)target;
}
if (parentNode != null) {
TermNodeDto copiedNode = (TermNodeDto) ((IStructuredSelection) clipBoardSelection).getFirstElement();
- boolean isDuplicate = this.checkDuplicates(copiedNode.getTerm().getUuid(), parentNode.getTree().getUuid());
- if (isDuplicate && !parentNode.getTree().isAllowDuplicate()) {
+ boolean isDuplicate = this.checkDuplicates(copiedNode.getTerm().getUuid(), parentNode.getTreeUuid());
+ if (isDuplicate && !parentNode.isAllowsDuplicats()) {
MessagingUtils.informationDialog(Messages.AddFeatureHandler_Duplicates_not_allowed,
Messages.AddFeatureHandler_Duplicates_not_allowed_message + "\n"
+ copiedNode.getTerm().getTitleCache());
return;
}
- TermNodeDto newDto = new TermNodeDto(copiedNode.getTerm(), parentNode, 0, parentNode.getTree(), null, 0,
+ TermNodeDto newDto = new TermNodeDto(copiedNode.getTerm(), parentNode, 0, null, null, 0,
null, null);
this.refresh();
this.setDirty();
import eu.etaxonomy.cdm.persistence.dto.CharacterNodeDto;
import eu.etaxonomy.cdm.persistence.dto.TermDto;
import eu.etaxonomy.cdm.persistence.dto.TermNodeDto;
+import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;
import eu.etaxonomy.taxeditor.l10n.Messages;
import eu.etaxonomy.taxeditor.model.MessagingUtils;
import eu.etaxonomy.taxeditor.termtree.AvailableTermsWizard;
TermNodeDto parent = getParent(selection);
TermType type = null;
if (parent.getTerm() == null){
- type = parent.getTree().getTermType();
+ type = parent.getType();
}else{
type = parent.getTerm().getTermType();
}
for (DefinedTermBase term : additionalTerms) {
boolean isDuplicate = false;
- if (!parent.getTree().isAllowDuplicate()){
- isDuplicate = editor.checkDuplicates(term.getUuid(), parent.getTree().getUuid());
+ if (!parent.isAllowsDuplicats()){
+ isDuplicate = editor.checkDuplicates(term.getUuid(), parent.getTreeUuid());
if (isDuplicate){
duplicates.add(term);
}
editor.setDirty();
if (editor instanceof ICharacterEditor){
- CharacterNodeDto newDto = new CharacterNodeDto(CharacterDto.fromCharacter((Character)term), parent, 0, parent.getTree(), null, 0, null, null);
+ CharacterNodeDto newDto = new CharacterNodeDto(CharacterDto.fromCharacter((Character)term), parent, 0, (TermTreeDto) ((ICharacterEditor)editor).getTreeDtoForUuid(parent.getTreeUuid()), null, 0, null, null);
}else{
- TermNodeDto newDto = new TermNodeDto(TermDto.fromTerm(term), parent, 0, parent.getTree(), null, 0, null, null);
+ TermNodeDto newDto = new TermNodeDto(TermDto.fromTerm(term), parent, 0, (TermTreeDto)editor.getTreeDtoForUuid(parent.getTreeUuid()), null, 0, null, null);
}
// ((AbstractTermTreeEditor)editor).getViewer().refresh();
&& selection!=null
&& selection.size()==1
&& selection.getFirstElement() instanceof TermNodeDto
- && !((TermNodeDto)selection.getFirstElement()).getTree().isFlat()
- && !((TermNodeDto)selection).getTree().isManaged();
+ && !((TermNodeDto)selection.getFirstElement()).isFlat()
+ && !((TermNodeDto)selection).isExternallyManaged();
menuItem.setVisible(canExecute);
return canExecute;
}
&& selection!=null
&& selection.size()==1
&& selection.getFirstElement() instanceof TermNodeDto
- && !((TermNodeDto)selection.getFirstElement()).getTree().isManaged();
+ && !((TermNodeDto)selection.getFirstElement()).isExternallyManaged();
menuItem.setVisible(canExecute);
return canExecute;
}
element_text = this.formFactory.createMultiLineTextWithLabel(formElement, "Description", textHeight, style);
if (PreferencesUtil.isMultilanguageTextEditingCapability()) {
createRepresentationEditingElements(formElement, style);
- setTermDto(term, fill);
+
}
-
+ setTermDto(term, fill);
if(representation!=null){
setSelectedRepresentation(representation);
}
term.addRepresentation(rep);
}
- if (selectedRepresentation != null) {
+ if (selectedRepresentation != null && combo_language != null) {
combo_language.setTerms(getLanguages());
}
}
@Override
- protected void updateControlStates() {
+ public void updateControlStates() {
super.updateControlStates();
}
import eu.etaxonomy.taxeditor.ui.element.CheckboxElement;
import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;
import eu.etaxonomy.taxeditor.ui.element.RepresentationElement;
-import eu.etaxonomy.taxeditor.ui.element.TextWithLabelElement;
import eu.etaxonomy.taxeditor.ui.section.AbstractCdmDetailElement;
/**
}
@Override
- protected void updateControlStates() {
+ public void updateControlStates() {
super.updateControlStates();
// toggleable_cache.setEnabled(getEntity().isProtectedTitleCache());
}
BGBM BDI Projects / taxeditor.git / commitdiff