eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/bulkeditor/referencingobjects/ReferencingObjectsView.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
  10 package eu.etaxonomy.taxeditor.bulkeditor.referencingobjects;
  11
  12 import java.util.ArrayList;
  13 import java.util.Collections;
  14 import java.util.Comparator;
  15 import java.util.List;
  16 import java.util.Set;
  17 import java.util.UUID;
  18
  19 import org.apache.log4j.Logger;
  20 import org.eclipse.core.runtime.IProgressMonitor;
  21 import org.eclipse.core.runtime.IStatus;
  22 import org.eclipse.core.runtime.Status;
  23 import org.eclipse.core.runtime.jobs.Job;
  24 import org.eclipse.jface.action.MenuManager;
  25 import org.eclipse.jface.viewers.CellEditor;
  26 import org.eclipse.jface.viewers.ICellModifier;
  27 import org.eclipse.jface.viewers.ISelection;
  28 import org.eclipse.jface.viewers.IStructuredSelection;
  29 import org.eclipse.jface.viewers.ITableLabelProvider;
  30 import org.eclipse.jface.viewers.TableViewer;
  31 import org.eclipse.jface.viewers.TableViewerColumn;
  32 import org.eclipse.jface.viewers.TextCellEditor;
  33 import org.eclipse.jface.viewers.TreeNode;
  34 import org.eclipse.jface.viewers.Viewer;
  35 import org.eclipse.swt.SWT;
  36 import org.eclipse.swt.widgets.Composite;
  37 import org.eclipse.swt.widgets.Control;
  38 import org.eclipse.swt.widgets.Display;
  39 import org.eclipse.swt.widgets.Menu;
  40 import org.eclipse.swt.widgets.Table;
  41 import org.eclipse.ui.IWorkbenchPart;
  42 import org.springframework.remoting.RemoteAccessException;
  43
  44 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  45 import eu.etaxonomy.cdm.api.service.IAgentService;
  46 import eu.etaxonomy.cdm.api.service.IDescriptionService;
  47 import eu.etaxonomy.cdm.api.service.IEventBaseService;
  48 import eu.etaxonomy.cdm.api.service.IGroupService;
  49 import eu.etaxonomy.cdm.api.service.IMediaService;
  50 import eu.etaxonomy.cdm.api.service.INameService;
  51 import eu.etaxonomy.cdm.api.service.IOccurrenceService;
  52 import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;
  53 import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;
  54 import eu.etaxonomy.cdm.api.service.IReferenceService;
  55 import eu.etaxonomy.cdm.api.service.ITaxonService;
  56 import eu.etaxonomy.cdm.api.service.ITermService;
  57 import eu.etaxonomy.cdm.api.service.IUserService;
  58 import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
  59 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  60 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  61 import eu.etaxonomy.cdm.model.common.CdmBase;
  62 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  63 import eu.etaxonomy.cdm.model.common.EventBase;
  64 import eu.etaxonomy.cdm.model.common.Group;
  65 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  66 import eu.etaxonomy.cdm.model.common.User;
  67 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  68 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  69 import eu.etaxonomy.cdm.model.description.PolytomousKey;
  70 import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
  71 import eu.etaxonomy.cdm.model.media.Media;
  72 import eu.etaxonomy.cdm.model.molecular.Sequence;
  73 import eu.etaxonomy.cdm.model.name.NonViralName;
  74 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  75 import eu.etaxonomy.cdm.model.reference.Reference;
  76 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  77 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  78 import eu.etaxonomy.taxeditor.model.DescriptionHelper;
  79 import eu.etaxonomy.taxeditor.store.CdmStore;
  80 import eu.etaxonomy.taxeditor.view.AbstractCdmViewPart;
  81
  82 /**
  83  * @author p.ciardelli
  84  * @created 08.07.2009
  85  * @version 1.0
  86  */
  87 public class ReferencingObjectsView extends AbstractCdmViewPart {
  88         private static final Logger logger = Logger
  89                         .getLogger(ReferencingObjectsView.class);
  90
  91         public static final String ID = "eu.etaxonomy.taxeditor.bulkeditor.view.referencingobjects";
  92
  93         private TableViewer viewer;
  94
  95         private String referencedObjectTitleCache;
  96         private ConversationHolder conversation;
  97         //private final ICdmEntitySession cdmEntitySession;
  98         private UUID actualUuid;
  99         List<CdmBase> referencingObjects = null;
 100         Set<CdmBase> referencingObjectsSet = null;
 101         IProgressMonitor actualMonitor = null;
 102         private Job currentJob = null;
 103
 104         public ReferencingObjectsView() {
 105           // cdmEntitySession = CdmStore.getCurrentSessionManager().getNullSession();
 106
 107                 //cdmEntitySession = CdmStore.getCurrentSessionManager().bindNullSession();
 108         }
 109
 110         /** {@inheritDoc} */
 111         @Override
 112         public void createViewer(Composite parent) {
 113                 selectionService.addSelectionListener(this);
 114                 conversation = CdmStore.createConversation();
 115                 viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
 116                                 | SWT.V_SCROLL | SWT.FULL_SELECTION);
 117                 createColumns(viewer);
 118                 viewer.setContentProvider(new ReferencingObjectsContentProvider());
 119                 viewer.setLabelProvider(new ReferencingObjectsLabelProvider());
 120
 121                 viewer.setCellModifier(new ICellModifier() {
 122             @Override
 123             public void modify(Object element, String property, Object value) {
 124             }
 125
 126             @Override
 127             public Object getValue(Object element, String property) {
 128                 ITableLabelProvider tableLabelProvider = null;
 129                 if(viewer.getLabelProvider() instanceof ITableLabelProvider){
 130                     tableLabelProvider = (ITableLabelProvider) viewer.getLabelProvider();
 131                 }
 132                 Object[] columnProperties = viewer.getColumnProperties();
 133                 for (int i=0;i<columnProperties.length;i++) {
 134                     if(columnProperties[i].equals(property) && tableLabelProvider!=null){
 135                         return tableLabelProvider.getColumnText(element, i);
 136                     }
 137                 }
 138                 return "";
 139             }
 140
 141             @Override
 142             public boolean canModify(Object element, String property) {
 143                 return true;
 144             }
 145         });
 146
 147         //create context menu
 148         MenuManager menuManager = new MenuManager();
 149         getSite().registerContextMenu(menuManager, viewer);
 150         Control control = viewer.getControl();
 151         Menu menu = menuManager.createContextMenu(control);
 152         menuManager.setRemoveAllWhenShown(true);
 153         control.setMenu(menu);
 154
 155         // Propagate selection from viewer
 156         getSite().setSelectionProvider(viewer);
 157         }
 158
 159         /**
 160          * Create the columns for the table
 161          * @param viewer
 162          */
 163         private void createColumns(TableViewer viewer) {
 164                 Table table = viewer.getTable();
 165                 String[] titles = {"Class", "Description", "UUID", "Object ID" };
 166                 int[] bounds = { 100, 200, 100, 70};
 167
 168         CellEditor[] editors = new CellEditor[titles.length];
 169
 170                 for (int i = 0; i < titles.length; i++) {
 171                         TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 172                         editors[i] = new TextCellEditor(table);
 173                         column.getColumn().setText(titles[i]);
 174                         column.getColumn().setWidth(bounds[i]);
 175                         column.getColumn().setResizable(true);
 176                         column.getColumn().setMoveable(true);
 177                 }
 178                 table.setHeaderVisible(true);
 179                 table.setLinesVisible(true);
 180
 181                 viewer.setCellEditors(editors);
 182                 viewer.setColumnProperties(titles);
 183         }
 184
 185         @Override
 186         public void setFocus() {
 187            // cdmEntitySession.bind();
 188         }
 189
 190         public void updateReferencingObjects(final UUID entityUUID, final Class objectClass) {
 191             if (actualUuid == entityUUID){
 192                 return ;
 193             }
 194
 195             if(actualMonitor!=null && !actualMonitor.isCanceled()){
 196 //              boolean success = false;
 197 //              //wait for cancel to be done
 198 //              while(!success){
 199 //                  success = currentJob.cancel();
 200 //              }
 201 //              currentJob = null;
 202                 while(!actualMonitor.isCanceled()){
 203                     actualMonitor.setCanceled(true);
 204                 }
 205
 206             }
 207             showEmptyPage();
 208                 currentJob = new Job("Update Referencing Objects") {
 209
 210                         @Override
 211                         protected IStatus run(final IProgressMonitor monitor) {
 212                                 monitor.beginTask("Calculating referencing objects", 100);
 213                                 actualUuid = entityUUID;
 214
 215                                 monitor.worked(5);
 216                                 referencingObjects = new ArrayList<>();
 217                                 if(monitor.isCanceled()) {
 218                                     actualUuid = null;
 219                     return Status.CANCEL_STATUS;
 220                 }
 221                                 if (actualMonitor != null){
 222                                     actualMonitor.setCanceled(true);
 223
 224                                 }
 225                                 actualMonitor = monitor;
 226                                 if (entityUUID != null){
 227 //                                  ICdmEntitySession previousCdmEntitySession = CdmStore.getCurrentSessionManager().getActiveSession();
 228 //                      cdmEntitySession.bind();
 229                         referencingObjectsSet = getReferencingObjects(entityUUID, objectClass);
 230
 231                         if(monitor.isCanceled()) {
 232                             actualUuid = null;
 233
 234                             return Status.CANCEL_STATUS;
 235                         }
 236                         monitor.worked(30);
 237                         referencingObjects = sortReferencing();
 238                         if (referencingObjects == null){
 239                             if (monitor.isCanceled()){
 240                                 actualUuid = null;
 241
 242                                 return Status.CANCEL_STATUS;
 243                             }
 244                         }
 245
 246                         if(monitor.isCanceled()) {
 247 //                          if(previousCdmEntitySession != null) {
 248 //                              previousCdmEntitySession.bind();
 249 //                          }
 250
 251                             return Status.CANCEL_STATUS;
 252                         }
 253                         monitor.worked(80);
 254
 255                         updateView();
 256 //                      if(previousCdmEntitySession != null) {
 257 //                          previousCdmEntitySession.bind();
 258 //                      }else{
 259 //                              CdmStore.getCurrentSessionManager().bind(null);
 260 //                      }
 261                        // actualUuid = entityUUID;
 262                                 }
 263                                 monitor.done();
 264                                 actualMonitor = null;
 265
 266                                 return Status.OK_STATUS;
 267
 268
 269                         }
 270                 };
 271                 currentJob.setUser(true);
 272
 273                 currentJob.schedule();
 274         }
 275
 276         private Set<CdmBase> getReferencingObjects(UUID entity, Class objectClass) {
 277                 CdmBase referencedObject = null;
 278         try {
 279                 if (objectClass.getSuperclass().equals(TeamOrPersonBase.class) ){
 280                         referencedObject = CdmStore.getService(IAgentService.class).load(entity);
 281                 } else if (objectClass.getSuperclass().equals(NonViralName.class)){
 282                         referencedObject = CdmStore.getService(INameService.class).load(entity);
 283                 } else if (objectClass.getSuperclass().equals(TaxonBase.class)){
 284                         referencedObject = CdmStore.getService(ITaxonService.class).load(entity);
 285                 } else if (objectClass.equals(Reference.class)){
 286                         referencedObject = CdmStore.getService(IReferenceService.class).load(entity);
 287                 } else if (objectClass.getSuperclass().equals(SpecimenOrObservationBase.class)){
 288                         referencedObject = CdmStore.getService(IOccurrenceService.class).load(entity);
 289                 } else if (objectClass.isAssignableFrom(User.class)){
 290                         referencedObject = CdmStore.getService(IUserService.class).load(entity);
 291                 } else if (objectClass.isAssignableFrom(Group.class)){
 292                         referencedObject = CdmStore.getService(IGroupService.class).load(entity);
 293                 } else if (objectClass.isAssignableFrom(Media.class)){
 294                     referencedObject = CdmStore.getService(IMediaService.class).load(entity);
 295                 } else if (DescriptionBase.class.isAssignableFrom(objectClass)){
 296                     referencedObject = CdmStore.getService(IDescriptionService.class).load(entity);
 297                 } else if (DescriptionElementBase.class.isAssignableFrom(objectClass)){
 298                 referencedObject = CdmStore.getService(IDescriptionService.class).loadDescriptionElement(entity, null);
 299             } else if (objectClass.equals(Sequence.class)){
 300                 referencedObject = CdmStore.getService(ISequenceService.class).load(entity, null);
 301             } else if (PolytomousKey.class.isAssignableFrom(objectClass)){
 302                 referencedObject = CdmStore.getService(IPolytomousKeyService.class).load(entity, null);
 303             } else if (PolytomousKeyNode.class.isAssignableFrom(objectClass)){
 304                 referencedObject = CdmStore.getService(IPolytomousKeyNodeService.class).load(entity, null);
 305             } else if (DefinedTermBase.class.isAssignableFrom(objectClass)){
 306                 referencedObject = CdmStore.getService(ITermService.class).load(entity, null);
 307             } else if (EventBase.class.isAssignableFrom(objectClass)){
 308                 referencedObject = CdmStore.getService(IEventBaseService.class).load(entity, null);
 309             } else if (User.class.isAssignableFrom(objectClass)){
 310                 referencedObject = CdmStore.getService(IUserService.class).load(entity, null);
 311             } else if (Group.class.isAssignableFrom(objectClass)){
 312                 referencedObject = CdmStore.getService(IGroupService.class).load(entity, null);
 313             }
 314             else if(CdmBase.class.isAssignableFrom(objectClass)){
 315                 referencedObject = CdmStore.getCommonService().find(objectClass, entity);
 316             }
 317                         //referencedObject =(CdmBase) CdmStore.getService(IIdentifiableEntityService.class).load(referencedObject.getUuid());
 318                 Set<CdmBase> setOfReferencingObjects = null;
 319
 320                 if (referencedObject != null){
 321                     if(referencedObject.isInstanceOf(IdentifiableEntity.class)){
 322                         referencedObjectTitleCache = (HibernateProxyHelper.deproxy(referencedObject, IdentifiableEntity.class)).getTitleCache();
 323                     }
 324                     else if(referencedObject.isInstanceOf(DescriptionElementBase.class)){
 325                         referencedObjectTitleCache = DescriptionHelper.getLabel(referencedObject);
 326                     }
 327                     else if (referencedObject.isInstanceOf(User.class)){
 328                         referencedObjectTitleCache = ((User)referencedObject).getUsername();
 329                     }else{
 330                         referencedObjectTitleCache = null;
 331                     }
 332                         setOfReferencingObjects = CdmStore.getCommonService().getReferencingObjects(referencedObject);
 333                         return setOfReferencingObjects;
 334                 }
 335
 336         } catch (Exception e) {
 337             logger.debug("Error retrieving referencing objects", e);
 338             e.printStackTrace();
 339             updateDescription("The referencing objects view could not be loaded completely. Some Problems occured.");
 340         }
 341                 return null;
 342         }
 343         private List<CdmBase> sortReferencing(){
 344
 345             if (referencingObjectsSet != null){
 346             List<CdmBase> referencingObjects = new ArrayList<CdmBase>(referencingObjectsSet);
 347             try{
 348                 Collections.sort(referencingObjects, new ReferencingClassComparator());
 349             }catch (RemoteAccessException e){
 350                 logger.debug(e.getStackTrace());
 351                 return null;
 352             }
 353             return referencingObjects;
 354
 355         }
 356
 357             return null;
 358         }
 359
 360
 361         class ReferencingClassComparator implements Comparator<CdmBase>   {
 362
 363                 @Override
 364         public int compare(CdmBase o1, CdmBase o2) {
 365                         String string1 = o1.getClass().getSimpleName();
 366                         String string2 = o2.getClass().getSimpleName();
 367                         int result = string1.compareToIgnoreCase(string2);
 368                         if (result == 0) {
 369                                 string1 = DescriptionHelper.getObjectDescription(o1);
 370                                 string2 = DescriptionHelper.getObjectDescription(o2);
 371
 372                                 result = string1.compareToIgnoreCase(string2);
 373                                 if (result == 0){
 374                                     return o1.getUuid().compareTo(o2.getUuid());
 375                                 }
 376                         }
 377                                 return result;
 378                 }
 379         }
 380
 381         private void updateView() {
 382             Display.getDefault().asyncExec(new Runnable() {
 383             @Override
 384             public void run() {
 385
 386                         if (viewer != null && !viewer.getControl().isDisposed()){
 387                                 try{
 388                                         viewer.setInput(referencingObjects);
 389
 390                                         showViewer();
 391
 392                                         //enable/disable table
 393                                         viewer.getControl().setEnabled(referencingObjects!=null);
 394                                 }catch(Exception e){
 395                                     e.printStackTrace();
 396                                     logger.debug(e.getStackTrace());
 397                                     updateDescription("The referencing objects view could not be loaded completely. Some Problems occured.");
 398                                 }
 399
 400                         }
 401             }
 402             });
 403         }
 404
 405
 406         private void updateDescription(final String description){
 407             Display.getDefault().asyncExec(new Runnable() {
 408             @Override
 409             public void run() {
 410                 if (referencedObjectTitleCache != null){
 411                     setContentDescription(description);
 412                 } else {
 413                     setContentDescription(description);
 414                 }
 415
 416             }
 417
 418          });
 419          }
 420
 421         /** {@inheritDoc} */
 422         @Override
 423     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 424         if(part == this){
 425             return;
 426         }
 427
 428         if(selection instanceof IStructuredSelection){
 429                 //referencedObjectTitleCache = null;
 430                 showViewer(part, (IStructuredSelection) selection);
 431         }
 432         }
 433
 434         /** {@inheritDoc} */
 435         @Override
 436         public void showViewer(Object part, IStructuredSelection selection) {
 437         //      this.part = part;
 438
 439                 Object firstElement = selection.getFirstElement();
 440                 if(firstElement instanceof TreeNode){
 441                     firstElement = ((TreeNode) firstElement).getValue();
 442                 }
 443                 if(firstElement instanceof CdmBase){
 444                     CdmBase referencedCdmObject = (CdmBase) firstElement;
 445                     if (referencedCdmObject.getUuid() == actualUuid){
 446                         return;
 447                     }
 448                     if (referencedCdmObject != null){
 449                 if(referencedCdmObject.isInstanceOf(IdentifiableEntity.class)){
 450                     referencedObjectTitleCache = (HibernateProxyHelper.deproxy(referencedCdmObject, IdentifiableEntity.class)).getTitleCache();
 451                 }
 452                 else if(referencedCdmObject.isInstanceOf(DescriptionElementBase.class)){
 453                     referencedObjectTitleCache = DescriptionHelper.getLabel(referencedCdmObject);
 454                 }
 455                 else if (referencedCdmObject.isInstanceOf(User.class)){
 456                     referencedObjectTitleCache = ((User)referencedCdmObject).getUsername();
 457                 }else if (referencedCdmObject.isInstanceOf(TaxonNode.class)){
 458                     referencedObjectTitleCache = "TaxonNode of "+(HibernateProxyHelper.deproxy(referencedCdmObject, TaxonNode.class)).getTaxon().getTitleCache();
 459                 }
 460                     }
 461                     if (referencedObjectTitleCache != null){
 462                         updateDescription("'" + referencedObjectTitleCache + "' is referenced by:");
 463                     } else{
 464                         updateDescription("");
 465                     }
 466
 467                     updateReferencingObjects(referencedCdmObject.getUuid(),firstElement.getClass() );
 468
 469                 }
 470                 else if (firstElement != null){
 471                     updateView();
 472             updateDescription("");
 473                 }
 474         }
 475
 476         /** {@inheritDoc} */
 477         @Override
 478         public void dispose() {
 479                 conversation.close();
 480                 selectionService.removePostSelectionListener(this);
 481                 selectionService.removeSelectionListener(this);
 482                 //cdmEntitySession.dispose();
 483                 super.dispose();
 484
 485         }
 486
 487         /** {@inheritDoc} */
 488         @Override
 489         public Viewer getViewer() {
 490                 return viewer;
 491         }
 492
 493         /** {@inheritDoc} */
 494         @Override
 495         public void changed(Object object) {
 496                 // no editing in this view
 497         }
 498
 499         /** {@inheritDoc} */
 500         @Override
 501         public boolean onComplete() {
 502                 return false;
 503         }
 504
 505         public void refresh(){
 506                 selectionService.removePostSelectionListener(this);
 507                 selectionService.removeSelectionListener(this);
 508                 selectionService.addPostSelectionListener(this);
 509                 selectionService.addSelectionListener(this);
 510
 511         }
 512
 513         @Override
 514         protected String getViewName() {
 515                 return "Referencing Objects";
 516         }
 517
 518 }