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