/ - Diff - EDIT - EDIT Project Management

     	<classpathentry exported="true" kind="lib" path="lib/org.osgi.core-1.0.0.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.aop-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.aspects-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.beans-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.context-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.beans-3.2.2.RELEASE.jar" sourcepath="/home/cmathew/.m2/repository/org/springframework/org.springframework.beans/3.2.2.RELEASE/org.springframework.beans-3.2.2.RELEASE-sources.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.context-3.2.2.RELEASE.jar" sourcepath="/home/cmathew/.m2/repository/org/springframework/org.springframework.context/3.2.2.RELEASE/org.springframework.context-3.2.2.RELEASE-sources.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.core-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.expression-3.2.2.RELEASE.jar"/>
     	<classpathentry exported="true" kind="lib" path="lib/org.springframework.jdbc-3.2.2.RELEASE.jar" sourcepath="lib/org.springframework.jdbc-3.2.2.RELEASE-sources.jar"/>

     import org.apache.log4j.Logger;
     import org.hibernate.SessionFactory;
     import org.springframework.beans.BeansException;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.context.ApplicationContext;
     import org.springframework.context.ApplicationContextAware;
     import org.springframework.orm.hibernate4.HibernateTransactionManager;
     import org.springframework.security.authentication.ProviderManager;
     import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     import org.springframework.security.core.Authentication;
     import org.springframework.security.core.context.SecurityContext;
     import org.springframework.security.core.context.SecurityContextHolder;
     import org.springframework.stereotype.Component;
     import org.springframework.transaction.PlatformTransactionManager;
     import org.springframework.transaction.TransactionStatus;
     import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
     import eu.etaxonomy.cdm.api.conversation.ConversationHolderMock;
     import eu.etaxonomy.cdm.api.service.IAgentService;
     import eu.etaxonomy.cdm.api.service.IClassificationService;
     import eu.etaxonomy.cdm.api.service.ICollectionService;
     import eu.etaxonomy.cdm.api.service.ICommonService;
     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.IEntityValidationService;
     import eu.etaxonomy.cdm.api.service.IFeatureNodeService;
     import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
     import eu.etaxonomy.cdm.api.service.IGrantedAuthorityService;
     import eu.etaxonomy.cdm.api.service.IGroupService;
     import eu.etaxonomy.cdm.api.service.IIdentificationKeyService;
     import eu.etaxonomy.cdm.api.service.ILocationService;
     import eu.etaxonomy.cdm.api.service.IMediaService;
     import eu.etaxonomy.cdm.api.service.INameService;
     import eu.etaxonomy.cdm.api.service.IOccurrenceService;
     import eu.etaxonomy.cdm.api.service.IPolytomousKeyNodeService;
     import eu.etaxonomy.cdm.api.service.IPolytomousKeyService;
     import eu.etaxonomy.cdm.api.service.IReferenceService;
     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
     import eu.etaxonomy.cdm.api.service.ITaxonService;
     import eu.etaxonomy.cdm.api.service.ITermService;
     import eu.etaxonomy.cdm.api.service.IUserService;
     import eu.etaxonomy.cdm.api.service.IVocabularyService;
     import eu.etaxonomy.cdm.api.service.IWorkingSetService;
     import eu.etaxonomy.cdm.api.service.molecular.IAmplificationService;
     import eu.etaxonomy.cdm.api.service.molecular.IPrimerService;
     import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
     import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
     import eu.etaxonomy.cdm.model.common.CdmBase;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;
     import eu.etaxonomy.taxeditor.service.ICachedCommonService;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
