import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.HashSet;
+import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;
+import org.eclipse.e4.ui.di.UISynchronize;
+
import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
import eu.etaxonomy.cdm.api.conversation.IConversationEnabled;
import eu.etaxonomy.cdm.api.service.IClassificationService;
+import eu.etaxonomy.cdm.api.service.INameService;
import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
import eu.etaxonomy.cdm.api.service.ITaxonService;
+import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
+import eu.etaxonomy.cdm.api.service.config.TaxonBaseDeletionConfigurator;
+import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.name.HybridRelationship;
import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeMap;
import eu.etaxonomy.taxeditor.editor.CdmEntitySessionInput;
+import eu.etaxonomy.taxeditor.editor.ChooseFromMultipleAcceptedTaxaDialog;
import eu.etaxonomy.taxeditor.editor.ChooseFromMultipleTaxonNodesDialog;
+import eu.etaxonomy.taxeditor.editor.EditorUtil;
import eu.etaxonomy.taxeditor.editor.l10n.Messages;
import eu.etaxonomy.taxeditor.model.DataChangeBridge;
import eu.etaxonomy.taxeditor.model.MessagingUtils;
+import eu.etaxonomy.taxeditor.operation.AbstractPostOperation;
+import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
private TaxonNode taxonNode;
+ private Map<TaxonBase, TaxonBaseDeletionConfigurator> toDeletes = new HashMap<>();
+ private Set<Synonym> toSaveNewSynonyms = new HashSet<>();
+ private List<TaxonBase> toSaveNewConcepts = new ArrayList<>();
+ private List<TaxonName> toSaveNewNames = new ArrayList<>();
+
+
+ private Set<AbstractPostTaxonOperation> operations = new HashSet<>();
+
private TaxonEditorInputDataChangeBehaviourE4 dataChangeBehavior;
- private TaxonBase initiallySelectedTaxonBase;
+ private TaxonBase<?> initiallySelectedTaxonBase;
+
+ private UISynchronize sync;
+
+
+ public void setSync(UISynchronize sync) {
+ this.sync = sync;
+ }
private enum CdmType {
TAXON_NODE,
}
private void init(TaxonNode taxonNode) {
- this.taxonNode = taxonNode;
+ this.taxonNode = taxonNode;
}
private void initForTaxonNode(UUID taxonNodeUuid) {
-
-
+ this.getCdmEntitySession().bind();
TaxonNode taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNodeUuid, getTaxonNodePropertyPaths());
-
+// TaxonNode taxonNode = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNodeUuid, getTaxonNodePropertyPaths());
if(taxonNode == null){
MessagingUtils.warningDialog(Messages.TaxonEditorInput_NOT_IMPLEMENTED, TaxonEditorInputE4.class, Messages.TaxonEditorInput_NOT_IMPLEMENTED_MESSAGE);
}
}
private void initForTaxonBase(UUID taxonBaseUuid) {
- TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).load(taxonBaseUuid, getTaxonBasePropertyPaths());
+ this.getCdmEntitySession().bind();
+// TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).load(taxonBaseUuid, getTaxonBasePropertyPaths());
+ TaxonBase taxonBase = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonService.class), taxonBaseUuid, getTaxonBasePropertyPaths());
if (taxonBase != null){
if(taxonBase.isInstanceOf(Taxon.class)){
Taxon taxon = CdmBase.deproxy(taxonBase, Taxon.class);
setInitiallySelectedTaxonBase(taxon);
- if (taxon.getTaxonNodes().size() == 0 && taxon.isMisapplication()){
+ if ( (taxon.isMisapplication() || taxon.isProparteSynonym())&& (taxon.getTaxonNodes().size() >0 || taxon.getRelationsFromThisTaxon().size() > 1)){
// TODO get accepted taxon
MessagingUtils.info(Messages.TaxonEditorInput_OPEN_MISSAPPLIED_NAME);
acceptedTaxa.add(relation.getToTaxon());
}
}
- setInputForMultipleTaxa(conversation, acceptedTaxa);
+ if (taxon.getTaxonNodes().size() > 0){
+ acceptedTaxa.add(taxon);
+ }
+ setInputForRelatedTaxa(conversation, acceptedTaxa);
}else{
setInputForMultipleNodes(conversation, taxon.getTaxonNodes());
private void initForParentTaxonNode(UUID parentNodeUuid){
-
-
+ this.getCdmEntitySession().bind();
TaxonName name = PreferencesUtil.getPreferredNomenclaturalCode().getNewTaxonNameInstance(null);
ITaxonTreeNode parentNode = CdmStore.getService(IClassificationService.class).getTreeNodeByUuid(parentNodeUuid);
private void setInputForMultipleNodes(ConversationHolder conversation, Set<TaxonNode> taxonNodes){
if(taxonNodes.size() == 1){
TaxonNode taxonNode = taxonNodes.iterator().next();
+ taxonNode = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNode.getUuid(), getTaxonNodePropertyPaths());
init(taxonNode);
}else if(taxonNodes.size() > 1){
+
TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(taxonNodes);
+ if(taxonNode != null){
+ taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());
+ }
if(taxonNode != null){
init(taxonNode);
}
}
}
- public static TaxonEditorInputE4 NewInstance(UUID taxonNodeUuid) throws Exception {
+ private void setInputForRelatedTaxa(ConversationHolder conversation, Set<Taxon> taxa){
+ if(taxa.size() == 1){
+ Taxon taxon = taxa.iterator().next();
+ Set<TaxonNode> nodes = taxon.getTaxonNodes();
+ TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(nodes);
+ init(taxonNode);
+ }else if(taxa.size() > 1){
+ Iterator<Taxon> taxonIterator = taxa.iterator();
+ Set<TaxonNode> nodes = new HashSet<>();
+ while (taxonIterator.hasNext()){
+
+ nodes.addAll(taxonIterator.next().getTaxonNodes());
+ }
+ TaxonNode taxonNode = ChooseFromMultipleAcceptedTaxaDialog.choose(nodes);
+ if(taxonNode != null){
+ taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());
+ }
+ if(taxonNode != null){
+ init(taxonNode);
+ }
+ } else if (taxa.size() == 0) {
+ // this is an undesired state
+ MessagingUtils.warningDialog(INCORRECT_STATE,TaxonEditorInputE4.class,Messages.TaxonEditorInput_TAXON_NOT_IN_CLASSIFICATION);
+ }
+ }
+
+ public static TaxonEditorInputE4 NewInstance(UUID taxonNodeUuid) {
return new TaxonEditorInputE4(taxonNodeUuid, CdmType.TAXON_NODE);
}
return initiallySelectedTaxonBase;
}
+ public Set<AbstractPostTaxonOperation> getOperations() {
+ return operations;
+ }
+
+ public void setOperations(Set<AbstractPostTaxonOperation> operations) {
+ this.operations = operations;
+ }
+
+ public void addOperation(AbstractPostTaxonOperation operation) {
+ this.operations.add(operation);
+ }
+
+ public void addToSaveNewSynonym(Synonym toSaveNew) {
+ this.toSaveNewSynonyms.add(toSaveNew);
+ }
+ public void addToSaveNewConcept(Taxon toSaveNew) {
+ this.toSaveNewConcepts.add(toSaveNew);
+
+ }
+
@Override
public List<TaxonNode> getRootEntities() {
return Arrays.asList(taxonNode);
@Override
public void merge() {
- CdmStore.getService(ITaxonNodeService.class).merge(taxonNode, true);
+ if (!this.getCdmEntitySession().isActive()){
+ this.getCdmEntitySession().bind();
+ }
+ for(Entry<TaxonBase, TaxonBaseDeletionConfigurator> entry:toDeletes.entrySet()){
+ delete(entry.getKey(), entry.getValue());
+ }
+ toDeletes.clear();
+ for(AbstractPostOperation entry:operations){
+ EditorUtil.executeOperation(entry,sync);
+ }
+ operations.clear();
+
+ for (Synonym syn: toSaveNewSynonyms){
+ for (HybridRelationship rel : syn.getName().getHybridChildRelations()){
+// if (!rel.getParentName().isPersited()) {
+ toSaveNewNames.add(rel.getParentName());
+// }
+// if (!rel.getHybridName().isPersited()) {
+ toSaveNewNames.add(rel.getHybridName());
+// }
+
+ }
+ }
+
+ for (TaxonBase concept: toSaveNewConcepts){
+ for (HybridRelationship rel : concept.getName().getHybridChildRelations()){
+// if (!rel.getParentName().isPersited()) {
+ toSaveNewNames.add(rel.getParentName());
+// }
+// if (!rel.getHybridName().isPersited()) {
+ toSaveNewNames.add(rel.getHybridName());
+// }
+
+ }
+ }
+ CdmStore.getService(INameService.class).merge(toSaveNewNames, true);
+ CdmStore.getService(ITaxonService.class).merge(toSaveNewConcepts, true);
+
+ toSaveNewNames.clear();
+ toSaveNewConcepts.clear();
+
+ CdmStore.getService(ITaxonNodeService.class).merge(taxonNode, true);
+
+ }
+
+ /**
+ * @param key
+ * @param value
+ */
+ private void delete(TaxonBase key, TaxonBaseDeletionConfigurator value) {
+ if (key instanceof Synonym){
+ CdmStore.getService(ITaxonService.class).deleteSynonym(((Synonym)key).getUuid(), (SynonymDeletionConfigurator) value);
+ }else{
+ CdmStore.getService(ITaxonService.class).deleteTaxon(((Taxon)key).getUuid(), (TaxonDeletionConfigurator) value, null);
+ }
}
"extensions", //$NON-NLS-1$
"rights", //$NON-NLS-1$
"sources", //$NON-NLS-1$
+ "identifiers",
"descriptions", //$NON-NLS-1$
- "relationsToThisTaxon", //$NON-NLS-1$
- "relationsFromThisTaxon", //$NON-NLS-1$
"taxonNodes", //$NON-NLS-1$
"descriptions.descriptionElements.feature", //$NON-NLS-1$
"descriptions.descriptionElements.area", //$NON-NLS-1$
"descriptions.descriptionElements.status", //$NON-NLS-1$
"descriptions.markers", //$NON-NLS-1$
"name.descriptions", //$NON-NLS-1$
- "name.typeDesignations", //$NON-NLS-1$
+ "name.typeDesignations.typeSpecimen.derivedFrom.originals", //$NON-NLS-1$
"name.status", //$NON-NLS-1$
"name.nomenclaturalReference.inReference", //$NON-NLS-1$
"name.taxonBases.taxonNodes", //$NON-NLS-1$
"name.relationsFromThisName", //$NON-NLS-1$
"name.relationsToThisName", //$NON-NLS-1$
- "name.homotypicalGroup.typifiedNames.taxonBases.synonymRelations.synonym.name.status", //$NON-NLS-1$
+ "name.homotypicalGroup.typifiedNames.taxonBases.synonyms.synonym.name.status", //$NON-NLS-1$
"name.homotypicalGroup.typifiedNames.relationsToThisName.fromName", //$NON-NLS-1$
- "synonymRelations.synonym.name.status.type", //$NON-NLS-1$
- "synonymRelations.synonym.name.relationsToThisName.fromName", //$NON-NLS-1$
- "synonymRelations.synonym.name.nomenclaturalReference.inReference.authorship", //$NON-NLS-1$
- "synonymRelations.synonym.name.nomenclaturalReference.authorship", //$NON-NLS-1$
- "synonymRelations.synonym.name.homotypicalGroup.typifiedNames.taxonBases.synonymRelations" //$NON-NLS-1$
+ "synonyms.name.status.type", //$NON-NLS-1$
+ "synonyms.name.relationsToThisName.fromName", //$NON-NLS-1$
+ "synonyms.name.nomenclaturalReference.inReference.authorship", //$NON-NLS-1$
+ "synonyms.name.nomenclaturalReference.authorship", //$NON-NLS-1$
+ "synonyms.name.homotypicalGroup.typifiedNames.taxonBases.synonyms" //$NON-NLS-1$
});
return taxonBasePropertyPaths;
}
+ /**
+ * @param selectedElement
+ * @param deleteConfig
+ */
+ public void addTaxonBaseToDelete(TaxonBase selectedElement, TaxonBaseDeletionConfigurator deleteConfig) {
+ this.toDeletes.put(selectedElement, deleteConfig);
+
+ }
+
+ /**
+ * @param newName
+ */
+ public void addToSaveNewName(TaxonName newName) {
+ this.toSaveNewNames.add(newName);
+ }
+
}
BGBM BDI Projects / taxeditor.git / blobdiff