com.talanlabs.taskmanager.engine.memory.MemoryTaskManagerReaderWriter Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of task-manager-engine Show documentation
The newest version!
package com.talanlabs.taskmanager.engine.memory;

import com.talanlabs.taskmanager.engine.configuration.persistance.ITaskManagerReader;
import com.talanlabs.taskmanager.engine.configuration.persistance.ITaskManagerWriter;
import com.talanlabs.taskmanager.engine.task.ICommonTask;
import com.talanlabs.taskmanager.engine.task.IStatusTask;
import com.talanlabs.taskmanager.engine.task.ISubTask;
import com.talanlabs.taskmanager.model.ITaskCluster;
import com.talanlabs.taskmanager.model.ITaskObject;
import org.apache.commons.lang3.tuple.Pair;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import java.util.*;
import java.util.Map.Entry;

public class MemoryTaskManagerReaderWriter implements ITaskManagerReader, ITaskManagerWriter {

    private static final Log LOG = LogFactory.getLog(MemoryTaskManagerReaderWriter.class);

    private Map> taskClusterMap;

    private Map> currentTasksMap;

    public MemoryTaskManagerReaderWriter() {
        super();

        this.taskClusterMap = new HashMap<>();
        this.currentTasksMap = new HashMap<>();
    }

    /**
     * Add array of task object in task cluster
     *
     * @param taskCluster a current cluster
     * @param taskObjects task objects
     */
    public void addTaskObjectsInTaskCluster(ITaskCluster taskCluster, ITaskObject... taskObjects) {
        taskClusterMap.get(taskCluster).addAll(Arrays.asList(taskObjects));
    }

    // WRITER

    @Override
    public ITaskCluster saveNewTaskCluster(ITaskCluster taskCluster) {
        LOG.info("MRW - saveNewTaskClusterForTaskObject");
        taskClusterMap.put(taskCluster, new ArrayList<>());
        currentTasksMap.put(taskCluster, new ArrayList<>());
        return taskCluster;
    }

    @Override
    public ITaskCluster saveNewGraphFromTaskCluster(ITaskCluster taskCluster, List> taskObjectTasks) {
        LOG.info("MRW - saveNewTaskObjectInTaskCluster");

        if (taskObjectTasks != null && !taskObjectTasks.isEmpty()) {
            List tos = taskClusterMap.get(taskCluster);
            List ats = currentTasksMap.get(taskCluster);

            for (Pair taskObjectNode : taskObjectTasks) {
                ITaskObject taskObject = taskObjectNode.getLeft();
                tos.add(taskObject);

                IStatusTask task = taskObjectNode.getRight();

                ((AbstractSimpleCommonTask) task).setTaskObject(taskObject);
                ((AbstractSimpleCommonTask) task).setStatus(AbstractSimpleCommonTask.Status.CURRENT);

                ats.add(task);
            }
        }

        ((SimpleTaskCluster) taskCluster).setCheckGraphCreated(true);

        return taskCluster;
    }

    @Override
    public void saveRemoveTaskObjectsFromTaskCluster(ITaskCluster taskCluster, List taskObjects) {
        LOG.info("MRW - saveRemoveTaskObjectsFromTaskCluster");

        if (taskObjects != null && !taskObjects.isEmpty()) {
            List tos = taskClusterMap.get(taskCluster);
            List ats = currentTasksMap.get(taskCluster);

            for (ITaskObject taskObject : taskObjects) {
                tos.remove(taskObject);

                Iterator it = ats.iterator();
                while (it.hasNext()) {
                    ICommonTask task = it.next();
                    if (task instanceof AbstractSimpleCommonTask) {
                        if (((AbstractSimpleCommonTask) task).getTaskObject().equals(taskObject)) {
                            it.remove();
                        }
                    }
                }
            }
        }
    }

