eu.etaxonomy.taxeditor.bulkeditor/src/main/java/eu/etaxonomy/taxeditor/bulkeditor/referencingobjects/ReferencingObjectsView.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.taxeditor.bulkeditor.referencingobjects;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collections;
  15 import java.util.Comparator;
  16 import java.util.List;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import org.apache.log4j.Logger;
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.core.runtime.IStatus;
  23 import org.eclipse.core.runtime.Status;
  24 import org.eclipse.core.runtime.jobs.Job;
  25 import org.eclipse.jface.action.MenuManager;
  26 import org.eclipse.jface.viewers.CellEditor;
  27 import org.eclipse.jface.viewers.ICellModifier;
  28 import org.eclipse.jface.viewers.ISelection;
  29 import org.eclipse.jface.viewers.IStructuredSelection;
  30 import org.eclipse.jface.viewers.ITableLabelProvider;
  31 import org.eclipse.jface.viewers.TableViewer;
  32 import org.eclipse.jface.viewers.TableViewerColumn;
  33 import org.eclipse.jface.viewers.TextCellEditor;
  34 import org.eclipse.jface.viewers.TreeNode;
  35 import org.eclipse.jface.viewers.Viewer;
  36 import org.eclipse.swt.SWT;
  37 import org.eclipse.swt.widgets.Composite;
  38 import org.eclipse.swt.widgets.Control;
  39 import org.eclipse.swt.widgets.Display;
  40 import org.eclipse.swt.widgets.Menu;
  41 import org.eclipse.swt.widgets.Table;
  42 import org.eclipse.ui.IWorkbenchPart;
  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.IReferenceService;
  53 import eu.etaxonomy.cdm.api.service.ITaxonService;
  54 import eu.etaxonomy.cdm.api.service.ITermService;
  55 import eu.etaxonomy.cdm.api.service.IUserService;
  56 import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
  57 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  58 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  59 import eu.etaxonomy.cdm.model.common.CdmBase;
  60 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  61 import eu.etaxonomy.cdm.model.common.EventBase;
  62 import eu.etaxonomy.cdm.model.common.Group;
  63 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  64 import eu.etaxonomy.cdm.model.common.User;
  65 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  66 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  67 import eu.etaxonomy.cdm.model.media.Media;
  68 import eu.etaxonomy.cdm.model.molecular.Sequence;
  69 import eu.etaxonomy.cdm.model.name.NonViralName;
  70 import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
  71 import eu.etaxonomy.cdm.model.reference.Reference;
  72 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  73 import eu.etaxonomy.taxeditor.model.DescriptionHelper;
  74 import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
  75 import eu.etaxonomy.taxeditor.store.CdmStore;
  76 import eu.etaxonomy.taxeditor.view.AbstractCdmViewPart;
  77
  78 /**
  79  * @author p.ciardelli
  80  * @created 08.07.2009
  81  * @version 1.0
  82  */
  83 public class ReferencingObjectsView extends AbstractCdmViewPart {
  84         private static final Logger logger = Logger
  85                         .getLogger(ReferencingObjectsView.class);
  86
  87         public static final String ID = "eu.etaxonomy.taxeditor.bulkeditor.view.referencingobjects";
  88
  89         private TableViewer viewer;
  90
  91         private String referencedObjectTitleCache;
  92         private ConversationHolder conversation;
  93         private final ICdmEntitySession cdmEntitySession;
  94
  95         public ReferencingObjectsView() {
  96             cdmEntitySession = CdmStore.getCurrentSessionManager().bindNullSession();
  97         }
  98
  99         /** {@inheritDoc} */
 100         @Override
 101         public void createViewer(Composite parent) {
 102                 selectionService.addSelectionListener(this);
 103                 conversation = CdmStore.createConversation();
 104                 viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
 105                                 | SWT.V_SCROLL | SWT.FULL_SELECTION);
 106                 createColumns(viewer);
 107                 viewer.setContentProvider(new ReferencingObjectsContentProvider());
 108                 viewer.setLabelProvider(new ReferencingObjectsLabelProvider());
 109                 viewer.setCellModifier(new ICellModifier() {
 110             @Override
 111             public void modify(Object element, String property, Object value) {
 112             }
 113
 114             @Override
 115             public Object getValue(Object element, String property) {
 116                 ITableLabelProvider tableLabelProvider = null;
 117                 if(viewer.getLabelProvider() instanceof ITableLabelProvider){
 118                     tableLabelProvider = (ITableLabelProvider) viewer.getLabelProvider();
 119                 }
 120                 Object[] columnProperties = viewer.getColumnProperties();
 121                 for (int i=0;i<columnProperties.length;i++) {
 122                     if(columnProperties[i].equals(property) && tableLabelProvider!=null){
 123                         return tableLabelProvider.getColumnText(element, i);
 124                     }
 125                 }
 126                 return "";
 127             }
 128
 129             @Override
 130             public boolean canModify(Object element, String property) {
 131                 return true;
 132             }
 133         });
 134
 135         //create context menu
 136         MenuManager menuManager = new MenuManager();
 137         getSite().registerContextMenu(menuManager, viewer);
 138         Control control = viewer.getControl();
 139         Menu menu = menuManager.createContextMenu(control);
 140         control.setMenu(menu);
 141
 142         // Propagate selection from viewer
 143         getSite().setSelectionProvider(viewer);
 144         }
 145
 146         /**
 147          * Create the columns for the table
 148          * @param viewer
 149          */
 150         private void createColumns(TableViewer viewer) {
 151                 Table table = viewer.getTable();
 152                 String[] titles = {"Class", "Description", "UUID", "Object ID" };
 153                 int[] bounds = { 100, 200, 100, 70};
 154
 155         CellEditor[] editors = new CellEditor[titles.length];
 156
 157                 for (int i = 0; i < titles.length; i++) {
 158                         TableViewerColumn column = new TableViewerColumn(viewer, SWT.NONE);
 159                         editors[i] = new TextCellEditor(table);
 160                         column.getColumn().setText(titles[i]);
 161                         column.getColumn().setWidth(bounds[i]);
 162                         column.getColumn().setResizable(true);
 163                         column.getColumn().setMoveable(true);
 164                 }
 165                 table.setHeaderVisible(true);
 166                 table.setLinesVisible(true);
 167
 168                 viewer.setCellEditors(editors);
 169                 viewer.setColumnProperties(titles);
 170         }
 171
 172         @Override
 173         public void setFocus() {
 174             cdmEntitySession.bind();
 175         }
 176
 177         public void updateReferencingObjects(final UUID entityUUID, final Class objectClass) {
 178
 179                 final Display display = Display.getCurrent();
 180
 181                 Job job = new Job("Update Referencing Objects") {
 182
 183                         @Override
 184                         protected IStatus run(IProgressMonitor monitor) {
 185                                 monitor.beginTask("Calculating referencing objects", 10);
 186
 187                                 monitor.worked(3);
 188
 189                                 display.asyncExec(new Runnable() {
 190
 191                                         @Override
 192                                         public void run() {
 193                                                 if (entityUUID != null){
 194                                                     ICdmEntitySession previousCdmEntitySession = CdmStore.getCurrentSessionManager().getActiveSession();
 195                                                     cdmEntitySession.bind();
 196                                                         List<CdmBase> referencingObjects = getReferencingObjects(entityUUID, objectClass);
 197                                                         if(previousCdmEntitySession != null) {
 198                                                             previousCdmEntitySession.bind();
 199                                                         }
 200                                                         updateView(referencingObjects);
 201
 202                                                 }
 203                                         }
 204                                 });
 205
 206                                 monitor.done();
 207
 208
 209                                 return Status.OK_STATUS;
 210                         }
 211                 };
 212
 213                 job.setPriority(Job.DECORATE);
 214                 job.schedule();
 215         }
 216
 217         private List<CdmBase> getReferencingObjects(UUID entity, Class objectClass) {
 218                 CdmBase referencedObject = null;
 219         try {
 220                 if (objectClass.getSuperclass().equals(TeamOrPersonBase.class) ){
 221                         referencedObject = CdmStore.getService(IAgentService.class).load(entity);
 222                 } else if (objectClass.getSuperclass().equals(NonViralName.class)){
 223                         referencedObject = CdmStore.getService(INameService.class).load(entity);
 224                 } else if (objectClass.getSuperclass().equals(TaxonBase.class)){
 225                         referencedObject = CdmStore.getService(ITaxonService.class).load(entity);
 226                 } else if (objectClass.equals(Reference.class)){
 227                         referencedObject = CdmStore.getService(IReferenceService.class).load(entity);
 228                 } else if (objectClass.getSuperclass().equals(SpecimenOrObservationBase.class)){
 229                         referencedObject = CdmStore.getService(IOccurrenceService.class).load(entity);
 230                 } else if (objectClass.isAssignableFrom(User.class)){
 231                         referencedObject = CdmStore.getService(IUserService.class).load(entity);
 232                 } else if (objectClass.isAssignableFrom(Group.class)){
 233                         referencedObject = CdmStore.getService(IGroupService.class).load(entity);
 234                 } else if (objectClass.isAssignableFrom(Media.class)){
 235                     referencedObject = CdmStore.getService(IMediaService.class).load(entity);
 236                 } else if (DescriptionBase.class.isAssignableFrom(objectClass)){
 237                     referencedObject = CdmStore.getService(IDescriptionService.class).load(entity);
 238                 } else if (DescriptionElementBase.class.isAssignableFrom(objectClass)){
 239                 referencedObject = CdmStore.getService(IDescriptionService.class).loadDescriptionElement(entity, null);
 240             } else if (objectClass.equals(Sequence.class)){
 241                 referencedObject = CdmStore.getService(ISequenceService.class).load(entity, null);
 242             } else if (DefinedTermBase.class.isAssignableFrom(objectClass)){
 243                 referencedObject = CdmStore.getService(ITermService.class).load(entity, null);
 244             } else if (EventBase.class.isAssignableFrom(objectClass)){
 245                 referencedObject = CdmStore.getService(IEventBaseService.class).load(entity, null);
 246             }
 247                         //referencedObject =(CdmBase) CdmStore.getService(IIdentifiableEntityService.class).load(referencedObject.getUuid());
 248                 Set<CdmBase> setOfReferencingObjects = null;
 249
 250                 if (referencedObject != null){
 251                     if(referencedObject.isInstanceOf(IdentifiableEntity.class)){
 252                         referencedObjectTitleCache = (HibernateProxyHelper.deproxy(referencedObject, IdentifiableEntity.class)).getTitleCache();
 253                     }
 254                     else if(referencedObject.isInstanceOf(DescriptionElementBase.class)){
 255                         referencedObjectTitleCache = DescriptionHelper.getLabel(referencedObject);
 256                     }
 257                     else{
 258                         referencedObjectTitleCache = null;
 259                     }
 260                         setOfReferencingObjects = CdmStore.getCommonService().getReferencingObjects(referencedObject);
 261                 }
 262                 if (setOfReferencingObjects != null){
 263                         List<CdmBase> referencingObjects = new ArrayList<CdmBase>(setOfReferencingObjects);
 264
 265                         Collections.sort(referencingObjects, new ReferencingClassComparator());
 266
 267                         return referencingObjects;
 268
 269                 }
 270         } catch (Exception e) {
 271             logger.error("Error retrieving referencing objects", e);
 272             setContentDescription("The referencing objects view could not be loaded completely. Some Problems occured.");
 273         }
 274                 return null;
 275         }
 276
 277         class ReferencingClassComparator implements Comparator<CdmBase> {
 278
 279                 @Override
 280         public int compare(CdmBase o1, CdmBase o2) {
 281                         String string1 = o1.getClass().getSimpleName();
 282                         String string2 = o2.getClass().getSimpleName();
 283                         int classCompare = string1.compareToIgnoreCase(string2);
 284                         if (classCompare == 0) {
 285                                 string1 = DescriptionHelper.getObjectDescription(o1);
 286                                 string2 = DescriptionHelper.getObjectDescription(o2);
 287                                 return string1.compareToIgnoreCase(string2);
 288                         } else {
 289                                 return classCompare;
 290                         }
 291                 }
 292         }
 293
 294         private void updateView(List<CdmBase> referencingObjects) {
 295                 if (viewer != null && !viewer.getControl().isDisposed()){
 296                         try{
 297                                 viewer.setInput(referencingObjects);
 298                                 if (referencedObjectTitleCache != null){
 299                                         setContentDescription("'" + referencedObjectTitleCache + "' is referenced by:");
 300                                 } else {
 301                                         setContentDescription("");
 302                                 }
 303                                 showViewer();
 304                         }catch(Exception e){
 305                                 setContentDescription("The referencing objects view could not be loaded completely. Some Problems occured.");
 306                         }
 307
 308                 }
 309         }
 310
 311         /** {@inheritDoc} */
 312         @Override
 313     public void selectionChanged(IWorkbenchPart part, ISelection selection) {
 314         if(part == this){
 315             return;
 316         }
 317         if(selection instanceof IStructuredSelection){
 318                 referencedObjectTitleCache = null;
 319             showViewer(part, (IStructuredSelection) selection);
 320         }
 321         }
 322
 323         /** {@inheritDoc} */
 324         @Override
 325         public void showViewer(IWorkbenchPart part, IStructuredSelection selection) {
 326         //      this.part = part;
 327
 328                 Object firstElement = selection.getFirstElement();
 329                 if(firstElement instanceof TreeNode){
 330                     firstElement = ((TreeNode) firstElement).getValue();
 331                 }
 332                 if(firstElement instanceof CdmBase){
 333                     updateReferencingObjects(((CdmBase) firstElement).getUuid(),firstElement.getClass() );
 334                 }
 335                 else{
 336                     updateView(null);
 337             setContentDescription("");
 338                 }
 339         }
 340
 341         /** {@inheritDoc} */
 342         @Override
 343         public void dispose() {
 344                 conversation.close();
 345                 selectionService.removePostSelectionListener(this);
 346                 selectionService.removeSelectionListener(this);
 347                 cdmEntitySession.dispose();
 348                 super.dispose();
 349
 350         }
 351
 352         /** {@inheritDoc} */
 353         @Override
 354         public Viewer getViewer() {
 355                 return viewer;
 356         }
 357
 358         /** {@inheritDoc} */
 359         @Override
 360         public void changed(Object object) {
 361                 // no editing in this view
 362         }
 363
 364         /** {@inheritDoc} */
 365         @Override
 366         public boolean onComplete() {
 367                 return false;
 368         }
 369
 370         public void refresh(){
 371                 selectionService.removePostSelectionListener(this);
 372                 selectionService.removeSelectionListener(this);
 373                 selectionService.addPostSelectionListener(this);
 374                 selectionService.addSelectionListener(this);
 375
 376         }
 377
 378 }