platform / task-web

/**
 * @(#)TaskManagerImpl.java
 *
 * Copyright (c) 2014-2014  苏州犀牛网络科技有限公司 版权所有
 * xiniunet. All rights reserved.
 *
 * This software is the confidential and proprietary
 * information of  xiniunet.
 * ("Confidential Information"). You shall not disclose
 * such Confidential Information and shall use it only
 * in accordance with the terms of the contract agreement
 * you entered into with xiniunet.
 */
package com.xiniunet.task.biz;

import com.xiniunet.foundation.domain.AttachmentCount;
import com.xiniunet.foundation.request.AttachmentExistRequest;
import com.xiniunet.foundation.request.IdsGetRequest;
import com.xiniunet.foundation.response.AttachmentExistResponse;
import com.xiniunet.foundation.response.IdsGetResponse;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.exception.ErrorType;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.PinYinUtil;
import com.xiniunet.framework.util.excel.datatable.DataTable;
import com.xiniunet.task.constant.Message;
import com.xiniunet.task.dal.SubtaskMapper;
import com.xiniunet.task.dal.TaskMapper;
import com.xiniunet.task.dal.TaskUserMapper;
import com.xiniunet.task.domain.Subtask;
import com.xiniunet.task.domain.Task;
import com.xiniunet.task.domain.TaskImport;
import com.xiniunet.task.domain.TaskUser;
import com.xiniunet.task.enumeration.TaskListObjectTypeEnum;
import com.xiniunet.task.enumeration.TaskObjectTypeEnum;
import com.xiniunet.task.po.SubtaskPO;
import com.xiniunet.task.po.TaskPO;
import com.xiniunet.task.po.TaskUserPO;
import com.xiniunet.task.request.*;
import com.xiniunet.task.response.*;
import com.xiniunet.util.ListUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.*;

/**
 * Created by 沈振家 on 2016-11-28 16:23:01.
 *
 * @author 沈振家
 */