    @Override
    public ITaskCluster saveMoveTaskObjectsToTaskCluster(ITaskCluster dstTaskCluster, Map> modifyClusterMap) {
        if (modifyClusterMap != null && !modifyClusterMap.isEmpty()) {
            List dstTos = taskClusterMap.get(dstTaskCluster);
            List dstAts = currentTasksMap.get(dstTaskCluster);

            for (Entry> entry : modifyClusterMap.entrySet()) {
                ITaskCluster srcTaskCluster = entry.getKey();
                List taskObjects = entry.getValue();

                if (taskObjects != null && !taskObjects.isEmpty()) {
                    List srcTos = taskClusterMap.get(srcTaskCluster);
                    List srcAts = currentTasksMap.get(srcTaskCluster);

                    for (ITaskObject taskObject : taskObjects) {
                        srcTos.remove(taskObject);
                        dstTos.add(taskObject);

                        Iterator it = srcAts.iterator();
                        while (it.hasNext()) {
                            ICommonTask task = it.next();
                            if (task instanceof AbstractSimpleCommonTask) {
                                if (((AbstractSimpleCommonTask) task).getTaskObject().equals(taskObject)) {
                                    it.remove();
                                    dstAts.add(task);
                                }
                            }
                        }
                    }
                }
            }
        }

        ((SimpleTaskCluster) dstTaskCluster).setCheckGraphCreated(true);

        return dstTaskCluster;
    }

    @Override
    public ITaskCluster archiveTaskCluster(ITaskCluster taskCluster) {
        LOG.info("MRW - archiveTaskCluster " + taskCluster);
        ((SimpleTaskCluster) taskCluster).setCheckArchived(true);
        return taskCluster;
    }

    @Override
    public void saveNewNextTasksInTaskCluster(ITaskCluster taskCluster, IStatusTask toDoneTask, Object taskServiceResult, List newTasks, Map> linkNextTasksMap,
            Map> otherBranchFirstTasksMap, List nextCurrentTasks, List deleteTasks) {
        LOG.info("MRW - saveNewNextTasksInTaskCluster");

        ((AbstractSimpleCommonTask) toDoneTask).setStatus(AbstractSimpleCommonTask.Status.DONE);

        currentTasksMap.get(taskCluster).remove(toDoneTask);

        if (deleteTasks != null && !deleteTasks.isEmpty()) {
            currentTasksMap.get(taskCluster).removeAll(deleteTasks);
        }

        ITaskObject taskObject = ((SimpleStatusTask) toDoneTask).getTaskObject();
        if (newTasks != null && !newTasks.isEmpty()) {
            for (ICommonTask task : newTasks) {
                if (task instanceof AbstractSimpleCommonTask) {
                    ((AbstractSimpleCommonTask) task).setTaskObject(taskObject);
                    ((AbstractSimpleCommonTask) task).setStatus(AbstractSimpleCommonTask.Status.TODO);
                }
                if (task instanceof SimpleSubTask) {
                    SimpleSubTask simpleSubTask = (SimpleSubTask) task;
                    List nextTasks = linkNextTasksMap.get(simpleSubTask);
                    if (nextTasks != null && !nextTasks.isEmpty()) {
                        simpleSubTask.getNextTasks().addAll(nextTasks);

                        for (ICommonTask nextTask : nextTasks) {
                            ((AbstractSimpleCommonTask) nextTask).getPreviousTasks().add(task);
                        }
                    }
                }
                if (task instanceof SimpleStatusTask) {
                    SimpleStatusTask simpleStatusTask = (SimpleStatusTask) task;
                    List otherPreviousNextTasks = otherBranchFirstTasksMap.get(simpleStatusTask);
                    if (otherPreviousNextTasks != null && !otherPreviousNextTasks.isEmpty()) {
                        simpleStatusTask.getOtherBranchFirstTasks().addAll(otherPreviousNextTasks);
                    }
                }
            }
        }

        if (nextCurrentTasks != null && !nextCurrentTasks.isEmpty()) {
            for (ICommonTask nextCurrentTask : nextCurrentTasks) {
                ((AbstractSimpleCommonTask) nextCurrentTask).setStatus(AbstractSimpleCommonTask.Status.CURRENT);
            }

            currentTasksMap.get(taskCluster).addAll(nextCurrentTasks);
        }
    }

