import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
+import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.ui.IEditorInput;
IStructuredSelection structuredSelection = (IStructuredSelection) selection;
IEntityPersistenceService persistenceService = (IEntityPersistenceService) input;
- IViewPart part = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage()
- .findView("eu.etaxonomy.taxeditor.bulkeditor.view.referencingobjects");
- if (part != null){
- ((ReferencingObjectsView)part).dispose();
- }
+
for(Object object : structuredSelection.toList()){
} catch (Exception e){
MessagingUtils.messageDialog("Exception occured. Could not delete", getClass(), e.getMessage(), null);
}
- if (result.isError() || result.isAbort()|| !result.getExceptions().isEmpty()){
+ if (result.isError() || result.isAbort()){
if (!result.getExceptions().isEmpty()) {
- MessagingUtils.messageDialog("Could not delete", getClass(), result.getExceptions().get(0).getMessage(), null);
+ MessagingUtils.messageDialog("Could not delete", getClass(), result.getExceptions().toString(), null);
}else{
MessagingUtils.messageDialog("Could not delete", getClass(), "The object could not be deleted. An exception occured.", null);
}
}
- if (result.isOk() && result.getExceptions().isEmpty()){
+ if (result.isOk() ){
((BulkEditor) editor).removeAnnotatedLine(annotation);
-
+ if(result.getUpdatedObjects().size() != 0 && !result.getExceptions().isEmpty()){
+ MessageDialog.openInformation(null, "Delete successfull", "The Synonym could be deleted, but there is an updated object: " + result.getExceptions().toString());
+ }
}
if (part != null){
package eu.etaxonomy.taxeditor.bulkeditor.input;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import org.eclipse.ui.IPersistableElement;
import eu.etaxonomy.cdm.api.service.ICommonService;
+import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.ICdmBase;
import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.common.MarkerType;
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
+import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.strategy.merge.IMergable;
import eu.etaxonomy.cdm.strategy.merge.MergeException;
import eu.etaxonomy.taxeditor.annotatedlineeditor.IEntityCreator;
private List<T> model;
private IEntityCreator<T> entityCreator;
+
+ private static Class serviceClass;
/**
* <p>NewInstance</p>
* @return a {@link eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput} object.
*/
static public AbstractBulkEditorInput NewInstance(BulkEditorInputType inputType) {
+
return BulkEditorInputType.getInput(inputType);
}
* @param entityUuid a {@link java.util.UUID} object.
* @return a T object.
*/
- protected abstract T loadEntity(UUID entityUuid);
+ protected T loadEntity(UUID entityUuid) {
+ List<String> propertyPaths = Arrays.asList(new String[]{});
+ return (T) CdmStore.getService(serviceClass).load(entityUuid, propertyPaths);
+ }
private void setEntityUuid(UUID entityUuid){
this.entityUuid = entityUuid;
if(getEntityUuid() != null){
- T entity = loadEntity(getEntityUuid());
+ T entity = (T) loadEntity(getEntityUuid());
entityList.add(entity);
model = entityList;
}
entityList = listEntities(configurator);
Collections.sort(entityList, queryComparator);
+
}
return CdmStore.getSearchManager().findTeamOrPersons(configurator);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
@Override
public AgentBase loadEntity(UUID uuid) {
List<String> propertyPaths = Arrays.asList(new String[]{});
return CdmStore.getService(IAgentService.class).load(uuid, propertyPaths);
- }
+ }*/
public boolean delete(AgentBase entity) throws ReferencedObjectUndeletableException {
/** {@inheritDoc} */
public boolean save(AgentBase entity) {
+
return CdmStore.getService(IAgentService.class).saveOrUpdate(entity) != null;
}
import org.eclipse.ui.menus.CommandContributionItem;
import org.eclipse.ui.menus.CommandContributionItemParameter;
+import eu.etaxonomy.cdm.api.service.IAgentService;
+import eu.etaxonomy.cdm.api.service.IGroupService;
+import eu.etaxonomy.cdm.api.service.INameService;
+import eu.etaxonomy.cdm.api.service.IOccurrenceService;
+import eu.etaxonomy.cdm.api.service.IReferenceService;
+import eu.etaxonomy.cdm.api.service.ITaxonService;
+import eu.etaxonomy.cdm.api.service.IUserService;
+import eu.etaxonomy.cdm.api.service.ReferenceServiceImpl;
+import eu.etaxonomy.cdm.io.dwca.in.INamespaceReader;
import eu.etaxonomy.cdm.model.agent.AgentBase;
import eu.etaxonomy.cdm.model.common.Group;
import eu.etaxonomy.cdm.model.common.User;
"No input class for the given input type defined.");
}
}
+
+ public static Class getServiceClass(
+ BulkEditorInputType inputType) {
+ switch (inputType) {
+ case REFERENCE:
+ return IReferenceService.class;
+ case NAME:
+ return INameService.class;
+ case AGENT:
+ return IAgentService.class;
+ case OCCURRENCE:
+ return IOccurrenceService.class;
+ case NAME_RELATIONSHIP:
+ return INameService.class;
+ case USER:
+ return IUserService.class;
+ case GROUP:
+ return IGroupService.class;
+ case TAXON:
+ return ITaxonService.class;
+ default:
+ throw new IllegalStateException(
+ "No input class for the given input type defined.");
+ }
+ }
}
\ No newline at end of file
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput#loadEntity(java.util.UUID)
- */
+
@Override
protected Group loadEntity(UUID entityUuid) {
List<String> propertyPaths = Arrays.asList(new String[]{});
return CdmStore.getService(IGroupService.class).load(entityUuid, propertyPaths);
}
-
+*/
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput#createEntityCreator()
*/
return CdmStore.getSearchManager().findNames(configurator);
}
- /** {@inheritDoc} */
+ /** {@inheritDoc}
@Override
public TaxonNameBase loadEntity(UUID uuid) {
List<String> propertyPaths = Arrays.asList(new String[]{});
return CdmStore.getService(INameService.class).load(uuid, propertyPaths);
}
-
+*/
/** {@inheritDoc}
**/
public boolean delete(TaxonNameBase entity) {
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput#loadEntity(java.util.UUID)
*/
- /** {@inheritDoc} */
+ /** {@inheritDoc}
@Override
protected SpecimenOrObservationBase loadEntity(UUID entityUuid) {
List<String> propertyPaths = Arrays.asList(new String[]{});
return CdmStore.getService(IOccurrenceService.class).load(entityUuid, propertyPaths);
- }
+ }*/
/* (non-Javadoc)
* @see org.eclipse.ui.IEditorInput#getName()
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput#loadEntity(java.util.UUID)
- */
+
@Override
protected User loadEntity(UUID entityUuid) {
List<String> propertyPaths = Arrays.asList(new String[]{});
return CdmStore.getService(IUserService.class).load(entityUuid, propertyPaths);
}
-
+ */
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.bulkeditor.input.AbstractBulkEditorInput#createEntityCreator()
*/
/** {@inheritDoc} */
public TaxonNameBase createEntity(String text) {
TaxonNameBase name = PreferencesUtil.getPreferredNomenclaturalCode().getNewTaxonNameInstance(null);
- name.setTitleCache(text);
+ name.setTitleCache(text, true);
+ //name.setTitleCache(text);
return name;
}
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Table;
import org.eclipse.ui.INullSelectionListener;
+import org.eclipse.ui.ISelectionListener;
import org.eclipse.ui.IWorkbenchPart;
* @created 08.07.2009
* @version 1.0
*/
-public class ReferencingObjectsView extends AbstractCdmViewPart implements INullSelectionListener{
+public class ReferencingObjectsView extends AbstractCdmViewPart{
private static final Logger logger = Logger
.getLogger(ReferencingObjectsView.class);
private TableViewer viewer;
private String referencedObjectTitleCache;
+ private ConversationHolder conversation;
/* (non-Javadoc)
* @see eu.etaxonomy.taxeditor.model.AbstractCdmViewPart#createViewer(org.eclipse.swt.widgets.Composite)
@Override
public void createViewer(Composite parent) {
selectionService.addSelectionListener(this);
-
+ conversation = CdmStore.createConversation();
viewer = new TableViewer(parent, SWT.MULTI | SWT.H_SCROLL
| SWT.V_SCROLL | SWT.FULL_SELECTION);
createColumns(viewer);
@Override
public void run() {
if (entityUUID != null){
- ConversationHolder conversation = CdmStore.createConversation();
+
List<CdmBase> referencingObjects = getReferencingObjects(entityUUID, objectClass);
- conversation.close();
+
updateView(referencingObjects);
+
+
}
}
});
referencedObject = CdmStore.getService(INameService.class).load(entity);
} else if (objectClass.getSuperclass().equals(TaxonBase.class)){
referencedObject = CdmStore.getService(ITaxonService.class).load(entity);
- } else if (objectClass.getSuperclass().equals(Reference.class)){
+ } else if (objectClass.equals(Reference.class)){
referencedObject = CdmStore.getService(IReferenceService.class).load(entity);
} else if (objectClass.getSuperclass().equals(SpecimenOrObservationBase.class)){
referencedObject = CdmStore.getService(IOccurrenceService.class).load(entity);
private void updateView(List<CdmBase> referencingObjects) {
if (viewer != null && !viewer.getControl().isDisposed()){
viewer.setInput(referencingObjects);
- /*if (referencedObjectTitleCache != null){
+ if (referencedObjectTitleCache != null){
setContentDescription("'" + referencedObjectTitleCache + "' is referenced by:");
} else {
setContentDescription("");
- }*/
+ }
showViewer();
}
}
/** {@inheritDoc} */
@Override
public void showViewer(IWorkbenchPart part, IStructuredSelection selection) {
- this.part = part;
+ // this.part = part;
updateReferencingObjects(((IdentifiableEntity) selection.getFirstElement()).getUuid(),selection.getFirstElement().getClass() );
}
/** {@inheritDoc} */
@Override
public void dispose() {
+ conversation.close();
selectionService.removePostSelectionListener(this);
selectionService.removeSelectionListener(this);
super.dispose();
}
public void refresh(){
+
selectionService.removePostSelectionListener(this);
selectionService.removeSelectionListener(this);
selectionService.addPostSelectionListener(this);
// TODO pass in homotypical group's taxon in case we are dragging from one editor to another
// Switch groups
- oldHomotypicalGroup.removeTypifiedName(synonymName);
+ oldHomotypicalGroup.removeTypifiedName(synonymName, false);
monitor.worked(40);
newHomotypicalGroup = HibernateProxyHelper.deproxy(newHomotypicalGroup, HomotypicalGroup.class);
newHomotypicalGroup.addTypifiedName(synonymName);
// TODO pass in homotypical group's taxon in case we are dragging from one editor to another
// Switch groups
- newHomotypicalGroup.removeTypifiedName(synonymName);
+ newHomotypicalGroup.removeTypifiedName(synonymName, false);
oldHomotypicalGroup.addTypifiedName(synonymName);
// Redraw editor if it exists
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
-import eu.etaxonomy.cdm.remote.dto.tdwg.voc.TaxonName;
import eu.etaxonomy.taxeditor.operation.AbstractPostTaxonOperation;
import eu.etaxonomy.taxeditor.operation.IPostOperationEnabled;
DeleteResult result = service.deleteSynonym(synonym, null);
if (result.isError()){
MessageDialog.openError(null, "Delete failed", result.getExceptions().get(0).getMessage());
+ } else if (result.getUpdatedObjects().size() != 0){
+ MessageDialog.openInformation(null, "Delete successfull", "The Synonym could be deleted, but there is an updated object: " + result.getExceptions().get(0).getMessage());
}
}
// taxon.removeSynonym(synonym);