@Transactional
@Service
public class TaskManagerImpl extends BaseManagerImpl implements TaskManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private TaskMapper taskMapper;

    @Autowired
    private SubtaskMapper subtaskMapper;

    @Autowired
    private SubtaskManager subtaskManager;

    @Autowired
    private TaskListManager taskListManager;

    @Autowired
    private TaskUserMapper taskUserMapper;

    @Autowired
    private TaskUserManager taskUserManager;

    /**
     * 根据Id获取任务
     *
     * @param request  获取任务请求
     * @param passport 用户护照
     * @return 获取任务应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskGetResponse get(TaskGetRequest request, Passport passport) {
        TaskPO entity = taskMapper.getById(request.getId(), passport);
        TaskGetResponse response = new TaskGetResponse();
        if (entity == null) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
            return response;
        }

        Task task = this.getMapper().map(entity, Task.class);
        response.setTask(task);

        // 获取子任务信息
        SubtaskFindRequest subtaskFindRequest = new SubtaskFindRequest();
        subtaskFindRequest.setPageSize(0);
        subtaskFindRequest.setTaskId(task.getId());
        SubtaskFindResponse subtaskFindResponse = subtaskManager.find(subtaskFindRequest, passport);
        if (!subtaskFindResponse.hasError()) {
            response.setSubtaskList(subtaskFindResponse.getResult());
        }

        // 获取任务分配人员
        TaskUserFindRequest taskUserFindRequest = new TaskUserFindRequest();
        taskUserFindRequest.setPageSize(0);
        taskUserFindRequest.setTaskId(task.getId());
        TaskUserFindResponse taskUserFindResponse = taskUserManager.find(taskUserFindRequest, passport);
        if (!taskUserFindResponse.hasError()) {
            response.setUserList(taskUserFindResponse.getResult());
        }

        return response;
    }


    /**
     * 模糊查询任务
     *
     * @param request  模糊查询任务请求
     * @param passport 用户护照
     * @return 模糊查询任务应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskSearchResponse search(TaskSearchRequest request, Passport passport) {
        TaskSearchResponse response = new TaskSearchResponse();
        List<Task> modelList = new ArrayList<>();
        Long count = taskMapper.searchCount(request, passport);

        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            //通过关键字查询出用户集合
            List<TaskPO> entityList = taskMapper.search(request, passport);

            for (TaskPO entity : entityList) {
                Task task = this.getMapper().map(entity, Task.class);
                modelList.add(task);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 高级查询任务
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskFindResponse find(TaskFindRequest request, Passport passport) {
        TaskFindResponse response = new TaskFindResponse();
        List<Task> modelList = new ArrayList<>();
        Long count = taskMapper.findCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }


            List<TaskPO> entityList = taskMapper.find(request, passport);
//            for (TaskPO entity : entityList) {
//                Task task = this.getMapper().map(entity, Task.class);
//                modelList.add(task);
//            }

            modelList = dealTask(entityList, passport);
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 高级查询任务
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskFindByTaskUserResponse findByTaskUser(TaskFindByTaskUserRequest request, Passport passport) {
        TaskFindByTaskUserResponse response = new TaskFindByTaskUserResponse();
        List<Task> modelList = new ArrayList<>();
        Long count = taskMapper.findByTaskUserCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }


            List<TaskPO> entityList = taskMapper.findByTaskUser(request, passport);
//            for (TaskPO entity : entityList) {
//                Task task = this.getMapper().map(entity, Task.class);
//                modelList.add(task);
//            }
            modelList = dealTask(entityList, passport);

        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 获取所有任务列表
     *
     * @param request  获取所有任务列表请求
     * @param passport 用户护照
     * @return 获取所有任务列表应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskGetAllListResponse getAllList(TaskGetAllListRequest request, Passport passport) {
        TaskGetAllListResponse response = new TaskGetAllListResponse();


        List<TaskPO> entityList = taskMapper.getAllList(request, passport);


        List<Task> modelList = new ArrayList<>();
        for (TaskPO entity : entityList) {
            Task task = this.getMapper().map(entity, Task.class);
            modelList.add(task);
        }

        response.setResult(modelList);

        response.setTotalCount(modelList.size());
        return response;
    }


    /**
     * 创建任务
     *
     * @param request  创建任务请求
     * @param passport 用户护照
     * @return 创建任务应答
     */
    @Override
    public TaskCreateResponse create(TaskCreateRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        if (entity.getId() == null) {
            long id = foundationService.getNewId();
            entity.setId(id);
        }

        TaskCreateResponse response = new TaskCreateResponse();

    /* 先检查关键数据是否有重复，在检查通过后才能做插入操作 */
        checkValidate(entity, passport, response);

        entity.setObjectNamePinyin(PinYinUtil.getPinYin(entity.getObjectName()));
        entity.setObjectNamePy(PinYinUtil.getPinYinHeadChar(entity.getObjectName()));
        if (entity.getObjectType().equals(TaskObjectTypeEnum.MANUAL) || entity.getOwnerUserId() == null) {
            entity.setOwnerUserId(passport.getUserId());
            entity.setOwnerUserName(passport.getUserName());
        }
        if (entity.getObjectId() == null) {
            entity.setObjectId(entity.getId());
        }
        if (entity.getDeadlineDate() == null) {
            entity.setHasDeadline(false);
        } else {
            entity.setHasDeadline(true);
        }
        if (entity.getRemndingTime() == null) {
            entity.setNeedReminding(false);
        } else {
            entity.setNeedReminding(true);
        }
        List<Long> subTaskIds = new ArrayList<>();
        if (request.getSubtaskList() != null && request.getSubtaskList().size() > 0) {
            entity.setHasSubtask(true);
            entity.setSubtaskCount(request.getSubtaskList().size());
            entity.setSubtaskDoneCount(0);
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(entity.getSubtaskCount());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            subTaskIds = idsGetResponse.getIds();
        } else {
            entity.setHasSubtask(false);
            entity.setSubtaskCount(0);
            entity.setSubtaskDoneCount(0);
        }

        List<TaskUser> userList = request.getUserList();
        List<TaskUserPO> userPOList = new ArrayList<>();
        if (userList != null && userList.size() > 0) {
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(userList.size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> listUserIds = idsGetResponse.getIds();
            int index = 0;
            for (TaskUser user : userList) {
                if (user.getUserId() != null) {
                    TaskUserPO userPO = this.getMapper().map(user, TaskUserPO.class);
                    userPO.setId(listUserIds.get(index));
                    userPO.setTaskId(entity.getId());
                    userPO.setTaskName(entity.getObjectName());
                    userPOList.add(userPO);
                    index++;
                }
            }
        }

        if (entity.getHasSubtask()) {
            List<SubtaskPO> subtaskPOList = new ArrayList<>();
            int index = 0;
            for (Subtask subtask : request.getSubtaskList()) {
                SubtaskPO subtaskPO = this.getMapper().map(subtask, SubtaskPO.class);
                subtaskPO.setId(subTaskIds.get(index));
                subtaskPO.setTaskId(entity.getId());
                subtaskPOList.add(subtaskPO);
                index++;
            }
            if (subtaskPOList.size() != subtaskMapper.insertBatch(subtaskPOList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
                return response;
            }
        }

        if (userPOList.size() > 0) {
            if (userPOList.size() != taskUserMapper.insertBatch(userPOList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
                return response;
            }
        }

        if (1 != taskMapper.insert(entity, passport)) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }
        response.setId(entity.getId());
        return response;
    }


    /**
     * 设置提醒
     *
     * @param request  设置提醒请求
     * @param passport 用户护照
     * @return 设置提醒应答
     */
    @Override
    public TaskRemindingEnableResponse enableReminding(TaskRemindingEnableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setNeedReminding(true);

        TaskRemindingEnableResponse response = new TaskRemindingEnableResponse();
        Long result = taskMapper.setReminding(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 取消提醒
     *
     * @param request  取消提醒请求
     * @param passport 用户护照
     * @return 取消提醒应答
     */
    @Override
    public TaskRemindingDisableResponse disableReminding(TaskRemindingDisableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setNeedReminding(false);
        entity.setRemndingTime(null);

        TaskRemindingDisableResponse response = new TaskRemindingDisableResponse();
        Long result = taskMapper.setReminding(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 设置截至日
     *
     * @param request  设置截至日请求
     * @param passport 用户护照
     * @return 设置截至日应答
     */
    @Override
    public TaskDeadlineEnableResponse enableDeadline(TaskDeadlineEnableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setHasDeadline(true);

        TaskDeadlineEnableResponse response = new TaskDeadlineEnableResponse();
        Long result = taskMapper.setDeadline(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 取消截至日
     *
     * @param request  取消截至日请求
     * @param passport 用户护照
     * @return 取消截至日应答
     */
    @Override
    public TaskDeadlineDisableResponse disableDeadline(TaskDeadlineDisableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setHasDeadline(false);
        entity.setDeadlineDate(null);

        TaskDeadlineDisableResponse response = new TaskDeadlineDisableResponse();
        Long result = taskMapper.setDeadline(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 设置星标
     *
     * @param request  设置星标请求
     * @param passport 用户护照
     * @return 设置星标应答
     */
    @Override
    public TaskStarEnableResponse enableStar(TaskStarEnableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsStar(true);

        TaskStarEnableResponse response = new TaskStarEnableResponse();
        Long result = taskMapper.setStar(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 取消星标
     *
     * @param request  取消星标请求
     * @param passport 用户护照
     * @return 取消星标应答
     */
    @Override
    public TaskStarDisableResponse disableStar(TaskStarDisableRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsStar(false);

        TaskStarDisableResponse response = new TaskStarDisableResponse();
        Long result = taskMapper.setStar(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }


    /**
     * 设置任务完成
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDoneResponse done(TaskDoneRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsDone(true);
        entity.setDoUserId(passport.getUserId());
        entity.setDoUserName(passport.getUserName());
        entity.setDoTime(new Date());

        TaskDoneResponse response = new TaskDoneResponse();
        Long result = taskMapper.done(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }

        // 同步更新子任务
        SubtaskPO subtaskPO = new SubtaskPO();
        subtaskPO.setTaskId(entity.getId());
        subtaskPO.setIsDone(true);
        subtaskPO.setDoUserId(passport.getUserId());
        subtaskPO.setDoUserName(passport.getUserName());
        subtaskPO.setDoTime(new Date());
        subtaskMapper.doneByTaskId(subtaskPO, passport);

        response.setResult(result);
        return response;
    }


    /**
     * 设置任务未完成
     *
     * @param request  设置任务未完成请求
     * @param passport 用户护照
     * @return 设置任务未完成应答
     */
    @Override
    public TaskTodoResponse todo(TaskTodoRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsDone(false);
        entity.setDoUserId(null);
        entity.setDoUserName(null);
        entity.setDoTime(null);

        TaskTodoResponse response = new TaskTodoResponse();
        Long result = taskMapper.done(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }

        // 同步更新子任务
        SubtaskPO subtaskPO = new SubtaskPO();
        subtaskPO.setTaskId(entity.getId());
        subtaskPO.setIsDone(false);
        subtaskPO.setDoUserId(null);
        subtaskPO.setDoUserName(null);
        subtaskPO.setDoTime(null);
        subtaskMapper.doneByTaskId(subtaskPO, passport);

        response.setResult(result);
        return response;
    }


    /**
     * 更新任务
     *
     * @param request  更新任务请求
     * @param passport 用户护照
     * @return 更新任务应答
     */
    @Override
    public TaskUpdateResponse update(TaskUpdateRequest request, Passport passport) {
        TaskPO entity = this.getMapper().map(request, TaskPO.class);

        TaskUpdateResponse response = new TaskUpdateResponse();
        entity.setObjectNamePinyin(PinYinUtil.getPinYin(entity.getObjectName()));
        entity.setObjectNamePy(PinYinUtil.getPinYinHeadChar(entity.getObjectName()));
        if (entity.getDeadlineDate() == null) {
            entity.setHasDeadline(false);
        } else {
            entity.setHasDeadline(true);
        }
        if (entity.getRemndingTime() == null) {
            entity.setNeedReminding(false);
        } else {
            entity.setNeedReminding(true);
        }
        List<Long> subTaskIds = new ArrayList<>();
        if (request.getSubtaskList() != null && request.getSubtaskList().size() > 0) {
            entity.setHasSubtask(true);
            entity.setSubtaskCount(request.getSubtaskList().size());
            entity.setSubtaskDoneCount(0);
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(entity.getSubtaskCount());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            subTaskIds = idsGetResponse.getIds();
        } else {
            entity.setHasSubtask(false);
            entity.setSubtaskCount(0);
            entity.setSubtaskDoneCount(0);
        }

        List<Long> taskIds = new ArrayList<>();
        taskIds.add(entity.getId());

        TaskUserFindRequest taskUserFindRequest = new TaskUserFindRequest();
        taskUserFindRequest.setPageSize(0);
        taskUserFindRequest.setTaskId(entity.getId());
        List<TaskUserPO> oldList = taskUserMapper.find(taskUserFindRequest, passport);

        List<TaskUser> userList = request.getUserList();
        List<TaskUserPO> addList = new ArrayList<>();
        List<TaskUserPO> updateList = new ArrayList<>();
        if (userList != null && userList.size() > 0) {
            for (TaskUser user : userList) {
                TaskUserPO userPO = this.getMapper().map(user, TaskUserPO.class);
                userPO.setTaskId(entity.getId());
                userPO.setTaskName(entity.getObjectName());
                if (user.getUserId() != null) {
                    if (user.getId() == null) {
                        addList.add(userPO);
                    } else {
                        updateList.add(userPO);
                    }
                }
            }
        }
        List<Long> deleteIds = ListUtil.getKeyList(oldList);
        deleteIds.removeAll(ListUtil.getKeyList(updateList));
        if (addList.size() > 0) {
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(addList.size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> idList = idsGetResponse.getIds();
            int index = 0;
            for (TaskUserPO userPO : addList) {
                userPO.setId(idList.get(index));
                index++;
            }
            if (addList.size() != taskUserMapper.insertBatch(addList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }
        if(updateList.size() > 0){
            if(updateList.size() != taskUserMapper.updateBatch(updateList,passport)){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }
        if(deleteIds != null && deleteIds.size() > 0){
            if(deleteIds.size() != taskUserMapper.deleteBatch(deleteIds,passport)){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }

        subtaskMapper.deleteByTaskId(taskIds, passport);
        if (entity.getHasSubtask()) {
            List<SubtaskPO> subtaskPOList = new ArrayList<>();
            int index = 0;
            for (Subtask subtask : request.getSubtaskList()) {
                SubtaskPO subtaskPO = this.getMapper().map(subtask, SubtaskPO.class);
                subtaskPO.setId(subTaskIds.get(index));
                subtaskPO.setTaskId(entity.getId());
                subtaskPOList.add(subtaskPO);
                index++;
            }
            if (subtaskPOList.size() != subtaskMapper.insertBatch(subtaskPOList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }

        Long result = taskMapper.update(entity, passport);
        if (result != 1) {
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }

        response.setResult(result);
        return response;
    }


    /**
     * 更新任务
     *
     * @param request  更新任务请求
     * @param passport 用户护照
     * @return 更新任务应答
     */
    @Override
    public TaskChangeByObjectResponse changeByObject(TaskChangeByObjectRequest request, Passport passport) {
        TaskChangeByObjectResponse response = new TaskChangeByObjectResponse();

        TaskFindRequest taskFindRequest = new TaskFindRequest();
        taskFindRequest.setObjectId(request.getObjectId());
        taskFindRequest.setObjectType(request.getObjectType());
        List<TaskPO> taskPOList = taskMapper.find(taskFindRequest, passport);
        Long listId = null;
        TaskListFindRequest taskListFindRequest = new TaskListFindRequest();
        taskListFindRequest.setObjectId(request.getListObjectId());
        taskListFindRequest.setObjectType(getListObjectTypeByTaskObjectType(request.getObjectType()));
        TaskListFindResponse taskListFindResponse = taskListManager.find(taskListFindRequest, passport);
        if (!taskListFindResponse.hasError() && taskListFindResponse.getResult().size() > 0) {
            listId = taskListFindResponse.getResult().get(0).getId();
        }
        if (taskPOList == null || taskPOList.isEmpty()) {
            TaskCreateRequest taskCreateRequest = new TaskCreateRequest();
            taskCreateRequest.setObjectId(request.getObjectId());
            taskCreateRequest.setObjectType(request.getObjectType());
            taskCreateRequest.setObjectCategory(request.getObjectCategory());
            taskCreateRequest.setObjectName(request.getObjectName());
            taskCreateRequest.setObjectDescription(request.getObjectDescription());
            taskCreateRequest.setOwnerUserId(request.getOwnerUserId());
            taskCreateRequest.setOwnerUserName(request.getOwnerUserName());
            taskCreateRequest.setHasDeadline(request.getHasDeadline());
            taskCreateRequest.setDeadlineDate(request.getDeadlineDate());
            taskCreateRequest.setObjectUrl(request.getObjectUrl());
            taskCreateRequest.setListId(listId);
            TaskCreateResponse taskCreateResponse = this.create(taskCreateRequest, passport);

            if (taskCreateResponse.hasError()) {
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            } else {
                response.setResult(1L);
            }
            return response;
        }
        TaskPO taskPO = taskPOList.get(0);
        taskPO.setObjectName(request.getObjectName());
        taskPO.setObjectDescription(request.getObjectDescription());
        taskPO.setOwnerUserId(request.getOwnerUserId());
        taskPO.setOwnerUserName(request.getOwnerUserName());
        taskPO.setHasDeadline(request.getHasDeadline());
        taskPO.setDeadlineDate(request.getDeadlineDate());
        taskPO.setListId(listId);

        if (1 != taskMapper.update(taskPO, passport)) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_UPDATE_FAILURE);
            return response;
        }

        response.setResult(1L);
        return response;
    }


    /**
     * 设置任务完成
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDoneByObjectResponse doneByObject(TaskDoneByObjectRequest request, Passport passport) {
        TaskDoneByObjectResponse response = new TaskDoneByObjectResponse();

        TaskFindRequest taskFindRequest = new TaskFindRequest();
        taskFindRequest.setObjectId(request.getObjectId());
        taskFindRequest.setObjectType(request.getObjectType());
        List<TaskPO> taskPOList = taskMapper.find(taskFindRequest, passport);
        if (taskPOList == null || taskPOList.size() != 1) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
            return response;
        }
        TaskPO taskPO = taskPOList.get(0);

        TaskDoneRequest taskDoneRequest = new TaskDoneRequest();
        taskDoneRequest.setId(taskPO.getId());
        taskDoneRequest.setRowVersion(taskPO.getRowVersion());
        TaskDoneResponse taskDoneResponse = this.done(taskDoneRequest, passport);
        if (taskDoneResponse.hasError()) {
            response.addErrors(taskDoneResponse.getErrors());
            return response;
        }

        response.setResult(1L);
        return response;
    }


    /**
     * 设置任务未完成
     *
     * @param request  设置任务未完成请求
     * @param passport 用户护照
     * @return 设置任务未完成应答
     */
    @Override
    public TaskTodoByObjectResponse todoByObject(TaskTodoByObjectRequest request, Passport passport) {
        TaskTodoByObjectResponse response = new TaskTodoByObjectResponse();

        TaskFindRequest taskFindRequest = new TaskFindRequest();
        taskFindRequest.setObjectId(request.getObjectId());
        taskFindRequest.setObjectType(request.getObjectType());
        List<TaskPO> taskPOList = taskMapper.find(taskFindRequest, passport);
        if (taskPOList == null || taskPOList.size() != 1) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
            return response;
        }
        TaskPO taskPO = taskPOList.get(0);

        TaskTodoRequest taskTodoRequest = new TaskTodoRequest();
        taskTodoRequest.setId(taskPO.getId());
        taskTodoRequest.setRowVersion(taskPO.getRowVersion());
        TaskTodoResponse taskTodoResponse = this.todo(taskTodoRequest, passport);
        if (taskTodoResponse.hasError()) {
            response.addErrors(taskTodoResponse.getErrors());
            return response;
        }

        response.setResult(1L);
        return response;
    }


    /**
     * 删除任务
     *
     * @param request  删除任务请求
     * @param passport 用户护照
     * @return 删除任务应答
     */
    @Override
    public TaskDeleteResponse delete(TaskDeleteRequest request, Passport passport) {
        TaskDeleteResponse response = new TaskDeleteResponse();
        if (1 != taskMapper.delete(request.getId(), passport)) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        List<Long> taskIds = new ArrayList<>();
        taskIds.add(request.getId());
        subtaskMapper.deleteByTaskId(taskIds, passport);
        taskUserMapper.deleteByTaskId(taskIds, passport);

        response.setResult(1L);
        return response;
    }


    /**
     * 批量删除任务
     *
     * @param request  删除任务请求
     * @param passport 用户护照
     * @return 删除任务应答
     */
    @Override
    public TaskBatchDeleteResponse deleteBatch(TaskBatchDeleteRequest request, Passport passport) {
        TaskBatchDeleteResponse response = new TaskBatchDeleteResponse();
        List<Long> idList = request.getIdList();
        if (idList == null || idList.size() == 0) {
            response.setResult(0L);
            return response;
        }
        if (idList.size() != taskMapper.deleteBatch(idList, passport)) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        subtaskMapper.deleteByTaskId(idList, passport);
        taskUserMapper.deleteByTaskId(idList, passport);

        response.setResult(Long.valueOf(idList.size()));
        return response;
    }

    /**
     *  批量创建任务
     *
     * @param request   批量创建任务请求
     * @param passport 用户护照
     * @return  批量创建任务应答
     */
    @Override
    public TaskCreateBatchResponse createBatch(TaskCreateBatchRequest request, Passport passport) {
        TaskCreateBatchResponse response = new TaskCreateBatchResponse();
        List<Task> taskList = request.getList();
        IdsGetRequest idsGetRequest = new IdsGetRequest();
        idsGetRequest.setCount(taskList.size());
        List<Long> ids = foundationService.getNewIds(idsGetRequest).getIds();

        List<TaskPO> taskPOList = new ArrayList<>();
        int index = 0;
        for (Task task : taskList) {
            TaskPO entity = this.getMapper().map(task, TaskPO.class);
            entity.setId(ids.get(index));
            entity.setObjectNamePinyin(PinYinUtil.getPinYin(entity.getObjectName()));
            entity.setObjectNamePy(PinYinUtil.getPinYinHeadChar(entity.getObjectName()));

            if (entity.getObjectType().equals(TaskObjectTypeEnum.MANUAL) || entity.getOwnerUserId() == null) {
                entity.setOwnerUserId(passport.getUserId());
                entity.setOwnerUserName(passport.getUserName());
            }
            if (entity.getObjectId() == null) {
                entity.setObjectId(ids.get(index));
            }
            if (entity.getDeadlineDate() == null) {
                entity.setHasDeadline(false);
            } else {
                entity.setHasDeadline(true);
            }
            if (entity.getRemndingTime() == null) {
                entity.setNeedReminding(false);
            } else {
                entity.setNeedReminding(true);
            }
            entity.setHasSubtask(false);
            entity.setSubtaskCount(0);
            entity.setSubtaskDoneCount(0);
            taskPOList.add(entity);
            index++;
        }

        if (taskPOList.size() > 0) {
            taskMapper.insertBatch(taskPOList, passport);
            response.setIds(ids);
        }

        return response;
    }


    /**
     * 导入任务
     *
     * @param request  导入任务请求
     * @param passport 用户护照
     * @return 导入任务应答
     */
    @Override
    public TaskListImportResponse importList(TaskListImportRequest request, Passport passport) {
        DataTable<TaskImport> dataTable = request.getDataTable();

        List<TaskPO> importList = new ArrayList<>();            //需要创建的对象的集合

        List<Long> result = new LinkedList<>();                    //存储ID的集合
        List<TaskImport> beanList = request.getList();            //取出导入对象的集合
        TaskListImportResponse response = new TaskListImportResponse();//最终的返回结果

    /* 批量获取ID */
        IdsGetRequest idsGetRequest = new IdsGetRequest();
        idsGetRequest.setCount(beanList.size());
        List<Long> ids = foundationService.getNewIds(idsGetRequest).getIds();

        int index = 0;
        for (TaskImport importBean : beanList) {
            // 设置
            TaskPO entity = this.getMapper().map(importBean, TaskPO.class);


            importList.add(entity);
            result.add(ids.get(index));         //将取到的ID放入返回结果中
            entity.setId(ids.get(index));       //设置ID

            index++;
        }

        if (!dataTable.hasError()) {
            if (importList.size() > 0) {
                taskMapper.insertBatch(importList, passport);
            }
        } else {
            response.setDataTable(dataTable);
            response.addErrors(dataTable.getErrorList());
        }

        response.setList(result);
        return response;

    }

    /**
     * 验证对象
     *
     * @param task     任务
     * @param passport 用户护照
     */
    private void checkValidate(TaskPO task, Passport passport, BaseResponse response) {
        // TODO

    }

    private TaskListObjectTypeEnum getListObjectTypeByTaskObjectType(TaskObjectTypeEnum taskObjectType) {
        TaskListObjectTypeEnum result = TaskListObjectTypeEnum.MANUAL;
        if (taskObjectType != null) {
            switch (taskObjectType) {
                case ITSM_REQUEST:
                case ITSM_CHANGE:
                case ITSM_RELEASE:
                case ITSM_PROBLEM:
                case ITSM_EVENT:
                    result = TaskListObjectTypeEnum.ITSM_APPLICATION;
                    break;
                case PMS_PLAN_ITEM:
                case PMS_TASK:
                case PMS_ISSUE:
                    result = TaskListObjectTypeEnum.PMS_PROJECT;
                    break;
                default:
                    result = TaskListObjectTypeEnum.MANUAL;
            }
        }
        return result;
    }

    private List<Task> dealTask(List<TaskPO> list, Passport passport) {
        List<Task> modelList = new ArrayList<>();
        List<Long> ids = new ArrayList<>();
        for (TaskPO entity : list) {
            Task task = this.getMapper().map(entity, Task.class);
            modelList.add(task);
            ids.add(task.getId());
        }

        // 获取任务分配人
        TaskUserFindRequest taskUserFindRequest = new TaskUserFindRequest();
        taskUserFindRequest.setTaskIds(ids);
        taskUserFindRequest.setPageSize(0);
        TaskUserFindResponse taskUserFindResponse = taskUserManager.find(taskUserFindRequest, passport);
        if (taskUserFindResponse != null && taskUserFindResponse.getResult() != null) {
            List<TaskUser> userList = taskUserFindResponse.getResult();
            for (Task task : modelList) {
                List<TaskUser> taskUserList = new ArrayList<>();
                for (TaskUser user : userList) {
                    if (task.getId().equals(user.getTaskId())) {
                        taskUserList.add(user);
                    }
                }
                task.setUserList(taskUserList);
            }
        }

        // 获取附件信息
        AttachmentExistRequest attachmentExistRequest = new AttachmentExistRequest();
        attachmentExistRequest.setBusinessIds(ids);
        attachmentExistRequest.setBusinessType("COLLABORATION_TASK");
        AttachmentExistResponse attachmentExistResponse = foundationService.existAttachment(attachmentExistRequest, passport);
        if (attachmentExistResponse != null && attachmentExistResponse.getResult() != null) {
            Map<Long, Integer> attachmentCountMap = new HashMap<>();
            for (AttachmentCount attachmentCount : attachmentExistResponse.getResult()) {
                attachmentCountMap.put(attachmentCount.getBusinessId(), attachmentCount.getCount());
            }
            for (Task task : modelList) {
                Integer count = attachmentCountMap.get(task.getId());
                if (count != null && count > 0) {
                    task.setHasAttachment(true);
                } else {
                    task.setHasAttachment(false);
                }
            }
        }

        return modelList;
    }

}