-...
+     *
      */
     @Component
     public class CdmApplicationRemoteConfiguration extends CdmApplicationDefaultConfiguration {
     public class CdmApplicationRemoteConfiguration implements ICdmApplicationConfiguration, ApplicationContextAware  {
         @SuppressWarnings("unused")
         private static final Logger logger = Logger.getLogger(CdmApplicationRemoteConfiguration.class);
         protected ApplicationContext applicationContext;
         @Autowired
         //@Qualifier("nameService")
         private INameService nameService;
         @Autowired
         //@Qualifier("taxonService")
         private ITaxonService taxonService;
         @Autowired
         //@Qualifier("classificationService")
         private IClassificationService classificationService;
         @Autowired
         //@Qualifier("referenceService")
         private IReferenceService referenceService;
         @Autowired
         //@Qualifier("agentService")
         private IAgentService agentService;
         @Autowired
         //@Qualifier("databaseService")
         private IDatabaseService databaseService;
         @Autowired
         //@Qualifier("termService")
         private ITermService termService;
         //@Autowired
         private HibernateTransactionManager transactionManager;
         @Autowired
         //@Qualifier("descriptionService")
         private IDescriptionService descriptionService;
         @Autowired
         //@Qualifier("occurrenceService")
         private IOccurrenceService occurrenceService;
         @Autowired
         //@Qualifier("primerService")
         private IPrimerService primerService;
         @Autowired
         //@Qualifier("amplificationService")
         private IAmplificationService amplificationService;
         @Autowired
         //@Qualifier("sequenceService")
         private ISequenceService sequenceService;
         @Autowired
         //@Qualifier("mediaService")
         private IMediaService mediaService;
         @Autowired
         //@Qualifier("commonService")
         private ICommonService commonService;
         @Autowired
         private ILocationService locationService;
         //@Autowired
         private SessionFactory sessionFactory;
         //@Autowired
         private DataSource dataSource;
         @Autowired
         private ProviderManager authenticationManager;
         @Autowired
         private IUserService userService;
         @Autowired
         private IGrantedAuthorityService grantedAuthorityService;
         @Autowired
         private IGroupService groupService;
         @Autowired
         private ICollectionService collectionService;
         @Autowired
         private IFeatureTreeService featureTreeService;
         @Autowired
         private IFeatureNodeService featureNodeService;
         @Autowired
         private IVocabularyService vocabularyService;
         @Autowired
         IEditGeoService editGeoService;
         private ITaxonNodeService taxonNodeService;
         @Autowired
         private IIdentificationKeyService identificationKeyService;
         @Autowired
         private IPolytomousKeyService polytomousKeyService;
         @Autowired
         private IPolytomousKeyNodeService polytomousKeyNodeService;
         @Autowired
         private IEntityValidationService entityValidationService;
         @Autowired
         private IEntityConstraintViolationService entityConstraintViolationService;
         @Autowired
         private ICdmPermissionEvaluator permissionEvaluator;
         @Autowired
         private IEditGeoService editGeoService;
         @Autowired
         private ICachedCommonService cachedCommonService;
         @Autowired
         private IWorkingSetService workingSetService;
         @Autowired
         protected ICdmEntitySessionManager cdmEntitySessionManager;
         public CdmApplicationRemoteConfiguration() {
         private IService<CdmBase> mainService;
         public CdmApplicationRemoteConfiguration() {}
         // ****************************** APPLICATION CONTEXT *************************************************/
         @Override
         public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{
             this.applicationContext = applicationContext;
+        }
         /* (non-Javadoc)
-...
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration#startTransaction()
         /**
          * @return
          */
         public IEditGeoService getEditGeoService() {
             return this.editGeoService;
+        }
         /**
          * @return
          */
         public ICachedCommonService getCachedCommonService(){
             return this.cachedCommonService;
+        }
         public ICdmEntitySessionManager getCdmEntitySessionManager() {
             return this.cdmEntitySessionManager;
+        }
      // ****************************** GETTER *************************************************/
         @Override
         public TransactionStatus startTransaction() throws UnsupportedOperationException {
             throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
         public final Object getBean(String name){
             return this.applicationContext.getBean(name);
+        }
         @Override
         public IAgentService getAgentService(){
             return this.agentService;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration#startTransaction()
          */
         @Override
         public TransactionStatus startTransaction(Boolean readOnly) throws UnsupportedOperationException {
             throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
         public IDatabaseService getDatabaseService(){
             return this.databaseService;
+        }
         @Override
         public INameService getNameService(){
             return this.nameService;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#commitTransaction(org.springframework.transaction.TransactionStatus)
          */
         @Override
         public void commitTransaction(TransactionStatus txStatus) throws UnsupportedOperationException {
             throw new UnsupportedOperationException("commitTransaction is not implemented for CdmApplicationRemoteConfiguration");
         public IReferenceService getReferenceService(){
             return this.referenceService;
+        }
         @Override
         public ITaxonService getTaxonService(){
             return this.taxonService;
+        }
         @Override
         public IClassificationService getClassificationService(){
             return this.classificationService;
+        }
         @Override
         public ITaxonNodeService getTaxonNodeService(){
             return this.taxonNodeService;
+        }
         @Override
         public IDescriptionService getDescriptionService(){
             return this.descriptionService;
+        }
         @Override
         public IOccurrenceService getOccurrenceService(){
             return this.occurrenceService;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#NewConversation()
          */
         @Override
         public IPrimerService getPrimerService(){
             return this.primerService;
+        }
         @Override
         public IAmplificationService getAmplificationService(){
             return this.amplificationService;
+        }
         @Override
         public ISequenceService getSequenceService(){
             return this.sequenceService;
+        }
         @Override
         public IMediaService getMediaService(){
             return this.mediaService;
+        }
         @Override
         public ITermService getTermService(){
             return this.termService;
+        }
         @Override
         public ICommonService getCommonService(){
             return this.commonService;
+        }
         @Override
         public ILocationService getLocationService(){
             return this.locationService;
+        }
         @Override
         public IUserService getUserService(){
             return this.userService;
+        }
         @Override
         public IGrantedAuthorityService getGrantedAuthorityService(){
             return this.grantedAuthorityService;
+        }
         @Override
         public IService<CdmBase> getMainService(){
             return this.mainService;
+        }
         @Override
         public ProviderManager getAuthenticationManager(){
             return this.authenticationManager;
+        }
         @Override
         public ConversationHolder NewConversation() {
             return new ConversationHolderMock();
+        }
         /**
          * @return
          */
         public IEditGeoService getEditGeoService() {
             return this.editGeoService;
         @Override
         public ICollectionService getCollectionService(){
             return collectionService;
+        }
         /**
          * @return
          */
         public ICachedCommonService getCachedCommonService(){
             return this.cachedCommonService;
         @Override
         public IFeatureTreeService getFeatureTreeService(){
             return featureTreeService;
+        }
         @Override
         public IFeatureNodeService getFeatureNodeService(){
             return featureNodeService;
+        }
         public ICdmEntitySessionManager getCdmEntitySessionManager() {
             return this.cdmEntitySessionManager;
         @Override
         public IVocabularyService getVocabularyService(){
             return vocabularyService;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setDataSource(javax.sql.DataSource)
          */
         @Override
         public void setDataSource(DataSource dataSource) {
         public IIdentificationKeyService getIdentificationKeyService(){
             return identificationKeyService;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setTransactionManager(org.springframework.transaction.PlatformTransactionManager)
          */
         @Override
         public void setTransactionManager(PlatformTransactionManager transactionManager) {
         public IPolytomousKeyService getPolytomousKeyService(){
             return polytomousKeyService;
+        }
         @Override
         public IPolytomousKeyNodeService getPolytomousKeyNodeService(){
             return polytomousKeyNodeService;
+        }
         @Override
         public IWorkingSetService getWorkingSetService(){
             return workingSetService;
+        }
         @Override
         public IGroupService getGroupService(){
             return groupService;
+        }
         @Override
         public IEntityValidationService getEntityValidationService(){
             return entityValidationService;
+        }
         @Override
         public IEntityConstraintViolationService getEntityConstraintViolationService(){
             return entityConstraintViolationService;
+        }
         @Override
         public ICdmPermissionEvaluator getPermissionEvaluator(){
             return permissionEvaluator;
+        }
         @Override
         public TransactionStatus startTransaction() throws UnsupportedOperationException {
             throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
+        }
         @Override
         public TransactionStatus startTransaction(Boolean readOnly) throws UnsupportedOperationException {
             throw new UnsupportedOperationException("startTransaction is not implemented for CdmApplicationRemoteConfiguration");
+        }
         @Override
         public void commitTransaction(TransactionStatus txStatus) throws UnsupportedOperationException {
             throw new UnsupportedOperationException("commitTransaction is not implemented for CdmApplicationRemoteConfiguration");
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#setSessionFactory(org.hibernate.SessionFactory)
          */
         @Override
         public void setSessionFactory(SessionFactory sessionFactory) {
         public void authenticate(String username, String password){
             UsernamePasswordAuthenticationToken tokenForUser = new UsernamePasswordAuthenticationToken(username, password);
             Authentication authentication = this.getAuthenticationManager().authenticate(tokenForUser);
             SecurityContext context = SecurityContextHolder.getContext();
             context.setAuthentication(authentication);
+        }
+    }

     /**
     * Copyright (C) 2014 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
      * Copyright (C) 2014 EDIT
      * European Distributed Institute of Taxonomy
      * http://www.e-taxonomy.eu
+     *
      * The contents of this file are subject to the Mozilla Public License Version 1.1
      * See LICENSE.TXT at the top of this package for the full license terms.
      */
     package eu.etaxonomy.cdm.api.application;
-...
     import org.apache.log4j.Logger;
     import org.hibernate.collection.internal.AbstractPersistentCollection;
     import org.hibernate.proxy.AbstractLazyInitializer;
     import org.springframework.beans.MutablePropertyValues;
     import org.springframework.beans.factory.config.BeanDefinition;
     import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
     import org.springframework.context.ApplicationListener;
     import org.springframework.context.support.GenericApplicationContext;
     import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
     import org.springframework.core.io.ClassPathResource;
     import org.springframework.core.io.Resource;
     import eu.etaxonomy.cdm.api.application.CdmApplicationController;
     import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;
     import eu.etaxonomy.cdm.api.application.RemotingMonitoredGenericApplicationContext;
     import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
     import eu.etaxonomy.cdm.common.monitor.NullProgressMonitor;
     import eu.etaxonomy.cdm.common.monitor.SubProgressMonitor;
     import eu.etaxonomy.taxeditor.remoting.cache.CdmModelCacher;
     import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;
     import eu.etaxonomy.taxeditor.session.CdmEntitySessionManager;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
     /**
-...
         private static final Logger logger = Logger.getLogger(CdmApplicationRemoteController.class);
         public static final Resource DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE =
         		new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");
                 new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");
         private final Resource applicationContextResource;
         private final IProgressMonitor progressMonitor;
         /**
          * Creates new instance of CdmApplicationRemoteController
+         *
-...
          * @return
          */
         public static CdmApplicationRemoteController NewInstance(Resource applicationContextResource,
     			ICdmRemoteSource remoteSource,
     			boolean omitTermLoading,
     			IProgressMonitor progressMonitor,
     			List<ApplicationListener> listeners) {
         	return new CdmApplicationRemoteController(applicationContextResource,
         			remoteSource,
         			omitTermLoading,
         			progressMonitor,
     				listeners);
                 ICdmRemoteSource remoteSource,
                 boolean omitTermLoading,
                 IProgressMonitor progressMonitor,
                 List<ApplicationListener> listeners) {
             return new CdmApplicationRemoteController(applicationContextResource,
                     remoteSource,
                     omitTermLoading,
                     progressMonitor,
                     listeners);
+        }
         /**
-...
          * @return
          */
         public static CdmApplicationRemoteController NewInstance(ICdmRemoteSource remoteSource,
     			boolean omitTermLoading,
     			IProgressMonitor progressMonitor,
     			List<ApplicationListener> listeners) {
                 boolean omitTermLoading,
                 IProgressMonitor progressMonitor,
                 List<ApplicationListener> listeners) {
         	return new CdmApplicationRemoteController(DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE,
         			remoteSource,
         			omitTermLoading,
         			progressMonitor,
     				listeners);
             return new CdmApplicationRemoteController(DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE,
                     remoteSource,
                     omitTermLoading,
                     progressMonitor,
                     listeners);
+        }
     	/**
     	 * Constructs CdmApplicationRemoteController
+    	 *
     	 * @param applicationContextResource
     	 * @param remoteSource
     	 * @param omitTermLoading
     	 * @param progressMonitor
     	 * @param listeners
     	 */
     	private CdmApplicationRemoteController(Resource applicationContextResource,
     				ICdmRemoteSource remoteSource,
     				boolean omitTermLoading,
     				IProgressMonitor progressMonitor,
     				List<ApplicationListener> listeners){
     		logger.info("Start CdmApplicationRemoteController with remote source: " + remoteSource.getName());
         /**
          * Constructs CdmApplicationRemoteController
+         *
          * @param applicationContextResource
          * @param remoteSource
          * @param omitTermLoading
          * @param progressMonitor
          * @param listeners
          */
         private CdmApplicationRemoteController(Resource applicationContextResource,
                 ICdmRemoteSource remoteSource,
                 boolean omitTermLoading,
                 IProgressMonitor progressMonitor,
                 List<ApplicationListener> listeners){
             logger.info("Start CdmApplicationRemoteController with remote source: " + remoteSource.getName());
             this.applicationContextResource =
             		applicationContextResource != null ? applicationContextResource : DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE;
                     applicationContextResource != null ? applicationContextResource : DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE;
             this.progressMonitor = progressMonitor != null ? progressMonitor : new NullProgressMonitor();
             setNewRemoteSource(remoteSource, omitTermLoading, listeners);
+    	}
+        }
-...
          * @return
          */
         protected boolean setNewRemoteSource(ICdmRemoteSource remoteSource,
         		boolean omitTermLoading,
         		List<ApplicationListener> listeners){
                 boolean omitTermLoading,
                 List<ApplicationListener> listeners){
             logger.info("Connecting to '" + remoteSource.getName() + "'");
             RemotingMonitoredGenericApplicationContext applicationContext =  new RemotingMonitoredGenericApplicationContext();
             int refreshTasks = 45;
             int nTasks = 5 + refreshTasks;
             GenericApplicationContext applicationContext
                 = generateApplicationContext(applicationContextResource, listeners, progressMonitor, false);
             progressMonitor.beginTask("Connecting to '" + remoteSource.getName() + "'", nTasks);
             progressMonitor.subTask("Registering remote source.");
             PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
             Properties properties = new Properties();
             properties.setProperty("remoteServer", remoteSource.getServer());
-...
             properties.setProperty("remoteContext", remoteSource.getContextPath());
             pspc.setProperties(properties);
             applicationContext.addBeanFactoryPostProcessor(pspc);
             //progressMonitor.beginTask("Connecting to '" + remoteSource.getName() + "'", nTasks);
             applicationContext.refresh();
             applicationContext.start();
             progressMonitor.subTask("Cleaning up.");
             setApplicationContext(applicationContext);
             progressMonitor.worked(1);
             progressMonitor.done();
             return true;
+        }
         public static GenericApplicationContext generateApplicationContext(Resource applicationContextResource,
                 List<ApplicationListener> listeners,
                 IProgressMonitor progressMonitor,
                 boolean validateXml) {
             RemotingMonitoredGenericApplicationContext applicationContext =  new RemotingMonitoredGenericApplicationContext();
             int refreshTasks = 45;
             int nTasks = 5 + refreshTasks;
             progressMonitor.subTask("Registering remote source.");
             applicationContext.getEnvironment().setActiveProfiles("remoting");
             progressMonitor.worked(1);
             XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(applicationContext);
             //xmlReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_NONE);
             if(!validateXml) {
                 xmlReader.setValidationMode(XmlBeanDefinitionReader.VALIDATION_NONE);
+            }
             progressMonitor.subTask("Registering resources.");
             xmlReader.loadBeanDefinitions(applicationContextResource);
             progressMonitor.worked(1);
             //omitTerms
             if (omitTermLoading == true){
                 String initializerName = "persistentTermInitializer";
                 BeanDefinition beanDef = applicationContext.getBeanDefinition(initializerName);
                 MutablePropertyValues values = beanDef.getPropertyValues();
                 values.addPropertyValue("omit", omitTermLoading);
+            }
             if (listeners != null){
                 for(ApplicationListener listener : listeners){
                     applicationContext.addApplicationListener(listener);
+                }
+            }
             applicationContext.refresh(new SubProgressMonitor(progressMonitor, refreshTasks));
             applicationContext.start();
             progressMonitor.subTask("Cleaning up.");
             setApplicationContext(applicationContext);
             progressMonitor.worked(1);
             progressMonitor.done();
             return true;
             return applicationContext;
+        }
         /* (non-Javadoc)
-...
         @Override
         protected void init(){
             configuration = (ICdmApplicationConfiguration)applicationContext.getBean("cdmApplicationRemoteConfiguration");
     		AbstractLazyInitializer.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
     		AbstractPersistentCollection.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
     		CdmModelCacher cmdmc = new CdmModelCacher();
     		cmdmc.cacheGetterFields();
             AbstractLazyInitializer.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
             AbstractPersistentCollection.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
             CdmModelCacher cmdmc = new CdmModelCacher();
             cmdmc.cacheGetterFields();
+        }
         public ICdmEntitySessionManager getCdmEntitySessionManager() {
         	return ((CdmApplicationRemoteConfiguration)configuration).getCdmEntitySessionManager();
             return ((CdmApplicationRemoteConfiguration)configuration).getCdmEntitySessionManager();
+        }
+    }

     */
     package eu.etaxonomy.cdm.api.application;
     import java.util.concurrent.CancellationException;
     import java.io.Serializable;
     import org.apache.log4j.Logger;
     import org.springframework.beans.BeansException;
     import org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver;
     import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
     import org.springframework.beans.factory.support.DefaultListableBeanFactory;
     import org.springframework.context.support.GenericApplicationContext;
     import org.springframework.core.LocalVariableTableParameterNameDiscoverer;
     import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
     import eu.etaxonomy.cdm.common.monitor.SubProgressMonitor;
     /**
      * {@link GenericApplicationContext Generic application context} which allows progress monitoring.
      * @author a.mueller
      * @date 29.09.2011
+     *
      */
     public class RemotingMonitoredGenericApplicationContext extends GenericApplicationContext{
     public class RemotingMonitoredGenericApplicationContext extends GenericApplicationContext implements Serializable {
         @SuppressWarnings("unused")
         private static final Logger logger = Logger.getLogger(CdmApplicationController.class);
         private static final Logger logger = Logger.getLogger(RemotingMonitoredGenericApplicationContext.class);
         final int countInvokeBeanFactoryPostProcessors = 10;
         final int countFinishBeanFactoryInitialization = 90;
         private final int countTasks = countInvokeBeanFactoryPostProcessors + countFinishBeanFactoryInitialization;
         private IProgressMonitor currentMonitor;
        // private IProgressMonitor currentMonitor;
-...
          * Constructor.
          * @param progressMonitor
          */
     //    public RemotingMonitoredGenericApplicationContext() {
     ////		MonitoredListableBeanFactory beanFactory =
     //        super(new RemotingMonitoredListableBeanFactory());
     //        //taken from empty constructor of GenericApplicationContext
     //        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setSerializationId(getId());
     //        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
     //        ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
     //    }
         public RemotingMonitoredGenericApplicationContext() {
     //		MonitoredListableBeanFactory beanFactory =
             super(new RemotingMonitoredListableBeanFactory());
     //      MonitoredListableBeanFactory beanFactory =
             super();
             //taken from empty constructor of GenericApplicationContext
             ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setSerializationId(getId());
             ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
             ((RemotingMonitoredListableBeanFactory)getBeanFactory()).setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
             ((DefaultListableBeanFactory)getBeanFactory()).setSerializationId(getId());
             ((DefaultListableBeanFactory)getBeanFactory()).setParameterNameDiscoverer(new LocalVariableTableParameterNameDiscoverer());
             ((DefaultListableBeanFactory)getBeanFactory()).setAutowireCandidateResolver(new QualifierAnnotationAutowireCandidateResolver());
+        }
         public int countTasks(){
             return countTasks;
+        }
         protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){
             String task = "Invoke bean factory post processors";
             checkMonitorCancelled(currentMonitor);
             currentMonitor.subTask(task);
             super.invokeBeanFactoryPostProcessors(beanFactory);
             currentMonitor.worked(countInvokeBeanFactoryPostProcessors);
             checkMonitorCancelled(currentMonitor);
+        }
     //    public int countTasks(){
     //        return countTasks;
     //    }
     //
     //    @Override
     //    protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory){
     //        String task = "Invoke bean factory post processors";
     ////        checkMonitorCancelled(currentMonitor);
     ////        currentMonitor.subTask(task);
     //        super.invokeBeanFactoryPostProcessors(beanFactory);
     ////        currentMonitor.worked(countInvokeBeanFactoryPostProcessors);
     ////        checkMonitorCancelled(currentMonitor);
     //    }
     //
     //    @Override
     //    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){
     ////        checkMonitorCancelled(currentMonitor);
     //        String task = "Finish bean factory initialization";
     ////        currentMonitor.subTask(task);
     ////        IProgressMonitor subMonitor	= new SubProgressMonitor(currentMonitor, countFinishBeanFactoryInitialization);
     ////        getMyBeanFactory().setCurrentMonitor(subMonitor);
     //        super.finishBeanFactoryInitialization(beanFactory);
     ////        checkMonitorCancelled(currentMonitor);
     //
     //    }
     //    /**
     //     * @param progressMonitor the progressMonitor to set
     //     */
     //    public void setCurrentMonitor(IProgressMonitor monitor) {
     ////        this.currentMonitor = monitor;
     //    }
     //
     //    /**
     //     *
     //     */
     //    public IProgressMonitor getCurrentMonitor() {
     ////        return currentMonitor;
     //        return null;
     //    }
     //    /* (non-Javadoc)
     //     * @see org.springframework.context.support.AbstractApplicationContext#refresh()
     //     */
     //    @Override
     //    public void refresh() throws BeansException, IllegalStateException {
     //        //checkMonitorCancelled(monitor);
     //        String message = "Refresh application context. This might take a while ...";
     ////        currentMonitor = monitor;
     //        beginTask(message, countTasks);
     //        super.refresh();
     //        taskDone();
     //        //checkMonitorCancelled(monitor);
     //    }
         protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory){
             checkMonitorCancelled(currentMonitor);
             String task = "Finish bean factory initialization";
             currentMonitor.subTask(task);
             IProgressMonitor subMonitor	= new SubProgressMonitor(currentMonitor, countFinishBeanFactoryInitialization);
             getMyBeanFactory().setCurrentMonitor(subMonitor);
             super.finishBeanFactoryInitialization(beanFactory);
             checkMonitorCancelled(currentMonitor);
+        }
         /**
          * @param progressMonitor the progressMonitor to set
          */
         public void setCurrentMonitor(IProgressMonitor monitor) {
             this.currentMonitor = monitor;
+        }
         /**
+         *
          */
         public IProgressMonitor getCurrentMonitor() {
             return currentMonitor;
+        }
         /* (non-Javadoc)
          * @see org.springframework.context.support.AbstractApplicationContext#refresh()
          */
         public void refresh(IProgressMonitor monitor) throws BeansException, IllegalStateException {
             checkMonitorCancelled(monitor);
             String message = "Refresh application context. This might take a while ...";
             currentMonitor = monitor;
             beginTask(message, countTasks);
             super.refresh();
             taskDone();
             checkMonitorCancelled(monitor);
+        }
         /**
+         *
          */
         private void taskDone() {
             if (currentMonitor != null){
                 currentMonitor.done();
+            }
+        }
         /**
          * @param monitor
          * @param message
          */
         private void beginTask(String message, int countTasks) {
             if (currentMonitor != null){
                 currentMonitor.beginTask(message, countTasks);
+            }
+        }
         private RemotingMonitoredListableBeanFactory getMyBeanFactory(){
             return (RemotingMonitoredListableBeanFactory)getBeanFactory();
+        }
         private void checkMonitorCancelled(IProgressMonitor monitor) {
             if (monitor != null && monitor.isCanceled()){
                 throw new CancellationException();
+            }
+        }
     //    private void taskDone() {
     ////        if (currentMonitor != null){
     ////            currentMonitor.done();
     ////        }
     //    }
     //    /**
     //     * @param monitor
     //     * @param message
     //     */
     //    private void beginTask(String message, int countTasks) {
     ////        if (currentMonitor != null){
     ////            currentMonitor.beginTask(message, countTasks);
     ////        }
     //    }
     //    private RemotingMonitoredListableBeanFactory getMyBeanFactory(){
     //        return (RemotingMonitoredListableBeanFactory)getBeanFactory();
     //    }
     //
     //
     //    private void checkMonitorCancelled(IProgressMonitor monitor) {
     //        if (monitor != null && monitor.isCanceled()){
     //            throw new CancellationException();
     //        }
     //    }
+    }

     // $Id$
     /**
     * Copyright (C) 2009 EDIT
     * European Distributed Institute of Taxonomy
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
-...
     public class RemotingMonitoredListableBeanFactory extends DefaultListableBeanFactory {
     	@SuppressWarnings("unused")
     	private static final Logger logger = Logger.getLogger(RemotingMonitoredListableBeanFactory.class);
     	private boolean isInitializingBeans = false;
     	private IProgressMonitor currentMonitor;
     	private static List<String> beansToMonitor = Arrays.asList("sessionFactory","defaultBeanInitializer","persistentTermInitializer");
     	private Set<String> alreadyMonitoredBeans = new HashSet<String>();
     	private final Set<String> alreadyMonitoredBeans = new HashSet<String>();
     	public RemotingMonitoredListableBeanFactory(){
+    	}
     //	@Override
     //	protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
     //		if (registeredBeanNames.contains(beanName)){
     //			return super.getMergedLocalBeanDefinition(beanName);
     //
     //
     //		}
     ////		String message = "Handle bean '%s'";
     ////		message = String.format(message, beanName);
-...
     ////		registeredBeanNames.add(beanName);
     //		return result;
     //	}
     	public void preInstantiateSingletons() throws BeansException {
     	@Override
         public void preInstantiateSingletons() throws BeansException {
     		isInitializingBeans = true;
     		checkMonitorCancelled(currentMonitor);
     		int countBeans = 0;
-...
     //		}
     //		return result;
     //	}
     	protected Object createBean(final String name, final RootBeanDefinition mbd, final Object[] args){
     	@Override
         protected Object createBean(final String name, final RootBeanDefinition mbd, final Object[] args){
     		boolean doMonitor = isInitializingBeans && beansToMonitor.contains(name) && !alreadyMonitoredBeans.contains(name);
     		checkMonitorCancelled(currentMonitor);
     		if (doMonitor){
-...
     		return result;
+    	}
     	/**
     	 * @param mainMonitor the mainMonitor to set
     	 */
     	public void setCurrentMonitor(IProgressMonitor monitor) {
     		this.currentMonitor = monitor;
+    	}
     	private void checkMonitorCancelled(IProgressMonitor monitor) {
     		if (monitor != null && monitor.isCanceled()){
     			throw new CancellationException();
+    		}
+    		}
+    	}
+    }

     import eu.etaxonomy.taxeditor.remoting.cache.CdmTransientEntityCacher;
     import eu.etaxonomy.taxeditor.service.TermServiceRequestExecutor;
     import eu.etaxonomy.taxeditor.session.CdmEntitySession;
     import eu.etaxonomy.taxeditor.session.CdmEntitySessionManager;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySession;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManagerObserver;
     /**
      * Class which uses CDM services to cache cdm entities
-...
      * @param <T>
      */
     @Component
     public class CdmServiceCacher extends CdmCacher {
     public class CdmServiceCacher extends CdmCacher  implements ICdmEntitySessionManagerObserver {
         @Autowired
         ITermService termService;
         @Autowired
         private CdmEntitySessionManager cdmEntitySessionManager;
         private ICdmEntitySessionManager cdmEntitySessionManager;
         private CdmTransientEntityCacher cdmTransientEntityCacher;
-...
             return false;
+        }
         public void setActiveSession(ICdmEntitySession cdmEntitySession) {
         public void setCdmEntitySessionManager(ICdmEntitySessionManager cdmEntitySessionManager) {
             this.cdmEntitySessionManager = cdmEntitySessionManager;
             if(cdmEntitySessionManager != null) {
                 cdmEntitySessionManager.addSessionObserver(this);
+            }
+        }
         public CdmTransientEntityCacher getCurrentCacher() {
             ICdmEntitySession cdmEntitySession = cdmEntitySessionManager.getActiveSession();
             if(cdmEntitySession != null && cdmEntitySession instanceof CdmEntitySession) {
                 this.cdmTransientEntityCacher = ((CdmEntitySession) cdmEntitySession).getCacher();
             } else {
                 this.cdmTransientEntityCacher = null;
                 return ((CdmEntitySession) cdmEntitySession).getCacher();
+            }
             return null;
+        }
         @Override
-...
             return cachedCdmEntity;
+        }
         /* (non-Javadoc)
          * @see eu.etaxonomy.taxeditor.session.ICdmEntitySessionManagerObserver#changed()
          */
         @Override
         public void changed() {
             ICdmEntitySession cdmEntitySession = cdmEntitySessionManager.getActiveSession();
             if(cdmEntitySession != null && cdmEntitySession instanceof CdmEntitySession) {
                 this.cdmTransientEntityCacher = ((CdmEntitySession) cdmEntitySession).getCacher();
             } else {
                 this.cdmTransientEntityCacher = null;
+            }
+        }
+    }

     			String mappedClassName = mappedClass.getName();
     			CdmModelFieldPropertyFromClass cmgmfc = new CdmModelFieldPropertyFromClass(mappedClassName);
     			addGetters(persistentClass, cmgmfc);
     			logger.info("Adding class : " + mappedClassName + " to cache");
     			addGetters(persistentClass, cmgmfc);
     			cache.put(new Element(mappedClassName, cmgmfc));
+    		}

         public void bind() {
             logger.info("Binding session with owner " + sessionOwner.toString());
             cdmEntitySessionManager.bind(sessionOwner);
             cdmEntitySessionManager.notifyObservers();
+        }
         /* (non-Javadoc)

     import java.util.Set;
     import org.apache.log4j.Logger;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.stereotype.Component;
     import eu.etaxonomy.cdm.api.cache.CdmServiceCacher;
     import eu.etaxonomy.cdm.model.common.CdmBase;
     import eu.etaxonomy.cdm.persistence.hibernate.CdmDataChangeEvent.EventType;
-...
         private ICdmEntitySession activeSession;
         @Autowired
         private CdmServiceCacher cdmServiceCacher;
         @Override
         public ICdmEntitySession newSession(ICdmEntitySessionEnabled sessionOwner, boolean setAsActive) {
-...
         private void setActiveSession(ICdmEntitySession activeSession) {
             this.activeSession = activeSession;
             cdmServiceCacher.setActiveSession(activeSession);
             notifyObservers();
+        }

     <?xml version="1.0" encoding="UTF-8"?>
     <beans default-lazy-init="true" xmlns="http://www.springframework.org/schema/beans"
     <beans xmlns="http://www.springframework.org/schema/beans"
       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
-...
         </property>
       </bean>
       <bean id="providerManager"
       <bean id="authenticationManager"
         class="org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean">
         <property name="serviceUrl">
           <value>http://${remoteServer}:${remotePort}/${remoteContext}/remoting/authenticationManager.service</value>

     <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
     	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
       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">
     	<!-- <bean id="remoteTermInitializer" class="eu.etaxonomy.cdm.remote.service.RemoteTermInitializer"/> -->
       <!-- <bean id="remoteTermInitializer" class="eu.etaxonomy.cdm.remote.service.RemoteTermInitializer"/> -->
     	<context:annotation-config />
       <context:annotation-config />
     	<import resource="classpath:/eu/etaxonomy/cdm/httpInvokerServiceClients.xml" />
       <import resource="classpath:/eu/etaxonomy/cdm/httpInvokerServiceClients.xml" />
     	<context:component-scan base-package="eu/etaxonomy/taxeditor/session" />
     	<bean id="cdmApplicationRemoteConfiguration"
     		class="eu.etaxonomy.cdm.api.application.CdmApplicationRemoteConfiguration" />
     	<import resource="classpath:/eu/etaxonomy/cdm/remoting_services_security.xml" />
       <!-- <context:component-scan base-package="eu/etaxonomy/taxeditor/session"
         /> -->
       <bean id="cdmEntitySessionManager"  class="eu.etaxonomy.taxeditor.session.CdmEntitySessionManager" />
     	<context:component-scan base-package="eu.etaxonomy.cdm.api.cache">
     		<!-- FIXME:Remoting Temp workaround to make remoting work -->
     		<context:exclude-filter type="regex"
     			expression="eu\.etaxonomy\.cdm\.api\.cache\.CdmTermCacher" />
     	</context:component-scan>
       <bean id="cdmApplicationRemoteConfiguration"
         class="eu.etaxonomy.cdm.api.application.CdmApplicationRemoteConfiguration" />
     	<context:component-scan base-package="eu.etaxonomy.taxeditor.service"/>
     	<!-- EditGeoService was moved to ext. Therefore it will not be found by
     		the default component scan. We added it here because the Editor needs it.
     		However, this is only a temporary solution. In the future we want to pass
     		in an application context with the editor. -->
       <!-- <import resource="classpath:/eu/etaxonomy/cdm/remoting_services_security.xml"
         /> -->
     <!--   <context:component-scan base-package="eu.etaxonomy.taxeditor.service" /> -->
       <bean id="cdmServiceRequestExecutor"
         class="eu.etaxonomy.taxeditor.service.CdmServiceRequestExecutor" />
       <bean id="cachedCommonService"
         class="eu.etaxonomy.taxeditor.service.CachedCommonServiceImpl" />
       <bean id="accessDecisionManager"
         class="eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable">
         <property name="decisionVoters">
           <list>
             <bean
               class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.GrantAlwaysVoter" />
             <bean
               class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonNodeVoter" />
             <bean
               class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonBaseVoter" />
             <bean
               class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionBaseVoter" />
             <bean
               class="eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionElementVoter" />
           </list>
         </property>
       </bean>
       <!-- CdmPermissionEvaluator.hasPermissions() evaluates the CdmPermissions
         like TAXONNODE.UPDATE{20c8f083-5870-4cbd-bf56-c5b2b98ab6a7} -->
       <bean id="cdmPermissionEvaluator"
         class="eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator">
         <property name="accessDecisionManager" ref="accessDecisionManager" />
       </bean>
       <!-- The CdmSecurityHibernateInterceptor checks onSave() and on flushDirty()
         if the currently authenticated principal or token has sufficient permissions
         on the entity to be persisted -->
       <bean id="securityHibernateInterceptor"
         class="eu.etaxonomy.cdm.persistence.hibernate.CdmSecurityHibernateInterceptor">
         <property name="permissionEvaluator" ref="cdmPermissionEvaluator" />
       </bean>
     <!--   <bean id="authenticationManager" -->
     <!--     class="org.springframework.security.authentication.ProviderManager"> -->
     <!--     <property name="providers"> -->
     <!--       <list> -->
     <!--         <ref local="daoAuthenticationProvider" /> -->
     <!--       </list> -->
     <!--     </property> -->
     <!--   </bean> -->
     <!--   <bean id="daoAuthenticationProvider" -->
     <!--     class="org.springframework.security.authentication.dao.DaoAuthenticationProvider"> -->
     <!--     <property name="userDetailsService" ref="userService" /> -->
     <!--     <property name="saltSource" ref="saltSource" /> -->
     <!--     <property name="passwordEncoder" ref="passwordEncoder" /> -->
     <!--   </bean> -->
     <!--   <bean id="passwordEncoder" -->
     <!--     class="org.springframework.security.authentication.encoding.Md5PasswordEncoder" /> -->
     <!--   <bean id="saltSource" -->
     <!--     class="org.springframework.security.authentication.dao.ReflectionSaltSource"> -->
     <!--     <property name="userPropertyToUse" value="getUsername" /> -->
     <!--   </bean> -->
       <context:component-scan base-package="eu.etaxonomy.cdm.api.cache">
         <!-- FIXME:Remoting Temp workaround to make remoting work -->
         <context:exclude-filter type="regex"
           expression="eu\.etaxonomy\.cdm\.api\.cache\.CdmTermCacher" />
       </context:component-scan>
     	<!-- <bean id="conversationHolder" class="eu.etaxonomy.cdm.api.conversation.ConversationHolder"
     		scope="prototype"/> -->
     	<!-- TODO move to io -->
     	<!-- <context:component-scan base-package="eu/etaxonomy/cdm/io"> <context:exclude-filter
     		type="regex" expression="eu\.etaxonomy\.cdm\.io\.berlinModel.*" /> </context:component-scan> -->
     	<!-- enable the configuration of transactional behavior based on annotations -->
     	<!-- <tx:annotation-driven transaction-manager="transactionManager"/> -->
     </beans>

               security specific configuration
             ======================================================================
          -->
         <security:global-method-security pre-post-annotations="enabled" run-as-manager-ref="runAsManager" >
             <security:expression-handler ref="expressionHandler" />
         </security:global-method-security>
     <!--     <security:global-method-security pre-post-annotations="enabled" run-as-manager-ref="runAsManager" > -->
     <!--         <security:expression-handler ref="expressionHandler" /> -->
     <!--     </security:global-method-security> -->
         <!--
             To use "hasPermission()" in the Spring EL method annotations like @PreAuthorize we explicitly configure the permissionEvaluator
             the cdmPermissionEvaluator is already defined in the persistence security context
         -->
         <bean id="expressionHandler" class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler">
             <property name="permissionEvaluator" ref="cdmPermissionEvaluator" />
         </bean>
     <!--     <bean id="expressionHandler" class="org.springframework.security.access.expression.method.DefaultMethodSecurityExpressionHandler"> -->
     <!--         <property name="permissionEvaluator" ref="cdmPermissionEvaluator" /> -->
     <!--     </bean> -->
         <bean id="authenticationManager" class="org.springframework.security.authentication.ProviderManager">
             <property name="providers">
-...
             the key must match FirstDataInserter.RUN_AS_KEY
          -->
         <bean id="runAsManager"
             class="org.springframework.security.access.intercept.RunAsManagerImpl">
           <property name="key" value="TtlCx3pgKC4l"/>
         </bean>
     <!--     <bean id="runAsManager" -->
     <!--         class="org.springframework.security.access.intercept.RunAsManagerImpl"> -->
     <!--       <property name="key" value="TtlCx3pgKC4l"/> -->
     <!--     </bean> -->
     </beans>

     // $Id$
     /**
     * Copyright (C) 2015 EDIT
     * European Distributed Institute of Taxonomy
     * http://www.e-taxonomy.eu
+    *
     * The contents of this file are subject to the Mozilla Public License Version 1.1
     * See LICENSE.TXT at the top of this package for the full license terms.
     */
     package eu.etaxonomy.taxeditor.application;
     /**
      * @author cmathew
      * @date 26 May 2015
+     *
      */
     public class CdmApplicationRemoteControllerTest {
+    }

Project

General

Profile

EDIT

Revision 6548ea8a

Added by Cherian Mathew almost 9 years ago