    @Override
    public void saveNextTasksInTaskCluster(ITaskCluster taskCluster, ICommonTask toDoneTask, Object taskServiceResult, List nextCurrentTasks) {
        LOG.info("MRW - saveNextTasksInTaskCluster");

        ((AbstractSimpleCommonTask) toDoneTask).setStatus(AbstractSimpleCommonTask.Status.DONE);

        currentTasksMap.get(taskCluster).remove(toDoneTask);

        if (nextCurrentTasks != null && !nextCurrentTasks.isEmpty()) {
            for (ICommonTask nextCurrentTask : nextCurrentTasks) {
                AbstractSimpleCommonTask nct = (AbstractSimpleCommonTask) nextCurrentTask;
                nct.setStatus(AbstractSimpleCommonTask.Status.CURRENT);
            }

            currentTasksMap.get(taskCluster).addAll(nextCurrentTasks);
        }
    }

    @Override
    public void saveNothingTask(ITaskCluster taskCluster, ICommonTask nothingTask, Object taskServiceResult, Throwable errorMessage) {
        LOG.info("MRW - saveNothingTask");
    }

    // READER

    @Override
    public ITaskCluster findTaskClusterByTaskObject(ITaskObject taskObject) {
        LOG.info("MRW - findTaskClusterByTaskObject");

        for (Entry> entry : taskClusterMap.entrySet()) {
            if (entry.getValue().contains(taskObject)) {
                return entry.getKey();
            }
        }
        return null;
    }

    @Override
    public List findTaskObjectsByTaskCluster(ITaskCluster taskCluster) {
        LOG.info("MRW - findTaskObjectsByTaskCluster");
        return taskClusterMap.get(taskCluster);
    }

    @Override
    public List findCurrentTasksByTaskCluster(ITaskCluster taskCluster) {
        LOG.info("MRW - findCurrentTasksByTaskCluster");
        return currentTasksMap.get(taskCluster);
    }

    @Override
    public List findNextTasksBySubTask(ISubTask subTask, boolean uniquePossible) {
        LOG.info("MRW - findNextTasksBySubTask");

        List res = new ArrayList<>();

        List nextTasks = ((SimpleSubTask) subTask).getNextTasks();
        if (nextTasks != null && !nextTasks.isEmpty()) {
            if (uniquePossible) {
                for (ICommonTask nextTask : nextTasks) {
                    List previousTasks = ((AbstractSimpleCommonTask) nextTask).getPreviousTasks();
                    boolean allFinish = true;
                    if (previousTasks != null && !previousTasks.isEmpty()) {
                        Iterator previousTaskIt = previousTasks.iterator();
                        while (previousTaskIt.hasNext() && allFinish) {
                            AbstractSimpleCommonTask previousTask = (AbstractSimpleCommonTask) previousTaskIt.next();
                            if (!previousTask.equals(subTask) && (AbstractSimpleCommonTask.Status.TODO.equals(previousTask.getStatus()) || AbstractSimpleCommonTask.Status.CURRENT.equals(previousTask.getStatus()))) {
                                allFinish = false;
                            }
                        }
                    }
                    if (allFinish) {
                        res.add(nextTask);
                    }
                }
            } else {
                res.addAll(nextTasks);
            }
        }

        return res;
    }

    @Override
    public List findOtherBranchFirstTasksByStatusTask(IStatusTask statusTask) {
        LOG.info("MRW - findOtherBranchFirstTasksByStatusTask");
        return ((SimpleStatusTask) statusTask).getOtherBranchFirstTasks();
    }
}