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