EDIT

import eu.etaxonomy.cdm.api.service.longrunningService.ILongRunningTasksService;

import eu.etaxonomy.cdm.api.service.longrunningService.ILongRunningTasksService;

import eu.etaxonomy.cdm.api.service.longrunningService.ILongRunningTasksService;

/**

* 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.cdm.api.service.longrunningService;

import java.util.Collection;

import java.util.Set;

import java.util.UUID;

import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;

import eu.etaxonomy.cdm.api.service.config.CacheUpdaterConfigurator;

import eu.etaxonomy.cdm.api.service.config.DescriptionAggregationConfiguration;

import eu.etaxonomy.cdm.api.service.config.ForSubtreeConfiguratorBase;

import eu.etaxonomy.cdm.api.service.config.SortIndexUpdaterConfigurator;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;

import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;

/**

 * @author cmathew

 * @since 31 Jul 2015

 *

 */

public interface ILongRunningTasksService {

    /**

     * @param configurator

     * @return

     */

    public UUID monitLongRunningTask(ForSubtreeConfiguratorBase configurator);

    /**

     * @param configurator

     * @return

     */

    public UUID monitLongRunningTask(CacheUpdaterConfigurator configurator);

    /**

     * @param movingUuids

     * @param targetTreeNodeUuid

     * @param movingType

     * @param monitor

     * @return

     */

    UUID monitLongRunningTask(Set<UUID> movingUuids, UUID targetTreeNodeUuid, int movingType);

    /**

     * Monitored invocation of {@link IDescriptiveDataSetService#aggregate(UUID, IProgressMonitor)}

     * @param descriptiveDataSetUuid the data set which should be aggregated

     * @param config the aggregation configuration

     * @return the uuid of the monitor

     */

    public UUID aggregateDescriptiveDataSet(UUID descriptiveDataSetUuid,  DescriptionAggregationConfiguration config);

    /**

     * Monitored invocation of {@link IDescriptiveDataSetService#addRowWrapperToDataset(Collection, UUID)}

     * @param wrapper the specimen wrapper to use for creating the row wrapper

     * @param datasetUuid the target dataset

     * @return the uuid of the monitor

     */

    public UUID addRowWrapperToDataset(Collection<SpecimenNodeWrapper> wrapper, UUID datasetUuid);

    /**

     * Monitored invocation of {@link IDescriptiveDataSetService#generatePolytomousKey(UUID, UUID))}

     * @param datasetUuid the data set

     * @param taxonUuid the taxonomic scope of the key

     * @return the uuid of the monitor

     */

    public UUID generatePolytomousKey(UUID datasetUuid, UUID taxonUuid);

    /**

     * Monitored invocation of {@link IDescriptiveDataSetService#getRowWrapper(DescriptiveDataSet, IProgressMonitor)}

     * @param descriptiveDataSetUuid the working set for which getRowWrapper() is invoked

     * @return the uuid of the monitor

     */

    public UUID monitGetRowWrapper(UUID descriptiveDataSetUuid);

    /**

     * @param configurator

     * @return

     */

    UUID monitLongRunningTask(SortIndexUpdaterConfigurator configurator);

}

/**

 * 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.cdm.api.service.longrunningService;

import java.io.Serializable;

import java.util.Collection;

import java.util.Set;

import java.util.UUID;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.IDescriptiveDataSetService;

import eu.etaxonomy.cdm.api.service.IProgressMonitorService;

import eu.etaxonomy.cdm.api.service.ITaxonNodeService;

import eu.etaxonomy.cdm.api.service.UpdateResult;

import eu.etaxonomy.cdm.api.service.config.CacheUpdaterConfigurator;

import eu.etaxonomy.cdm.api.service.config.DescriptionAggregationConfiguration;

import eu.etaxonomy.cdm.api.service.config.ForSubtreeConfiguratorBase;

import eu.etaxonomy.cdm.api.service.config.PublishForSubtreeConfigurator;

import eu.etaxonomy.cdm.api.service.config.SecundumForSubtreeConfigurator;

import eu.etaxonomy.cdm.api.service.config.SortIndexUpdaterConfigurator;

import eu.etaxonomy.cdm.api.service.util.CacheUpdater;

import eu.etaxonomy.cdm.api.service.util.SortIndexUpdaterWrapper;

import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.RemotingProgressMonitorThread;

import eu.etaxonomy.cdm.persistence.dto.SpecimenNodeWrapper;

/**

 * @author k.luther

 * @since 04 May 2018

 *

 */

