EDIT

/**

 * 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 java.util.ArrayList;

import java.util.Arrays;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.apache.log4j.Logger;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;

import org.springframework.security.access.AccessDecisionVoter;

import org.springframework.security.authentication.AuthenticationProvider;

import org.springframework.security.authentication.ProviderManager;

import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;

import org.springframework.security.authentication.dao.DaoAuthenticationProvider;

import org.springframework.security.authentication.dao.ReflectionSaltSource;

import org.springframework.security.authentication.encoding.Md5PasswordEncoder;

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.IAnnotationService;

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.ITestService;

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.io.service.IIOService;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator;

import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;

import eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable;

import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionBaseVoter;

import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionElementVoter;

import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.GrantAlwaysVoter;

import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonBaseVoter;

import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonNodeVoter;

import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;

import eu.etaxonomy.taxeditor.service.CachedCommonServiceImpl;

import eu.etaxonomy.taxeditor.service.CdmServiceRequestExecutor;

import eu.etaxonomy.taxeditor.service.ICachedCommonService;

import eu.etaxonomy.taxeditor.service.TermServiceRequestExecutor;

import eu.etaxonomy.taxeditor.session.CdmEntitySessionManager;

import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;

/**

 * CDM Application Configuration class which manages the configuration for remoting

 * clients

 *

 */

@Component

public class CdmApplicationRemoteConfiguration implements ICdmApplicationConfiguration, ApplicationContextAware  {

    @SuppressWarnings("unused")

    private static final Logger logger = Logger.getLogger(CdmApplicationRemoteConfiguration.class);

    protected ApplicationContext applicationContext;

    private ICdmRemoteSource remoteSource;

    private Map serviceMap = new HashMap<Class<IService>, IService>();

    private ICdmEntitySessionManager cdmEntitySessionManager;

    private CdmPermissionEvaluator cdmPermissionEvaluator;

    private ProviderManager authenticationManager;

    private ICachedCommonService cachedCommonService;

    public CdmApplicationRemoteConfiguration() {}

    public CdmApplicationRemoteConfiguration(ICdmRemoteSource remoteSource) {

        this.remoteSource = remoteSource;

    }

    public void setRemoteSource(ICdmRemoteSource remoteSource) {

        this.remoteSource = remoteSource;

    }

    private Object getService(Class<?> clazz, String serviceSuffix, CdmServiceRequestExecutor executor) {

        if(serviceMap.containsKey(clazz)) {

            return serviceMap.get(clazz);

        }

        String baseUrl;

        if(remoteSource.getContextPath() == null || remoteSource.getContextPath().equals("")) {

            baseUrl = "http://" + remoteSource.getServer() + ":" + String.valueOf(remoteSource.getPort());

        } else {

            baseUrl = "http://" + remoteSource.getServer()  + ":" + String.valueOf(remoteSource.getPort()) + "/" + remoteSource.getContextPath();

        }

        HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();

        proxy.setServiceInterface(clazz);

        proxy.setServiceUrl(baseUrl + serviceSuffix);

        if(executor != null) {

            executor.setReadTimeout(0);

            proxy.setHttpInvokerRequestExecutor(executor);

        }

        proxy.afterPropertiesSet();

        Object service = proxy.getObject();

        serviceMap.put(clazz,  service);

        return service;

    }

    // ****************************** APPLICATION CONTEXT *************************************************/

    @Override

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{

        this.applicationContext = applicationContext;

    }

    /* (non-Javadoc)

     * @see eu.etaxonomy.cdm.api.application.CdmApplicationDefaultConfiguration#getTransactionManager()

     */

    @Override

    public PlatformTransactionManager getTransactionManager() throws UnsupportedOperationException {

        throw new UnsupportedOperationException("getTransactionManager is not implemented for CdmApplicationRemoteConfiguration");

    }

    /**

     * @return

     */

    public IEditGeoService getEditGeoService() {

        return (IEditGeoService) getService(IEditGeoService.class, "/remoting/editgeo.service", new CdmServiceRequestExecutor());

    }

    /**

     * @return

     */

    public ICachedCommonService getCachedCommonService(){

        if(cachedCommonService == null) {

            cachedCommonService = new CachedCommonServiceImpl();

        }

        return cachedCommonService;

    }

    public ICdmEntitySessionManager getCdmEntitySessionManager() {

        if(cdmEntitySessionManager == null) {

            cdmEntitySessionManager = new CdmEntitySessionManager();

        }

        return cdmEntitySessionManager;

    }

 // ****************************** GETTER *************************************************/

    @Override

    public final Object getBean(String name){

        throw new UnsupportedOperationException("getBean is not implemented for CdmApplicationRemoteConfiguration");

    }

    @Override

