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.core.commands.ExecutionException;
+import org.eclipse.core.commands.operations.IOperationHistory;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.Status;
import org.eclipse.e4.ui.di.UISynchronize;
+import org.eclipse.ui.ide.undo.WorkspaceUndoUtil;
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.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
-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.AbstractUtility;
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.operation.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
/**
private TaxonNode taxonNode;
- private Map<TaxonBase, TaxonBaseDeletionConfigurator> toDelete = new HashMap<>();
- private Set<TaxonBase> toSaveNew = new HashSet<>();
+ 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 Set<AbstractPostOperation> operations = new HashSet<>();
private TaxonEditorInputDataChangeBehaviourE4 dataChangeBehavior;
- private TaxonBase initiallySelectedTaxonBase;
+ private TaxonBase<?> initiallySelectedTaxonBase;
- UISynchronize sync;
+ private UISynchronize sync;
public void setSync(UISynchronize sync) {
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) {
this.getCdmEntitySession().bind();
- TaxonBase taxonBase = CdmStore.getService(ITaxonService.class).load(taxonBaseUuid, getTaxonBasePropertyPaths());
+// 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()){
// TODO get accepted taxon
MessagingUtils.info(Messages.TaxonEditorInput_OPEN_MISSAPPLIED_NAME);
Set<Taxon> acceptedTaxa = new HashSet<Taxon>();
Set<TaxonRelationship> relations = taxon.getRelationsFromThisTaxon();
for(TaxonRelationship relation : relations){
- if(relation.getType().equals(TaxonRelationshipType.MISAPPLIED_NAME_FOR())){
+ if(relation.getType().isAnyMisappliedName() || relation.getType().isAnySynonym()){
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 setInputForMultipleNodes(ConversationHolder conversation, Set<TaxonNode> taxonNodes){
if(taxonNodes.size() == 1){
TaxonNode taxonNode = taxonNodes.iterator().next();
- taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());
+ taxonNode = getCdmEntitySession().remoteLoad(CdmStore.getService(ITaxonNodeService.class), taxonNode.getUuid(), getTaxonNodePropertyPaths());
init(taxonNode);
}else if(taxonNodes.size() > 1){
+
TaxonNode taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(taxonNodes);
- taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());
+ if(taxonNode != null){
+ taxonNode = CdmStore.getService(ITaxonNodeService.class).load(taxonNode.getUuid(), getTaxonNodePropertyPaths());
+ }
if(taxonNode != null){
init(taxonNode);
}
}
}
+ private void setInputForRelatedTaxa(ConversationHolder conversation, Set<Taxon> taxa){
+ if(taxa.size() == 1){
+ Taxon taxon = taxa.iterator().next();
+ Set<TaxonNode> nodes = taxon.getTaxonNodes();
+ TaxonNode taxonNode = null;
+ if (nodes.size()>1){
+ taxonNode = ChooseFromMultipleTaxonNodesDialog.choose(nodes);
+ }else if (nodes.size()==1){
+ taxonNode = nodes.iterator().next();
+ }else{
+ MessagingUtils.warningDialog(INCORRECT_STATE,TaxonEditorInputE4.class,Messages.TaxonEditorInput_TAXON_NOT_IN_CLASSIFICATION);
+ }
+ 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(AbstractPostOperation operation) {
+ this.operations.add(operation);
}
- 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);
- public void addToSaveNew(TaxonBase toSaveNew) {
- this.toSaveNew.add(toSaveNew);
}
@Override
if (!this.getCdmEntitySession().isActive()){
this.getCdmEntitySession().bind();
}
- for(Entry<TaxonBase, TaxonBaseDeletionConfigurator> entry:toDelete.entrySet()){
+ for(Entry<TaxonBase, TaxonBaseDeletionConfigurator> entry:toDeletes.entrySet()){
delete(entry.getKey(), entry.getValue());
}
- toDelete.clear();
+ toDeletes.clear();
for(AbstractPostOperation entry:operations){
- EditorUtil.executeOperation(entry,sync);
+ IStatus status = Status.CANCEL_STATUS;
+ final IAdaptable uiInfoAdapter = WorkspaceUndoUtil
+ .getUIInfoAdapter(AbstractUtility.getShell());
+ String operationlabel = entry.getLabel();
+ try {
+ entry.addContext(IOperationHistory.GLOBAL_UNDO_CONTEXT);
+ status = entry.execute(new NullProgressMonitor(), uiInfoAdapter);
+ } catch (ExecutionException e) {
+
+ MessagingUtils.operationDialog(AbstractUtility.class, e, TaxeditorStorePlugin.PLUGIN_ID, operationlabel, null);
+
+ }
+
+ String statusString = status.equals(Status.OK_STATUS) ? "completed"
+ : "cancelled";
+
+ IPostOperationEnabled postOperationEnabled = entry
+ .getPostOperationEnabled();
+ if (postOperationEnabled != null) {
+ postOperationEnabled.onComplete();
+ }
+
+
+ //AbstractUtility.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());
+// }
- CdmStore.getService(ITaxonService.class).save(toSaveNew);
+ }
+ }
+
+ 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);
+
}
/**
"sources", //$NON-NLS-1$
"identifiers",
"descriptions", //$NON-NLS-1$
- "relationsToThisTaxon.relatedFrom.name.taxonBases.taxonNodes", //$NON-NLS-1$
- "relationsToThisTaxon.relatedFrom.name.taxonBases.relationsFromThisTaxon", //$NON-NLS-1$
- "relationsToThisTaxon.relatedFrom.name.taxonBases.relationsToThisTaxon", //$NON-NLS-1$
- "relationsFromThisTaxon.relatedTo.name.taxonBases.taxonNodes", //$NON-NLS-1$
- "relationsFromThisTaxon.relatedTo.name.taxonBases.relationsFromThisTaxon", //$NON-NLS-1$
- "relationsFromThisTaxon.relatedTo.name.taxonBases.relationsToThisTaxon", //$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$
"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", //$NON-NLS-1$
-// "synonyms.synonym.name.homotypicalGroup.typifiedNames", //$NON-NLS-1$
"synonyms.name.homotypicalGroup.typifiedNames.taxonBases.synonyms" //$NON-NLS-1$
});
* @param deleteConfig
*/
public void addTaxonBaseToDelete(TaxonBase selectedElement, TaxonBaseDeletionConfigurator deleteConfig) {
- this.toDelete.put(selectedElement, deleteConfig);
+ this.toDeletes.put(selectedElement, deleteConfig);
+
+ }
+ /**
+ * @param newName
+ */
+ public void addToSaveNewName(TaxonName newName) {
+ this.toSaveNewNames.add(newName);
}
}