/ - Diff - EDIT - EDIT Project Management

     import org.eclipse.ui.IEditorInput;
     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;
-...
      */
     public abstract class AbstractBulkEditorInput<T extends ICdmBase> implements IEditorInput, IEntityPersistenceService<T> {
     	/**
+    	 *
     	 */
     	private static final long serialVersionUID = 416414530232743735L;
     	private UUID entityUuid;
     	private List<T> model;
-...
         public boolean merge(T entity, T mergeTarget) {
     		if (entity instanceof IMergable) {
     			try {
     				CdmStore.getService(ICommonService.class).merge((IMergable)mergeTarget, (IMergable)entity, null);
     				CdmStore.getCommonService().merge((IMergable)mergeTarget, (IMergable)entity, null);
     			} catch (MergeException e) {
     				MessagingUtils.errorDialog("Bulk Editor Merge Error",
     						this,

             	if (referencedObject != null){
             		referencedObjectTitleCache = ((IdentifiableEntity)referencedObject).getTitleCache();
             		setOfReferencingObjects = CdmStore.getService(ICommonService.class).getReferencingObjects(referencedObject);
             		setOfReferencingObjects = CdmStore.getCommonService().getReferencingObjects(referencedObject);
+            	}
     	        if (setOfReferencingObjects != null){
     		       	List<CdmBase> referencingObjects = new ArrayList<CdmBase>(setOfReferencingObjects);

      eu.etaxonomy.cdm.api.service.statistics,
      eu.etaxonomy.cdm.api.service.util,
      eu.etaxonomy.cdm.api.utility,
      eu.etaxonomy.cdm.api.validation,
      eu.etaxonomy.cdm.api.validation.batch,
      eu.etaxonomy.cdm.aspectj,
      eu.etaxonomy.cdm.common,
      eu.etaxonomy.cdm.common.media,

     	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     	xmlns:context="http://www.springframework.org/schema/context"
     	xmlns:tx="http://www.springframework.org/schema/tx"
     	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
     	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
         <!-- Default application context and term initializer -->

     	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     	xmlns:context="http://www.springframework.org/schema/context"
     	xmlns:tx="http://www.springframework.org/schema/tx"
     	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">
     	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">
         <!--  <bean id="remoteTermInitializer" class="eu.etaxonomy.cdm.remote.service.RemoteTermInitializer"/>-->

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
         http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
         ">

       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
         http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd
         http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.1.xsd"
+        >

     package eu.etaxonomy.taxeditor.editor.validation;
     import java.util.HashMap;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.Set;
-...
     import org.eclipse.core.runtime.CoreException;
     import eu.etaxonomy.cdm.model.validation.EntityConstraintViolation;
     import eu.etaxonomy.cdm.model.validation.EntityValidationResult;
     import eu.etaxonomy.cdm.model.validation.EntityValidation;
     import eu.etaxonomy.cdm.model.validation.Severity;
     /**
      * A class responsible for refreshing problem markers coming from the CVI
      * (Cdmlib Validation Infrastructure).
+     *
+     *
      * @author ayco_holleman
+     *
+     *
      */
     /*
      * See following for problems with icons in Problems view
      * http://stackoverflow.com
-...
      * http
      * ://cubussapiens.hu/2010/11/markers-and-annotations-in-eclipse-for-error-feedback
      * /
+     *
+     *
      * See here for difficulty of attaching markers to non-resources (files,
      * folders):
      * http://stackoverflow.com/questions/12493179/eclipse-virtual-resources
      */
     public class MarkerManager {
     	public static final String MARKER_TYPE_ID = "eu.etaxonomy.taxeditor.markers.validationerror";
     	/**
     	 * The primary key (id) of the EntityValidationResult record
     	 */
     	public static final String ATTRIB_DATABASE_ID = "databaseId";
     	// The values of the following constants must correspond to the attributes
     	// defined for the org.eclipse.core.resources.markers extension point in
     	// plugin.xml
     	/**
     	 * A user-friendly description of the type of the entity
     	 */
     	public static final String ATTRIB_USER_FRIENDLY_TYPE_NAME = "userFriendlyTypeName";
     	/**
     	 * A user-friendly description of the entity
     	 */
     	public static final String ATTRIB_USER_FRIENDLY_DESCRIPTION = "userFriendlyDescription";
     	/**
     	 * The field whose value violated a constraint
     	 */
     	public static final String ATTRIB_USER_FRIENDLY_FIELD_NAME = "userFriendlyFieldName";
     	/**
     	 * The value violating a constraint
     	 */
     	public static final String ATTRIB_INVALID_VALUE = "invalidValue";
     	/**
     	 * The message from the {@link Validator} about what was wrong.
     	 */
     	public static final String ATTRIB_VALIDATOR_MESSAGE = "validatorMessage";
     	/**
     	 * The class of the {@link Validator} coding for the constraint
     	 */
     	public static final String ATTRIB_VALIDATOR_CLASS = "validatorClass";
     	/**
     	 * The class of the validated entity
     	 */
     	public static final String ATTRIB_ENTITY_CLASS = "entityClass";
     	/**
     	 * The id of the validated entity
     	 */
     	public static final String ATTRIB_ENTITY_ID = "entityId";
     	private final IWorkspaceRoot root;
     	private final IMarker[] markers;
     	private final List<EntityValidationResult> results;
     	private final HashMap<Integer, EntityValidationResult> resultMap;
     	private final HashMap<Integer, IMarker> markerMap;
     	MarkerManager(List<EntityValidationResult> results) throws CoreException
+    	{
     		this.root = ResourcesPlugin.getWorkspace().getRoot();
     		this.markers = root.findMarkers(MARKER_TYPE_ID, true, IResource.DEPTH_INFINITE);
     		this.markerMap = new HashMap<Integer, IMarker>();
     		for (IMarker marker : markers) {
     			markerMap.put(getDatabaseId(marker), marker);
+    		}
     		this.results = results;
     		this.resultMap = new HashMap<Integer, EntityValidationResult>();
     		for (EntityValidationResult result : results) {
     			resultMap.put(result.getId(), result);
+    		}
+    	}
     	/**
     	 * Delete all markers that refer to errors that do not exist any longer
     	 * (i.e. the corresponding database record has been deleted).
+    	 *
     	 * @return The number of deleted markers
+    	 *
     	 * @throws CoreException
     	 */
     	int deleteObsoleteMarkers() throws CoreException
+    	{
     		int i = 0;
     		IMarker[] markers = root.findMarkers(MARKER_TYPE_ID, true, IResource.DEPTH_INFINITE);
     		for (IMarker marker : markers) {
     			if (isObsoleteMarker(marker)) {
     				++i;
     				marker.delete();
+    			}
+    		}
     		return i;
+    	}
     	/**
     	 * Create markers for new errors (i.e. no marker has been created for them
     	 * yet).
+    	 *
     	 * @return The number of new markers
+    	 *
     	 * @throws CoreException
     	 */
     	int createMarkers() throws CoreException
+    	{
     		int i = 0;
     		IMarker[] markers = root.findMarkers(MARKER_TYPE_ID, true, IResource.DEPTH_INFINITE);
     		for (EntityValidationResult result : results) {
     			if (!isNewResult(result)) {
     				continue;
+    			}
     			Set<EntityConstraintViolation> problems = result.getEntityConstraintViolations();
     			for (EntityConstraintViolation problem : problems) {
     				if (markerExistsForProblem(problem, markers)) {
     					continue;
+    				}
     				IMarker marker = root.createMarker(MARKER_TYPE_ID);
     				++i;
     				if (problem.getSeverity() == Severity.ERROR) {
     					marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
+    				}
     				else if (problem.getSeverity() == Severity.WARNING) {
     					marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_WARNING);
+    				}
     				else {
     					marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
+    				}
     				marker.setAttribute(IMarker.MESSAGE, problem.getMessage());
     				marker.setAttribute(ATTRIB_DATABASE_ID, result.getId());
     				marker.setAttribute(ATTRIB_USER_FRIENDLY_TYPE_NAME, result.getUserFriendlyTypeName());
     				marker.setAttribute(ATTRIB_USER_FRIENDLY_DESCRIPTION, result.getUserFriendlyDescription());
     				marker.setAttribute(ATTRIB_USER_FRIENDLY_FIELD_NAME, problem.getUserFriendlyFieldName());
     				marker.setAttribute(ATTRIB_VALIDATOR_MESSAGE, problem.getMessage());
     				marker.setAttribute(ATTRIB_INVALID_VALUE, problem.getInvalidValue());
     				marker.setAttribute(ATTRIB_VALIDATOR_CLASS, problem.getValidator());
     				marker.setAttribute(ATTRIB_ENTITY_CLASS, result.getValidatedEntityClass());
     				marker.setAttribute(ATTRIB_ENTITY_ID, result.getValidatedEntityId());
+    			}
+    		}
     		return i;
+    	}
     	/**
     	 * Is there a problem marker that captures the specified
     	 * {@link EntityConstraintViolation}? See
     	 * {@link #markerCapturesProblem(IMarker, EntityConstraintViolation)}.
+    	 *
     	 * @param problem
     	 * @param markers
     	 * @return
     	 * @throws CoreException
     	 */
     	private boolean markerExistsForProblem(EntityConstraintViolation problem, IMarker[] markers) throws CoreException
+    	{
     		for (IMarker marker : markers) {
     			if (markerCapturesProblem(marker, problem)) {
     				return true;
+    			}
+    		}
     		return false;
+    	}
     	/**
     	 * <p>
     	 * This method determines whether the problem exposed by the specified
     	 * marker is <b>de facto</b> equivalent to the specified
     	 * {@code EntityConstraintViolation}. When the CVI validates an entity, it
     	 * first deletes previous validation results for that entity and only then
     	 * saves the new validation result. Thus you cannot rely on the database id
     	 * of the {@code EntityConstraintViolation} to determine equivalence. Maybe
     	 * later we can make the CVI more sophisticated in this respect. Or maybe
     	 * see if solving it through the equals() method of
     	 * {@code EntityValidationResult} and/or {@code EntityConstraintViolation}
     	 * is possible. But for now this is the easiest solution.
     	 * </p>
     	 * <p>
     	 * The reason we check for equivalence, is that we don't want to
     	 * unnecessarily update the Problems view. If a marker is there, we don't
     	 * want to replace it with an equivalent marker, because that might lead to
     	 * strange click behaviour for end users (e.g. selected problems will
     	 * disappear and re-appear unselected).
     	 * </p>
+    	 *
     	 * @param marker
     	 * @param problem
     	 * @return
     	 * @throws CoreException
     	 */
     	private static boolean markerCapturesProblem(IMarker marker, EntityConstraintViolation problem) throws CoreException
+    	{
     		EntityValidationResult result = problem.getEntityValidationResult();
     		if (!marker.getAttribute(ATTRIB_ENTITY_CLASS).equals(result.getValidatedEntityClass())) {
     			return false;
+    		}
     		if (!marker.getAttribute(ATTRIB_ENTITY_ID).equals(result.getValidatedEntityId())) {
     			return false;
+    		}
     		if (!marker.getAttribute(ATTRIB_USER_FRIENDLY_FIELD_NAME).equals(problem.getPropertyPath())) {
     			return false;
+    		}
     		if (!marker.getAttribute(ATTRIB_INVALID_VALUE).equals(problem.getInvalidValue())) {
     			return false;
+    		}
     		if (!marker.getAttribute(ATTRIB_VALIDATOR_CLASS).equals(problem.getValidator())) {
     			return false;
+    		}
     		return true;
+    	}
     	/**
     	 * Is this a marker without a corresponding database record (
     	 * {@link EntityValidationResult})?
+    	 *
     	 * @param marker
     	 * @return
     	 * @throws CoreException
     	 */
     	private boolean isObsoleteMarker(IMarker marker) throws CoreException
+    	{
     		return resultMap.get(getDatabaseId(marker)) == null;
+    	}
     	/**
     	 * Is this an {@link EntityValidationResult} for which no marker has been
     	 * created yet?
+    	 *
     	 * @param result
     	 * @return
     	 */
     	private boolean isNewResult(EntityValidationResult result)
+    	{
     		return markerMap.get(result.getId()) == null;
+    	}
     	/**
     	 * Get the id of the {@link EntityValidationResult} that was stored as one
     	 * of the marker's attributes.
+    	 *
     	 * @param marker
     	 * @return
     	 * @throws CoreException
     	 */
     	private static Integer getDatabaseId(IMarker marker) throws CoreException
+    	{
     		return (Integer) marker.getAttribute(ATTRIB_DATABASE_ID);
+    	}
         public static final String MARKER_TYPE_ID = "eu.etaxonomy.taxeditor.markers.validationerror";
         /**
          * The primary key (id) of the EntityConstraintViolation record
          */
         public static final String ATTRIB_DATABASE_ID = "databaseId";
         // The values of the following constants must correspond to the attributes
         // defined for the org.eclipse.core.resources.markers extension point in
         // plugin.xml
         /**
          * A user-friendly description of the type of the entity
          */
         public static final String ATTRIB_USER_FRIENDLY_TYPE_NAME = "userFriendlyTypeName";
         /**
          * A user-friendly description of the entity
          */
         public static final String ATTRIB_USER_FRIENDLY_DESCRIPTION = "userFriendlyDescription";
         /**
          * The field whose value violated a constraint
          */
         public static final String ATTRIB_USER_FRIENDLY_FIELD_NAME = "userFriendlyFieldName";
         /**
          * The value violating a constraint
          */
         public static final String ATTRIB_INVALID_VALUE = "invalidValue";
         /**
          * The message from the {@link Validator} about what was wrong.
          */
         public static final String ATTRIB_VALIDATOR_MESSAGE = "validatorMessage";
         /**
          * The class of the {@link Validator} coding for the constraint
          */
         public static final String ATTRIB_VALIDATOR_CLASS = "validatorClass";
         /**
          * The class of the validated entity
          */
         public static final String ATTRIB_ENTITY_CLASS = "entityClass";
         /**
          * The id of the validated entity
          */
         public static final String ATTRIB_ENTITY_ID = "entityId";
         private final List<EntityConstraintViolation> problems;
         MarkerManager(List<EntityValidation> results) {
             this.problems = new ArrayList<EntityConstraintViolation>();
             for (EntityValidation result : results) {
                 Set<EntityConstraintViolation> problemsPerEntity = result.getEntityConstraintViolations();
                 for (EntityConstraintViolation problem : problemsPerEntity) {
                     problem.setEntityValidation(result);
                     problems.add(problem);
+                }
+            }
             //MessagingUtils.info("Number of validation errors: " + problems.size());
+        }
         /**
          * Delete all markers that refer to errors that do not exist any longer
          * (i.e. the corresponding database record has been deleted).
+         *
          * @return The number of deleted markers
+         *
          * @throws CoreException
          */
         int deleteObsoleteMarkers() throws CoreException {
             int i = 0;
             IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
             IMarker[] markers = root.findMarkers(MARKER_TYPE_ID, true, IResource.DEPTH_INFINITE);
             for (IMarker marker : markers) {
                 if (isObsoleteMarker(marker)) {
                     ++i;
                     marker.delete();
+                }
+            }
             //MessagingUtils.info("Obsolete markers: " + i);
             return i;
+        }
         /**
          * Create markers for new errors (i.e. no marker has been created for them
          * yet).
+         *
          * @return The number of new markers
+         *
          * @throws CoreException
          */
         int createMarkers() throws CoreException {
             int i = 0;
             IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
             IMarker[] markers = root.findMarkers(MARKER_TYPE_ID, true, IResource.DEPTH_INFINITE);
             for (EntityConstraintViolation problem : problems) {
                 if (isNewProblem(problem, markers)) {
                     ++i;
                     IMarker marker = root.createMarker(MARKER_TYPE_ID);
                     if (problem.getSeverity() == Severity.ERROR) {
                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_ERROR);
                     } else if (problem.getSeverity() == Severity.WARNING) {
                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_WARNING);
                     } else {
                         marker.setAttribute(IMarker.SEVERITY, IMarker.SEVERITY_INFO);
+                    }
                     EntityValidation result = problem.getEntityValidation();
                     marker.setAttribute(IMarker.MESSAGE, problem.getMessage());
                     marker.setAttribute(ATTRIB_DATABASE_ID, new Integer(problem.getId()));
                     marker.setAttribute(ATTRIB_USER_FRIENDLY_TYPE_NAME, result.getUserFriendlyTypeName());
                     marker.setAttribute(ATTRIB_USER_FRIENDLY_DESCRIPTION, result.getUserFriendlyDescription());
                     marker.setAttribute(ATTRIB_USER_FRIENDLY_FIELD_NAME, problem.getUserFriendlyFieldName());
                     marker.setAttribute(ATTRIB_VALIDATOR_MESSAGE, problem.getMessage());
                     marker.setAttribute(ATTRIB_INVALID_VALUE, problem.getInvalidValue());
                     marker.setAttribute(ATTRIB_VALIDATOR_CLASS, problem.getValidator());
                     marker.setAttribute(ATTRIB_ENTITY_CLASS, result.getValidatedEntityClass());
                     marker.setAttribute(ATTRIB_ENTITY_ID, result.getValidatedEntityId());
+                }
+            }
             //MessagingUtils.info("New problems: " + i);
             return i;
+        }
         private boolean isObsoleteMarker(IMarker marker) throws CoreException {
             for (EntityConstraintViolation problem : problems) {
                 if (isMarkerForProblem(marker, problem)) {
                     return false;
+                }
+            }
             return true;
+        }
         private static boolean isNewProblem(EntityConstraintViolation problem, IMarker[] markers) throws CoreException {
             for (IMarker marker : markers) {
                 if (isMarkerForProblem(marker, problem)) {
                     return false;
+                }
+            }
             return true;
+        }
         private static boolean isMarkerForProblem(IMarker marker, EntityConstraintViolation problem) throws CoreException {
             if (isEqual(marker, ATTRIB_DATABASE_ID, new Integer(problem.getId()))) {
                 return true;
+            }
             EntityValidation result = problem.getEntityValidation();
             if (!isEqual(marker, ATTRIB_ENTITY_ID, result.getValidatedEntityId())) {
                 return false;
+            }
             if (!isEqual(marker, ATTRIB_INVALID_VALUE, problem.getInvalidValue())) {
                 return false;
+            }
             if (!isEqual(marker, ATTRIB_ENTITY_CLASS, result.getValidatedEntityClass())) {
                 return false;
+            }
             if (!isEqual(marker, ATTRIB_USER_FRIENDLY_FIELD_NAME, problem.getUserFriendlyFieldName())) {
                 return false;
+            }
             if (!isEqual(marker, ATTRIB_VALIDATOR_CLASS, problem.getValidator())) {
                 return false;
+            }
             return true;
+        }
         private static boolean isEqual(IMarker marker, String attribute, Object value) throws CoreException {
             Object val = marker.getAttribute(attribute);
             boolean equal;
             if (val == null) {
                 equal = value == null;
             } else {
                 equal = value != null && val.equals(value);
+            }
             return equal;
+        }
+    }

     import org.eclipse.core.runtime.Status;
     import org.eclipse.core.runtime.jobs.Job;
     import eu.etaxonomy.cdm.api.service.IEntityConstraintViolationService;
     import eu.etaxonomy.cdm.api.service.IEntityValidationResultService;
     import eu.etaxonomy.cdm.model.validation.EntityValidationResult;
     import eu.etaxonomy.cdm.api.service.IEntityValidationService;
     import eu.etaxonomy.cdm.model.validation.EntityValidation;
     import eu.etaxonomy.taxeditor.model.MessagingUtils;
     import eu.etaxonomy.taxeditor.store.CdmStore;
     /**
      * A job that repeatedly checks the error tables and refreshes the problem
      * markers created from them.
+     *
+     *
      * @author ayco_holleman
+     *
+     *
      */
     public class ValidationDaemon extends Job {
     	@SuppressWarnings("unused")
     	private static final Logger logger = Logger.getLogger(ValidationDaemon.class);
     	private final IEntityValidationResultService validationResultService;
     	@SuppressWarnings("unused")
     	/* Not currently needed but present for future use if/when required */
     	private final IEntityConstraintViolationService constraintViolationService;
     	private final IEntityValidationService entityValidationService;
     	// Might want to make this configurable:
     	private int SLEEP_TIME = 5000;
     	private boolean cancelRequested = false;
     	public ValidationDaemon(){
     		super("Initializing validation module");
     //		StoreUtil.info("Initializing validation module");
     		MessagingUtils.info("Initializing validation module");
     		constraintViolationService = CdmStore.getService(IEntityConstraintViolationService.class);
     		validationResultService = CdmStore.getService(IEntityValidationResultService.class);
     		super("Running validation daemon");
     		entityValidationService = CdmStore.getService(IEntityValidationService.class);
+    	}
     	@Override
     	protected void canceling(){
     		cancelRequested = true;
-...
     	@Override
     	protected IStatus run(IProgressMonitor monitor){
     		MarkerManager markerManager;
     		List<EntityValidationResult> results;
     		List<EntityValidation> results;
     		try {
     			while (!cancelRequested) {
     				results = validationResultService.getValidationResults();
     				results = entityValidationService.getValidationResults();
     				markerManager = new MarkerManager(results);
     				markerManager.deleteObsoleteMarkers();
     				markerManager.createMarkers();
     				// Might want to make this configurable:
     				Thread.sleep(5000);
     				Thread.sleep(SLEEP_TIME);
+    			}
     //			StoreUtil.info("Validation module stopped");
     			MessagingUtils.info("Validation module stopped");
     			return Status.OK_STATUS;
+    		}
     		catch (Throwable t) {
     //			StoreUtil.info("Validation module terminated unexpectedly: " + t.getMessage());
     			MessagingUtils.info("Validation module terminated unexpectedly: " + t.getMessage());
     			return Status.CANCEL_STATUS;
+    		}

     import eu.etaxonomy.cdm.api.service.IDatabaseService;
     import eu.etaxonomy.cdm.api.service.IDescriptionService;
     import eu.etaxonomy.cdm.api.service.IEntityConstraintViolationService;
     import eu.etaxonomy.cdm.api.service.IEntityValidationResultService;
     import eu.etaxonomy.cdm.api.service.IEntityValidationService;
     import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
     import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
     import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;
-...
+    	}
     	@Override
     	public IEntityValidationResultService getEntityValidationResultService() {
     		return defaultApplicationConfiguration.getEntityValidationResultService();
     	public IEntityValidationService getEntityValidationService() {
     		return defaultApplicationConfiguration.getEntityValidationService();
+    	}
+    }

     		return defaultService.findWithoutFlush(uuid);
+    	}
     	/* (non-Javadoc)
     	 * @see eu.etaxonomy.cdm.api.service.IOccurrenceService#listFieldUnitsByAssociatedTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List, java.util.List)
     	 */
     	@Override
     	public Collection<SpecimenOrObservationBase> listFieldUnitsByAssociatedTaxon(Taxon associatedTaxon,
     	        List<OrderHint> orderHints, List<String> propertyPaths) {
     	    return defaultService.listFieldUnitsByAssociatedTaxon(associatedTaxon, orderHints, propertyPaths);
+    	}
     	/* (non-Javadoc)
     	 * @see eu.etaxonomy.cdm.api.service.IOccurrenceService#pageFieldUnitsByAssociatedTaxon(java.util.Set, eu.etaxonomy.cdm.model.taxon.Taxon, java.lang.Integer, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
     	 */
     	@Override
     	public Pager<SpecimenOrObservationBase> pageFieldUnitsByAssociatedTaxon(
     	        Set<TaxonRelationshipEdge> includeRelationships, Taxon associatedTaxon, Integer maxDepth, Integer pageSize,
-...
+    	}
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.service.IOccurrenceService#assembleDerivateHierarchyDTO(eu.etaxonomy.cdm.model.occurrence.FieldUnit, java.util.UUID)
          */
         @Override
         public DerivateHierarchyDTO assembleDerivateHierarchyDTO(FieldUnit fieldUnit, UUID associatedTaxonUuid) {
             return defaultService.assembleDerivateHierarchyDTO(fieldUnit, associatedTaxonUuid);
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.service.IOccurrenceService#getNonCascadedAssociatedElements(eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase, eu.etaxonomy.cdm.api.conversation.ConversationHolder)
          */
         @Override
         public Collection<ICdmBase> getNonCascadedAssociatedElements(SpecimenOrObservationBase<?> specimen) {
             return defaultService.getNonCascadedAssociatedElements(specimen);

         <!-- enable the configuration of transactional behavior based on annotations -->
         <tx:annotation-driven transaction-manager="transactionManager"/>
         <tx:annotation-driven transaction-manager="transactionManager"/>
     <!-- <bean id="validationManager" class="eu.etaxonomy.cdm.api.validation.ValidationManager" scope="prototype"/> -->

     import java.util.ArrayList;
     import java.util.List;
     import eu.etaxonomy.cdm.api.service.ICommonService;
     import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
     import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
     import eu.etaxonomy.cdm.model.name.NonViralName;
-...
                 return new ArrayList<INomenclaturalReference>();
+            }
     		try{
     			return CdmStore.getService(ICommonService.class).findMatching(nomenclaturalReference, MatchStrategyConfigurator.ReferenceMatchStrategy());
     			return CdmStore.getCommonService().findMatching(nomenclaturalReference, MatchStrategyConfigurator.ReferenceMatchStrategy());
     		}catch (MatchException e) {
     			MessagingUtils.error(this.getClass(), "Error finding matching references", e);
+    		}
-...
+    		}
     		try{
     			return CdmStore.getService(ICommonService.class).findMatching(authorTeam, MatchStrategyConfigurator.TeamOrPersonMatchStrategy());
     			return CdmStore.getCommonService().findMatching(authorTeam, MatchStrategyConfigurator.TeamOrPersonMatchStrategy());
     		}catch (MatchException e) {
     			MessagingUtils.error(this.getClass(), "Error finding matching authors", e);
+    		}
-...
     	private List<TaxonNameBase> findMatchingLatinNames(TaxonNameBase taxonNameBase) {
     		try {
     			return CdmStore.getService(ICommonService.class).findMatching(taxonNameBase, MatchStrategyConfigurator.NonViralNameMatchStrategy());
     			return CdmStore.getCommonService().findMatching(taxonNameBase, MatchStrategyConfigurator.NonViralNameMatchStrategy());
     		} catch (MatchException e) {
     			MessagingUtils.error(this.getClass(), "Error finding matching names", e);

     import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;
     import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
     import eu.etaxonomy.cdm.api.service.ICommonService;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.config.ICdmSource;
     import eu.etaxonomy.cdm.database.DbSchemaValidation;
-...
     		return service;
+    	}
     	/**
     	 * @see #getService(Class)
     	 * As ICommonService is not extending IService we need a specific request here
     	 */
     	public static ICommonService getCommonService() {
     		ICdmApplicationConfiguration configuration = getCurrentApplicationConfiguration();
     		return configuration.getCommonService();
+    	}
     	/**
     	 * <p>

     import org.eclipse.core.runtime.Status;
     import org.eclipse.core.runtime.jobs.Job;
     import org.eclipse.swt.widgets.Display;
     import org.hibernate.collection.internal.AbstractPersistentCollection;
     import org.hibernate.proxy.AbstractLazyInitializer;
     import org.springframework.core.io.Resource;
     import eu.etaxonomy.cdm.api.application.CdmApplicationController;
     import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteController;
     import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;
     import eu.etaxonomy.cdm.config.ICdmSource;
     import eu.etaxonomy.cdm.remote.ICdmRemoteSource;
     import eu.etaxonomy.cdm.config.CdmSourceException;
     import eu.etaxonomy.cdm.database.DatabaseTypeEnum;
     import eu.etaxonomy.cdm.config.ICdmSource;
     import eu.etaxonomy.cdm.database.DbSchemaValidation;
     import eu.etaxonomy.cdm.database.ICdmDataSource;
     import eu.etaxonomy.cdm.model.metadata.CdmMetaData;
     import eu.etaxonomy.cdm.model.metadata.CdmMetaData.MetaDataPropertyName;
     import eu.etaxonomy.cdm.remote.ICdmRemoteSource;
     import eu.etaxonomy.taxeditor.model.CdmProgressMonitorAdapter;
     import eu.etaxonomy.taxeditor.model.MessagingUtils;
     import eu.etaxonomy.taxeditor.ui.dialog.LoginDialog;
-...
     	public IStatus run(final IProgressMonitor monitor) {
     		monitor.beginTask(getConnectionMessage(), 10);
     		// check if database is up and running
     		checkDatabaseReachable(monitor);
-...
     			CdmProgressMonitorAdapter subprogressMonitor = CdmProgressMonitorAdapter
     					.CreateSubMonitor(monitor, 7);
     			// This is where we instantiate the application controller
     			int oldPriority = Thread.currentThread().getPriority();
     			try {
     				Thread.currentThread().setPriority(10);
     				applicationController = getApplicationController(cdmSource,subprogressMonitor);
     			} catch (Exception e) {
     				if(! causeIsCancelationExceptionRecursive(e)){
     					return new Status(IStatus.ERROR, "Could not connect to CDM Store", "An error occurred while trying to connect to datasource: " + cdmSource.getName(), e);
+    				}
     			} finally {
     				monitor.done();
     				Thread.currentThread().setPriority(oldPriority);
+    			}
+    		}

        </configIni>
        <launcherArgs>
           <programArgs>-data @user.home/.cdmLibrary -Dserver_port=58080
     -vm jre/bin</programArgs>
           <programArgs>-data @user.home/.cdmLibrary -Dserver_port=58080 </programArgs>
           <vmArgs>-Xmx512M -XX:MaxPermSize=256M -Dorg.eclipse.update.reconcile=false -Declipse.p2.unsignedPolicy=allow</vmArgs>
           <vmArgsMac>-XstartOnFirstThread -Dorg.eclipse.swt.internal.carbon.smallFonts</vmArgsMac>
        </launcherArgs>

Project

General

Profile

EDIT

Revision 68df9072

Added by Andreas Müller about 9 years ago