@Service("longRunningTasksService")

@Transactional(readOnly = false)

public class LongRunningTasksService implements ILongRunningTasksService{

    @Autowired

    ITaxonNodeService taxonNodeService;

    @Autowired

    IDescriptiveDataSetService descriptiveDataSetService;

    @Autowired

    IProgressMonitorService progressMonitorService;

    @Autowired

    CacheUpdater updater;

    @Autowired

    SortIndexUpdaterWrapper sortIndexUpdater;

    @Override

    public UUID monitGetRowWrapper(UUID descriptiveDataSetUuid) {

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                return descriptiveDataSetService.getRowWrapper(descriptiveDataSetUuid, monitor);

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(3);

        monitorThread.start();

        return uuid;

    }

    @Override

    public UUID aggregateDescriptiveDataSet(UUID descriptiveDataSetUuid,  DescriptionAggregationConfiguration config){

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult updateResult = descriptiveDataSetService.aggregate(descriptiveDataSetUuid, config, monitor);

                for(Exception e : updateResult.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(updateResult);

                return updateResult;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    @Override

    public UUID addRowWrapperToDataset(Collection<SpecimenNodeWrapper> wrapper, UUID datasetUuid){

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult updateResult = descriptiveDataSetService.addRowWrapperToDataset(wrapper, datasetUuid);

                for(Exception e : updateResult.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(updateResult);

                return updateResult;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    @Override

    public UUID generatePolytomousKey(UUID datasetUuid, UUID taxonUuid){

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult updateResult = descriptiveDataSetService.generatePolytomousKey(datasetUuid, taxonUuid);

                for(Exception e : updateResult.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(updateResult);

                return updateResult;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    @Override

    public UUID monitLongRunningTask(ForSubtreeConfiguratorBase config) {

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult result;

                config.setMonitor(monitor);

                result = updateData(config);

                for(Exception e : result.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(result);

                return result;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    private UpdateResult updateData(ForSubtreeConfiguratorBase config){

        if (config instanceof SecundumForSubtreeConfigurator){

            return taxonNodeService.setSecundumForSubtree((SecundumForSubtreeConfigurator)config);

        }else{

            return taxonNodeService.setPublishForSubtree((PublishForSubtreeConfigurator) config);

        }

    }

    @Override

    public UUID monitLongRunningTask(Set<UUID> movingUuids, UUID targetTreeNodeUuid, int movingType) {

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor remotingMonitor) {

                UpdateResult result;

                result = taxonNodeService.moveTaxonNodes(movingUuids,targetTreeNodeUuid, movingType,  remotingMonitor);

                for(Exception e : result.getExceptions()) {

                    remotingMonitor.addReport(e.getMessage());

                }

                remotingMonitor.setResult(result);

                return result;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public UUID monitLongRunningTask(CacheUpdaterConfigurator configurator) {

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult result;

                configurator.setMonitor(monitor);

                result = updater.doInvoke(configurator);

                for(Exception e : result.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(result);

                return result;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public UUID monitLongRunningTask(SortIndexUpdaterConfigurator configurator) {

        RemotingProgressMonitorThread monitorThread = new RemotingProgressMonitorThread() {

            @Override

            public Serializable doRun(IRemotingProgressMonitor monitor) {

                UpdateResult result;

                configurator.setMonitor(monitor);

                result = sortIndexUpdater.doInvoke(configurator);

                for(Exception e : result.getExceptions()) {

                    monitor.addReport(e.getMessage());

                }

                monitor.setResult(result);

                return result;

            }

        };

        UUID uuid = progressMonitorService.registerNewRemotingMonitor(monitorThread);

        monitorThread.setPriority(2);

        monitorThread.start();

        return uuid;

    }

}

      <ref bean="longRunningTasksService" />

      <value>eu.etaxonomy.cdm.api.service.longrunningService.ILongRunningTasksService