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