    public IAgentService getAgentService(){

        return (IAgentService) getService(IAgentService.class, "/remoting/agent.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IAnnotationService getAnnotationService(){

        return (IAnnotationService) getService(IAnnotationService.class, "/remoting/annotation.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IDatabaseService getDatabaseService(){

        return (IDatabaseService) getService(IDatabaseService.class, "/remoting/database.service", new CdmServiceRequestExecutor());

    }

    @Override

    public INameService getNameService(){

        return (INameService) getService(INameService.class, "/remoting/name.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IReferenceService getReferenceService(){

        return (IReferenceService) getService(IReferenceService.class, "/remoting/reference.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ITaxonService getTaxonService(){

        return (ITaxonService) getService(ITaxonService.class, "/remoting/taxon.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IClassificationService getClassificationService(){

        return (IClassificationService) getService(IClassificationService.class, "/remoting/classification.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ITaxonNodeService getTaxonNodeService(){

        return (ITaxonNodeService) getService(ITaxonNodeService.class, "/remoting/taxonnode.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IDescriptionService getDescriptionService(){

        return (IDescriptionService) getService(IDescriptionService.class, "/remoting/description.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IOccurrenceService getOccurrenceService(){

        return (IOccurrenceService) getService(IOccurrenceService.class, "/remoting/occurrence.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IPrimerService getPrimerService(){

        return (IPrimerService) getService(IPrimerService.class, "/remoting/primer.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IAmplificationService getAmplificationService(){

        return (IAmplificationService) getService(IAmplificationService.class, "/remoting/amplification.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ISequenceService getSequenceService(){

        return (ISequenceService) getService(ISequenceService.class, "/remoting/sequence.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IMediaService getMediaService(){

        return (IMediaService) getService(IMediaService.class, "/remoting/media.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ITermService getTermService(){

        return (ITermService) getService(ITermService.class, "/remoting/term.service", new TermServiceRequestExecutor());

    }

    @Override

    public ICommonService getCommonService(){

        return (ICommonService) getService(ICommonService.class, "/remoting/common.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ILocationService getLocationService(){

        return (ILocationService) getService(ILocationService.class, "/remoting/location.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IUserService getUserService(){

        return (IUserService) getService(IUserService.class, "/remoting-public/user.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IGrantedAuthorityService getGrantedAuthorityService(){

        return (IGrantedAuthorityService) getService(IGrantedAuthorityService.class, "/remoting/grantedauthority.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IService<CdmBase> getMainService(){

        return null;

    }

    @Override

    public ProviderManager getAuthenticationManager(){

        if(authenticationManager != null) {

            return authenticationManager;

        }

        Md5PasswordEncoder passwordEncoder = new Md5PasswordEncoder();

        ReflectionSaltSource saltSource = new ReflectionSaltSource();

        saltSource.setUserPropertyToUse("getUsername");

        DaoAuthenticationProvider daoAuthenticationProvider = new DaoAuthenticationProvider();

        daoAuthenticationProvider.setUserDetailsService(getUserService());

        daoAuthenticationProvider.setSaltSource(saltSource);

        daoAuthenticationProvider.setPasswordEncoder(passwordEncoder);

        authenticationManager = new ProviderManager(Arrays.asList((AuthenticationProvider)daoAuthenticationProvider));

        return authenticationManager;

    }

    @Override

    public ConversationHolder NewConversation() {

        return new ConversationHolderMock();

    }

    @Override

    public ICollectionService getCollectionService(){

        return (ICollectionService) getService(ICollectionService.class, "/remoting/collection.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IFeatureTreeService getFeatureTreeService(){

        return (IFeatureTreeService) getService(IFeatureTreeService.class, "/remoting/featuretree.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IFeatureNodeService getFeatureNodeService(){

        return (IFeatureNodeService) getService(IFeatureNodeService.class, "/remoting/featurenode.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IVocabularyService getVocabularyService(){

        return (IVocabularyService) getService(IVocabularyService.class, "/remoting/vocabulary.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IIdentificationKeyService getIdentificationKeyService(){

        return (IIdentificationKeyService) getService(IIdentificationKeyService.class, "/remoting/identificationkey.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IPolytomousKeyService getPolytomousKeyService(){

        return (IPolytomousKeyService) getService(IPolytomousKeyService.class, "/remoting/polytomouskey.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IPolytomousKeyNodeService getPolytomousKeyNodeService(){

        return (IPolytomousKeyNodeService) getService(IPolytomousKeyNodeService.class, "/remoting/polytomouskeynode.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IWorkingSetService getWorkingSetService(){

        return (IWorkingSetService) getService(IWorkingSetService.class, "/remoting/workingset.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IGroupService getGroupService(){

        return (IGroupService) getService(IGroupService.class, "/remoting/group.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IEntityValidationService getEntityValidationService(){

        return (IEntityValidationService) getService(IEntityValidationService.class, "/remoting/entityvalidation.service", new CdmServiceRequestExecutor());

    }

    @Override

    public IEntityConstraintViolationService getEntityConstraintViolationService(){

        return (IEntityConstraintViolationService) getService(IEntityConstraintViolationService.class, "/remoting/entityconstraintviolation.service", new CdmServiceRequestExecutor());

    }

    @Override

    public ICdmPermissionEvaluator getPermissionEvaluator(){

        if(cdmPermissionEvaluator != null) {

            return cdmPermissionEvaluator;

        }

        List<AccessDecisionVoter> decisionVoters = new ArrayList<AccessDecisionVoter>();

        decisionVoters.add(new GrantAlwaysVoter());

        decisionVoters.add(new TaxonNodeVoter());

        decisionVoters.add(new TaxonBaseVoter());

        decisionVoters.add(new DescriptionBaseVoter());

        decisionVoters.add(new DescriptionElementVoter());

        UnanimousBasedUnrevokable accessDecisionManager = new UnanimousBasedUnrevokable(decisionVoters);

        cdmPermissionEvaluator = new CdmPermissionEvaluator();

        cdmPermissionEvaluator.setAccessDecisionManager(accessDecisionManager);

        return cdmPermissionEvaluator;

    }

    @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");

    }

    @Override

    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);

    }

    public IIOService getIOService() {

        return (IIOService) getService(IIOService.class, "/remoting/io.service", new CdmServiceRequestExecutor());

    }

    public ITestService getTestService() {

        return (ITestService) getService(ITestService.class, "/remoting/test.service", new CdmServiceRequestExecutor());

    }

}