eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/EditorUtil.java

   1 /**
   2  * Copyright (C) 2007 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.editor;
  10
  11 import java.util.Collection;
  12 import java.util.HashSet;
  13 import java.util.List;
  14 import java.util.UUID;
  15
  16 import org.eclipse.core.commands.ExecutionEvent;
  17 import org.eclipse.core.commands.operations.IOperationHistory;
  18 import org.eclipse.core.commands.operations.IUndoContext;
  19 import org.eclipse.e4.ui.model.application.MApplication;
  20 import org.eclipse.e4.ui.model.application.ui.basic.MPart;
  21 import org.eclipse.e4.ui.model.application.ui.basic.MPartStack;
  22 import org.eclipse.e4.ui.workbench.modeling.EModelService;
  23 import org.eclipse.e4.ui.workbench.modeling.EPartService;
  24 import org.eclipse.e4.ui.workbench.modeling.EPartService.PartState;
  25 import org.eclipse.jface.dialogs.MessageDialog;
  26 import org.eclipse.jface.viewers.ISelection;
  27 import org.eclipse.jface.viewers.IStructuredSelection;
  28 import org.eclipse.jface.viewers.TreeNode;
  29 import org.eclipse.swt.widgets.Shell;
  30 import org.eclipse.ui.IEditorPart;
  31 import org.eclipse.ui.handlers.HandlerUtil;
  32
  33 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  34 import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;
  35 import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;
  36 import eu.etaxonomy.cdm.model.occurrence.FieldUnit;
  37 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  38 import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
  39 import eu.etaxonomy.cdm.model.taxon.Synonym;
  40 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  41 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  42 import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
  43 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  44 import eu.etaxonomy.taxeditor.bulkeditor.e4.BulkEditor;
  45 import eu.etaxonomy.taxeditor.bulkeditor.input.TaxonBulkEditorInput;
  46 import eu.etaxonomy.taxeditor.editor.descriptiveDataSet.DescriptiveDataSetEditor;
  47 import eu.etaxonomy.taxeditor.editor.descriptiveDataSet.matrix.CharacterMatrixPart;
  48 import eu.etaxonomy.taxeditor.editor.e4.TaxonEditorInput;
  49 import eu.etaxonomy.taxeditor.editor.group.authority.CdmAuthorityEditorInput;
  50 import eu.etaxonomy.taxeditor.editor.group.authority.e4.CdmAuthorityEditorE4;
  51 import eu.etaxonomy.taxeditor.editor.internal.TaxeditorEditorPlugin;
  52 import eu.etaxonomy.taxeditor.editor.l10n.Messages;
  53 import eu.etaxonomy.taxeditor.editor.name.e4.TaxonEditor;
  54 import eu.etaxonomy.taxeditor.editor.view.checklist.e4.DistributionEditorPart;
  55 import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateView;
  56 import eu.etaxonomy.taxeditor.editor.view.derivate.DerivateViewEditorInput;
  57 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  58 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  59 import eu.etaxonomy.taxeditor.security.RequiredPermissions;
  60 import eu.etaxonomy.taxeditor.store.CdmStore;
  61 import eu.etaxonomy.taxeditor.workbench.WorkbenchUtility;
  62 import eu.etaxonomy.taxeditor.workbench.part.IE4SavablePart;
  63
  64 /**
  65  * Utility for the editor package
  66  *
  67  * @author n.hoffmann
  68  * @created 20.01.2009
  69  */
  70 public class EditorUtil extends AbstractUtility {
  71
  72     private static final String NAME_EDITOR_ID = "eu.etaxonomy.taxeditor.editor.name.e4.TaxonEditor";
  73
  74     private static boolean factsVisible = true;
  75
  76     private static boolean mediaVisible = true;
  77
  78     public static void openDescriptiveDataSetEditor(UUID descriptiveDataSetUuid, EModelService modelService, EPartService partService, MApplication application){
  79         Collection<MPart> parts = partService.getParts();
  80         for (MPart part : parts) {
  81             if(part.getObject() instanceof DescriptiveDataSetEditor
  82                 && ((DescriptiveDataSetEditor) part.getObject()).getDescriptiveDataSet().getUuid().equals(descriptiveDataSetUuid)){
  83                 partService.showPart(part, PartState.ACTIVATE);
  84                 return;
  85             }
  86         }
  87         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DESCRIPTIVEDATASET_DESCRIPTIVEDATASETEDITOR;
  88         MPart part = showPart(partId, modelService, partService, application);
  89         DescriptiveDataSetEditor editor = (DescriptiveDataSetEditor) part.getObject();
  90         editor.init(descriptiveDataSetUuid);
  91     }
  92
  93     public static void openCharacterMatrix(UUID descriptiveDataSetUuid, EModelService modelService, EPartService partService, MApplication application){
  94         Collection<MPart> parts = partService.getParts();
  95         for (MPart part : parts) {
  96             if(part.getObject() instanceof CharacterMatrixPart
  97                 && ((CharacterMatrixPart) part.getObject()).getDescriptiveDataSet().getUuid().equals(descriptiveDataSetUuid)){
  98                 partService.showPart(part, PartState.ACTIVATE);
  99                 return;
 100             }
 101         }
 102         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_DESCRIPTIVEDATASET_MATRIX_CHARACTERMATRIXPART;
 103         MPart part = showPart(partId, modelService, partService, application);
 104         CharacterMatrixPart editor = (CharacterMatrixPart) part.getObject();
 105         editor.init(descriptiveDataSetUuid, true);
 106     }
 107
 108     public static void openDistributionEditor(List<UuidAndTitleCache<ITaxonTreeNode>> parentTaxonUuidList, EModelService modelService, EPartService partService, MApplication application){
 109         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_CHECKLIST_E4_DISTRIBUTIONEDITORPART;
 110         checkAndCloseFactsAndMediaParts(partService);
 111         MPart part = showPart(partId, modelService, partService, application);
 112         DistributionEditorPart editor = (DistributionEditorPart) part.getObject();
 113         editor.init(parentTaxonUuidList);
 114     }
 115
 116     public static void checkAndCloseFactsAndMediaParts(EPartService partService) {
 117         String partIdFactualData = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DESCRIPTIVE_E4_FACTUALDATAPARTE4;
 118         String partIdMedia = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_MEDIA_E4_MEDIAVIEWPARTE4;
 119         MPart part1 = partService.findPart(AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DESCRIPTIVE_E4_FACTUALDATAPARTE4);
 120         if (factsVisible || (part1!=null && part1.getWidget() != null && partService.isPartVisible(part1))){
 121             factsVisible = true;
 122         }else{
 123             factsVisible = false;
 124         }
 125         part1 = partService.findPart(AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_MEDIA_E4_MEDIAVIEWPARTE4);
 126         if (mediaVisible || (part1!=null && part1.getWidget() != null && partService.isPartVisible(part1))){
 127             mediaVisible = true;
 128         }else{
 129             mediaVisible = false;
 130         }
 131         closePart(partIdMedia, partService);
 132         closePart(partIdFactualData, partService);
 133     }
 134
 135
 136     public static void openSpecimenEditor(DerivateViewEditorInput input, EModelService modelService, EPartService partService, MApplication application){
 137         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DERIVATE_DERIVATEVIEW;
 138         MPart part = showPart(partId, modelService, partService, application);
 139         DerivateView derivateView = (DerivateView) part.getObject();
 140         derivateView.init(input);
 141     }
 142
 143     public static void openRightsEditor(CdmAuthorityEditorInput input, EModelService modelService, EPartService partService, MApplication application){
 144         Collection<MPart> parts = partService.getParts();
 145         for (MPart part : parts) {
 146             if(part.getObject() instanceof CdmAuthorityEditorE4
 147                 && ((CdmAuthorityEditorE4) part.getObject()).getInput().getGroup().equals(input.getGroup())){
 148                 partService.showPart(part, PartState.ACTIVATE);
 149                 return;
 150             }
 151         }
 152         String partId = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_GROUP_AUTHORITY_E4_CDMAUTHORITYEDITORE4;
 153         MPart part = showPart(partId, modelService, partService, application);
 154         CdmAuthorityEditorE4 authorityView = (CdmAuthorityEditorE4) part.getObject();
 155         authorityView.init(input);
 156     }
 157
 158     public static MPart showPart(String partId, EModelService modelService, EPartService partService, MApplication application){
 159         MPart part = partService.findPart(partId);
 160         if(part==null || modelService.getPartDescriptor(partId).isAllowMultiple()){
 161             part = partService.createPart(partId);
 162         }
 163         MPartStack editorAreaPartStack = WorkbenchUtility.getEditorAreaPartStack(application, modelService);
 164         if(editorAreaPartStack!=null){
 165             editorAreaPartStack.getChildren().add(part);
 166         }
 167
 168         return partService.showPart(part, PartState.ACTIVATE);
 169     }
 170
 171     public static MPart showPart(String partId, EModelService modelService, EPartService partService){
 172         MPart part = partService.findPart(partId);
 173         if(part==null || modelService.getPartDescriptor(partId).isAllowMultiple()){
 174             part = partService.createPart(partId);
 175             partService.activate(part);
 176         }else{
 177             partService.activate(part);
 178         }
 179
 180        return part;
 181     }
 182
 183         public static void openTaxonNodeE4(UUID taxonNodeUuid, EModelService modelService, EPartService partService, MApplication application) {
 184             TaxonEditorInput input = TaxonEditorInput.NewInstance(taxonNodeUuid);
 185             openTaxonEditor_internal(input, modelService, partService, application);
 186         }
 187
 188         public static void openTaxonBaseE4(UUID taxonBaseUuid, EModelService modelService, EPartService partService, MApplication application) {
 189             TaxonEditorInput input = TaxonEditorInput.NewInstanceFromTaxonBase(taxonBaseUuid);
 190             openTaxonEditor_internal(input, modelService, partService, application);
 191         }
 192
 193     private static void openTaxonEditor_internal(TaxonEditorInput input, EModelService modelService, EPartService partService, MApplication application) {
 194         TaxonBase<?> taxonBase = input.getTaxon();
 195         TaxonNode node = input.getTaxonNode();
 196         if(taxonBase == null){
 197             return;
 198         }
 199         boolean hasPermission = false;
 200 //        if (node != null){
 201             hasPermission = CdmStore.currentAuthentiationHasPermission(node, RequiredPermissions.TAXON_EDIT);
 202 //        }
 203 //        if (!hasPermission){
 204 //            MessagingUtils.warningDialog(Messages.EditorUtil_MISSING_PERMISSION, TaxonEditorInputE4.class, Messages.EditorUtil_MISSING_PERMISSION_MESSAGE);
 205 //            return;
 206 //        }
 207         if (taxonBase.isOrphaned()) {
 208             if(taxonBase.isInstanceOf(Synonym.class)){
 209                 MessagingUtils.warningDialog(Messages.EditorUtil_ORPHAN_ACCEPTED_TAXON, TaxonEditorInput.class, Messages.EditorUtil_ORPHAN_ACCEPTED_TAXON_MESSAGE);
 210                 return;
 211             }
 212             else{
 213                 MessagingUtils.warningDialog(Messages.EditorUtil_ORPHAN_TAXON, TaxonEditorInput.class, Messages.EditorUtil_ORPHAN_TAXON_MESSAGE);
 214                 return;
 215             }
 216         }
 217
 218         Collection<MPart> parts = partService.getParts();
 219         //check if part is already opened
 220         MPart alreadyOpenInOtherClassification = null;
 221         for (MPart part : parts) {
 222                 if(part.getObject() instanceof TaxonEditor
 223                     && ((TaxonEditor) part.getObject()).getTaxon()!=null
 224                     && ((TaxonEditor) part.getObject()).getTaxon().getUuid().equals(input.getTaxon().getUuid())){
 225
 226                     UUID inputNode = input.getTaxonNode().getUuid();
 227                     UUID editorNode = ((TaxonEditor) part.getObject()).getTaxonNode().getUuid();
 228                     if (!inputNode.equals(editorNode)){
 229                         alreadyOpenInOtherClassification = part;
 230                     }else{
 231                         ((TaxonEditor) part.getObject()).init(input);
 232                         partService.activate(part, true);
 233                         return;
 234                     }
 235             }
 236         }
 237         if (alreadyOpenInOtherClassification != null){
 238             boolean doSave = forceUserSaveE4Editor(((TaxonEditor) alreadyOpenInOtherClassification.getObject()), getShell());
 239             if (doSave){
 240                 input = TaxonEditorInput.NewInstance(input.getTaxonNode().getUuid());
 241                 partService.hidePart(alreadyOpenInOtherClassification);
 242             }else {
 243                 return;
 244             }
 245         }
 246
 247         MPart part = showPart(NAME_EDITOR_ID, modelService, partService, application);
 248
 249         TaxonEditor editor = (TaxonEditor) part.getObject();
 250 //        editor.setDisabled();
 251         editor.init(input);
 252 //        editor.setEnabled();
 253         editor.setFocus();
 254     }
 255
 256     public static void showMedia(EModelService modelService, EPartService partService) {
 257         String partIdFactualData = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_MEDIA_E4_MEDIAVIEWPARTE4;
 258         showPart(partIdFactualData, modelService, partService);
 259     }
 260
 261     public static void showFacts(EModelService modelService, EPartService partService) {
 262         String partIdFactualData = AppModelId.PARTDESCRIPTOR_EU_ETAXONOMY_TAXEDITOR_EDITOR_VIEW_DESCRIPTIVE_E4_FACTUALDATAPARTE4;
 263         showPart(partIdFactualData, modelService, partService);
 264     }
 265
 266     public static Collection<MPart> checkForChanges(UUID taxonUUID, EPartService partService ){
 267         Collection<MPart> parts = partService.getParts();
 268         Collection<MPart> dirtyParts = new HashSet<>();
 269         //check if part is already opened
 270         boolean isDirty = false;
 271         for (MPart part : parts) {
 272             if(part.getObject() instanceof TaxonEditor
 273                     && ((TaxonEditor) part.getObject()).getTaxon()!=null
 274                     && ((TaxonEditor) part.getObject()).getTaxon().getUuid().equals(taxonUUID)){
 275                 if (part.isDirty()){
 276                     dirtyParts.add(part);
 277                 }
 278
 279                 break;
 280             }else if (taxonUUID == null){
 281                 if (part.isDirty()){
 282                     dirtyParts.add(part);
 283                 }
 284             }
 285         }
 286         return dirtyParts;
 287     }
 288
 289     public static Collection<IE4SavablePart> checkForTaxonChanges(UUID taxonUUID, EPartService partService ){
 290         Collection<MPart> parts = partService.getParts();
 291         Collection<IE4SavablePart> dirtyParts = new HashSet<>();
 292         //check if part is already opened
 293         for (MPart part : parts) {
 294             if(part.getObject() instanceof TaxonEditor
 295                     && ((TaxonEditor) part.getObject()).getTaxon()!=null
 296                     && ((TaxonEditor) part.getObject()).getTaxon().getUuid().equals(taxonUUID)){
 297                 if (part.isDirty()){
 298                     dirtyParts.add((IE4SavablePart) part);
 299                 }
 300
 301                 break;
 302             }else if (taxonUUID == null){
 303                 if (part.isDirty() && (part.getObject() instanceof TaxonEditor || (part.getObject() instanceof BulkEditor && ((BulkEditor)part.getObject()).getEditorInput() instanceof TaxonBulkEditorInput))){
 304                     dirtyParts.add((IE4SavablePart) part.getObject());
 305                 }
 306             }
 307         }
 308         return dirtyParts;
 309     }
 310
 311         /**
 312          * An uninitialized taxon is one that hasn't been saved yet. As such, it
 313          * should appear in neither the list of recent names nor in the taxonomic
 314          * tree when opened.
 315          *
 316          * @param parentNodeUuid
 317          *            a {@link java.util.UUID} object.
 318          */
 319         public static void openEmptyE4(UUID parentNodeUuid) {
 320                 TaxonEditorInput input = TaxonEditorInput
 321                                 .NewEmptyInstance(parentNodeUuid);
 322         EPartService partService = TaxeditorEditorPlugin.getDefault().getWorkbench().getActiveWorkbenchWindow().getService(EPartService.class);
 323         MPart part = partService.createPart(NAME_EDITOR_ID);
 324         part = partService.showPart(part, PartState.ACTIVATE);
 325         TaxonEditor editor = (TaxonEditor) part.getObject();
 326         editor.init(input);
 327         }
 328
 329         /**
 330          * <p>
 331          * getUndoContext
 332          * </p>
 333          *
 334          * @return a {@link org.eclipse.core.commands.operations.IUndoContext}
 335          *         object.
 336          */
 337         public static IUndoContext getUndoContext() {
 338                 return IOperationHistory.GLOBAL_UNDO_CONTEXT;
 339         }
 340
 341         public static boolean isFactsVisible() {
 342         return factsVisible;
 343     }
 344
 345     public static void setFactsVisible(boolean factsVisible) {
 346         EditorUtil.factsVisible = factsVisible;
 347     }
 348
 349     public static boolean isMediaVisible() {
 350         return mediaVisible;
 351     }
 352
 353     public static void setMediaVisible(boolean mediaVisible) {
 354         EditorUtil.mediaVisible = mediaVisible;
 355     }
 356
 357         public static boolean forceUserSave(IEditorPart editor, Shell shell) {
 358                 if (editor.isDirty()) {
 359
 360                         boolean doSave = MessageDialog
 361                                         .openConfirm(shell, Messages.EditorUtil_COMFIRM_SAVE,
 362                                                         Messages.EditorUtil_CONFIRM_SAVE_MESSAGE);
 363
 364                         if (!doSave) {
 365                                 return false;
 366                         }
 367
 368                         editor.doSave(AbstractUtility.getMonitor());
 369                 }
 370                 return true;
 371         }
 372
 373         public static boolean forceUserSaveE4Editor(IE4SavablePart editor, Shell shell) {
 374             if (editor.isDirty()) {
 375
 376                 boolean doSave = MessageDialog
 377                         .openConfirm(shell, Messages.EditorUtil_COMFIRM_SAVE,
 378                                 Messages.EditorUtil_CONFIRM_SAVE_MESSAGE);
 379
 380                 if (!doSave) {
 381                     return false;
 382                 }
 383
 384                 editor.save(AbstractUtility.getMonitor());
 385             }
 386             return true;
 387         }
 388
 389         /**
 390          * <p>
 391          * getSelection
 392          * </p>
 393          *
 394          * @param event
 395          *            a {@link org.eclipse.core.commands.ExecutionEvent} object.
 396          * @return a {@link org.eclipse.jface.viewers.IStructuredSelection} object.
 397          */
 398         public static IStructuredSelection getSelection(ExecutionEvent event) {
 399                 IEditorPart activeEditor = HandlerUtil.getActiveEditor(event);
 400
 401                 return (IStructuredSelection) activeEditor.getSite()
 402                                 .getSelectionProvider().getSelection();
 403         }
 404
 405         /**
 406          * <p>
 407          * getPluginId
 408          * </p>
 409          *
 410          * @return a {@link java.lang.String} object.
 411          */
 412         public static String getPluginId() {
 413                 return TaxeditorEditorPlugin.PLUGIN_ID;
 414         }
 415
 416         /**
 417          * Iterates recursively over all originals having the given specimen as a derivate.
 418          * The first {@link DerivedUnit} with no more originals or the first {@link FieldUnit} is returned
 419          * @param specimen the start element for which the originals are iterated recursively
 420          * @return either a FieldUnit or a the topmost DerivedUnit (which can be itself)
 421          */
 422         public static SpecimenOrObservationBase<?> getTopMostDerivate(SpecimenOrObservationBase<?> specimen){
 423             if(specimen==null){
 424                 return null;
 425             }
 426             if(specimen.isInstanceOf(FieldUnit.class)){
 427                 return specimen;
 428             }
 429             else if(specimen.isInstanceOf(DerivedUnit.class)){
 430                 DerivedUnit derivedUnit = HibernateProxyHelper.deproxy(specimen, DerivedUnit.class);
 431                 if(derivedUnit.getOriginals()!=null
 432                         && !(derivedUnit.getOriginals().isEmpty())){
 433                     for(SpecimenOrObservationBase<?> original:((DerivedUnit) specimen).getOriginals()){
 434                         return getTopMostDerivate(original);
 435                     }
 436                 }
 437             }
 438             return specimen;
 439         }
 440
 441     /**
 442      * If the current selection is a single {@link TreeNode} it will be returned.
 443      * @param selection the selection to check
 444      * @return the selected TreeNode or <code>null</code> if no TreeNode selected
 445      */
 446     public static TreeNode getTreeNodeOfSelection(ISelection selection){
 447         if(selection instanceof IStructuredSelection
 448                 && ((IStructuredSelection) selection).size()==1
 449                 && ((IStructuredSelection) selection).getFirstElement() instanceof TreeNode){
 450             return (TreeNode) ((IStructuredSelection) selection).getFirstElement();
 451
 452         }
 453         return null;
 454     }
 455
 456     public static void closeObsoleteEditor(TaxonNodeDto taxonNode, EPartService partService){
 457         String treeIndex = taxonNode.getTreeIndex();
 458         Collection<MPart> parts = partService.getParts();
 459         for (MPart part : parts) {
 460             Object object = part.getObject();
 461             if(object instanceof TaxonEditor){
 462                 TaxonEditor taxonEditor = (TaxonEditor)object;
 463                 TaxonNode node = taxonEditor.getEditorInput().getTaxonNode();
 464                 if (node.treeIndex()!= null){
 465                         if(node.treeIndex().startsWith(treeIndex)){
 466                             if (part.isDirty()){
 467                                 forceUserSaveE4Editor(taxonEditor, getShell());
 468                             }
 469                             partService.hidePart(part);
 470                         }
 471                 }else{
 472                         logger.debug("The taxonnode of taxon " + node.getTaxon().getTitleCache() + " uuid: " + node.getUuid() + " has no treeindex");;
 473                 }
 474             }
 475         }
 476     }
 477
 478     public static void closeObsoleteEditorWithChildren(TaxonNodeDto taxonNode, EPartService partService){
 479         String treeIndex = taxonNode.getTreeIndex();
 480         Collection<MPart> parts = partService.getParts();
 481         for (MPart part : parts) {
 482             Object object = part.getObject();
 483             if(object instanceof TaxonEditor){
 484                 TaxonEditor taxonEditor = (TaxonEditor)object;
 485                 TaxonNode node = taxonEditor.getEditorInput().getTaxonNode();
 486                 if (node.treeIndex()!= null){
 487                     if(node.treeIndex().startsWith(treeIndex)){
 488                         if (part.isDirty()){
 489                             forceUserSaveE4Editor(taxonEditor, getShell());
 490                         }
 491                         partService.hidePart(part);
 492                     }
 493                 }else{
 494                     logger.debug("The taxonnode of taxon " + node.getTaxon().getTitleCache() + " uuid: " + node.getUuid() + " has no treeindex");;
 495                 }
 496             }
 497         }
 498     }
 499
 500     public static void closeObsoleteDescriptiveDatasetEditor(UUID datasetUuid, EPartService partService){
 501
 502         Collection<MPart> parts = partService.getParts();
 503         for (MPart part : parts) {
 504             Object object = part.getObject();
 505             if(object instanceof DescriptiveDataSetEditor){
 506                 DescriptiveDataSetEditor editor = (DescriptiveDataSetEditor)object;
 507                 DescriptiveDataSet descDataSet = editor.getDescriptiveDataSet();
 508                 if(descDataSet.getUuid().equals(datasetUuid)){
 509                     if (part.isDirty()){
 510                         forceUserSaveE4Editor(editor, getShell());
 511                     }
 512                     partService.hidePart(part);
 513                 }
 514
 515             }
 516         }
 517     }
 518
 519     public static void closePart(String partID, EPartService partService){
 520
 521         Collection<MPart> parts = partService.getParts();
 522         for (MPart part : parts) {
 523             String elementId = part.getElementId();
 524             if (elementId.equals(partID)){
 525                 partService.hidePart(part);
 526             }
 527         }
 528     }
 529
 530     public static void updateEditor(TaxonNode taxonNode, TaxonEditor editor){
 531         String treeIndex = taxonNode.treeIndex();
 532         TaxonNode node = editor.getEditorInput().getTaxonNode();
 533         if(node.treeIndex().equals(treeIndex)){
 534                 TaxonEditorInput input = TaxonEditorInput.NewInstance(node.getUuid());
 535                 editor.init(input);
 536         }
 537     }
 538 }