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.jface.resource.ImageDescriptor;
-import org.eclipse.ui.IEditorInput;
-import org.eclipse.ui.IMemento;
-import org.eclipse.ui.IPersistableElement;
+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.TaxonEditorInputFactory;
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.IPostOperationEnabled;
import eu.etaxonomy.taxeditor.preference.PreferencesUtil;
import eu.etaxonomy.taxeditor.store.CdmStore;
+import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
/**
* @date Aug 24, 2017
*
*/
-public class TaxonEditorInputE4 extends CdmEntitySessionInput implements IEditorInput, IConversationEnabled, IPersistableElement {
+public class TaxonEditorInputE4 extends CdmEntitySessionInput implements IConversationEnabled {
private static final String INCORRECT_STATE = Messages.TaxonEditorInput_INCORRECT_STATE;
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<AbstractPostOperation> 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);
}
init(taxonNode);
+ setInitiallySelectedTaxonBase(getTaxon());
}
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()){
// 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());
taxa.add(taxon);
}
setInputForMultipleTaxa(conversation, taxa);
+ setInitiallySelectedTaxonBase(synonym);
}
}
}
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 = 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 new TaxonEditorInputE4(parentNodeUuid, CdmType.PARENT_TAXON_NODE);
}
- @Override
- public boolean exists() {
- return taxonNode != null;
- }
-
- @Override
- public ImageDescriptor getImageDescriptor() {
- return null;
- }
-
- @Override
- public String getName() {
- if(getTaxon() == null){
- return null;
- }
- TaxonName name = getTaxon().getName();
- if (name == null || name.getTitleCache() == null) {
- return Messages.TaxonEditorInput_NEW_TAXON;
- } else {
- return name.getTitleCache();
- }
- }
-
- @Override
- public IPersistableElement getPersistable() {
- return null;
- }
-
- @Override
- public String getToolTipText() {
- return getName();
- }
-
- /** {@inheritDoc} */
- @Override
public Object getAdapter(Class adapter) {
if (adapter == Taxon.class) {
}
public Taxon getTaxon(){
- Taxon taxon = CdmBase.deproxy(taxonNode.getTaxon(), Taxon.class);
- return taxon;
+ if(taxonNode!=null){
+ Taxon taxon = CdmBase.deproxy(taxonNode.getTaxon(), Taxon.class);
+ return taxon;
+ }
+ return null;
}
public TaxonNode getTaxonNode() {
DataChangeBridge.handleDataChange(events, dataChangeBehavior);
}
- @Override
- public String getFactoryId() {
- return TaxonEditorInputFactory.getFactoryId();
+ public void setInitiallySelectedTaxonBase(TaxonBase taxonBase) {
+ this.initiallySelectedTaxonBase = taxonBase;
}
- /** {@inheritDoc} */
- @Override
- public void saveState(IMemento memento) {
- TaxonEditorInputFactoryE4.saveState(memento, this);
+ public TaxonBase getInitiallySelectedTaxonBase() {
+ return initiallySelectedTaxonBase;
}
+ public void addOperation(AbstractPostOperation operation) {
+ this.operations.add(operation);
+ }
- public void setInitiallySelectedTaxonBase(TaxonBase taxonBase) {
- this.initiallySelectedTaxonBase = taxonBase;
+ public void addToSaveNewSynonym(Synonym toSaveNew) {
+ this.toSaveNewSynonyms.add(toSaveNew);
}
+ public void addToSaveNewConcept(Taxon toSaveNew) {
+ this.toSaveNewConcepts.add(toSaveNew);
- public TaxonBase getInitiallySelectedTaxonBase() {
- return initiallySelectedTaxonBase;
}
@Override
@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){
+ 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());
+// }
+
+ }
+ }
+
+ 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