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.alibaba.dubbo.common.utils.CollectionUtils;
import com.alibaba.dubbo.common.utils.StringUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.rocketmq.client.consumer.listener.ConsumeConcurrentlyStatus;
import com.xiniunet.foundation.domain.AttachmentCount;
import com.xiniunet.foundation.domain.Comment;
import com.xiniunet.foundation.domain.FileAttachmentBind;
import com.xiniunet.foundation.request.*;
import com.xiniunet.foundation.response.*;
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.Identity;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.DateUtil;
import com.xiniunet.framework.util.MQUtil;
import com.xiniunet.framework.util.PinYinUtil;
import com.xiniunet.framework.util.excel.datatable.DataTable;
import com.xiniunet.master.domain.system.Tenant;
import com.xiniunet.master.domain.system.User;
import com.xiniunet.master.request.system.TenantGetAllListByUnionIdRequest;
import com.xiniunet.master.request.system.UserFindRequest;
import com.xiniunet.master.request.system.UserGetRequest;
import com.xiniunet.master.response.system.TenantGetAllListByUnionIdResponse;
import com.xiniunet.master.response.system.UserFindResponse;
import com.xiniunet.master.response.system.UserGetResponse;
import com.xiniunet.master.service.MasterService;
import com.xiniunet.task.constant.Constant;
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.*;
import com.xiniunet.task.enumeration.BusinessTypeEnum;
import com.xiniunet.task.enumeration.TaskListObjectTypeEnum;
import com.xiniunet.task.enumeration.TaskObjectTypeEnum;
import com.xiniunet.task.enumeration.UserRoleEnum;
import com.xiniunet.task.message.TaskAutoOverdueMessage;
import com.xiniunet.task.message.TaskProcessCreateMessage;
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 com.xiniunet.web.home.module.screen.api.Foundation;
import com.xiniunet.xntalk.request.AttachMessagePushRequest;
import com.xiniunet.xntalk.request.IdentityExchangeRequest;
import com.xiniunet.xntalk.request.NotificationUnionGetRequest;
import com.xiniunet.xntalk.response.AttachMessagePushResponse;
import com.xiniunet.xntalk.response.IdentityExchangeResponse;
import com.xiniunet.xntalk.response.NotificationUnionGetResponse;
import com.xiniunet.xntalk.service.UnionService;
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.text.ParseException;
import java.text.SimpleDateFormat;
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 TaskHistoryManager taskHistoryManager;
    @Autowired
    private SubtaskMapper subtaskMapper;

    @Autowired
    private SubtaskManager subtaskManager;

    @Autowired
    private TaskListManager taskListManager;

    @Autowired
    private TaskUserMapper taskUserMapper;

    @Autowired
    private TaskUserManager taskUserManager;
    @Autowired
    private MasterService masterService;
    @Autowired
    private UnionService unionService;
    /**
     * 根据Id获取任务
     *
     * @param request  获取任务请求
     * @param passport 用户护照
     * @return 获取任务应答
     */
    @Override
    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);

        // 获取任务分配人员
        TaskUserFindRequest taskUserFindRequest = new TaskUserFindRequest();
        taskUserFindRequest.setPageSize(0);
        taskUserFindRequest.setTaskId(task.getId());
        TaskUserFindResponse taskUserFindResponse = taskUserManager.find(taskUserFindRequest, passport);
        List<TaskUser> taskUserList = new ArrayList<>();
        List<TaskUser> ccUserList = new ArrayList<>();
        if (!taskUserFindResponse.hasError() && taskUserFindResponse.getResult() != null && taskUserFindResponse.getResult().size()>0) {
            for(TaskUser taskUser : taskUserFindResponse.getResult()){
                if(taskUser.getUserRole() != null){
                    if( taskUser.getUserRole().equals(UserRoleEnum.CC_USER)){
                        ccUserList.add(taskUser);
                    }else if(taskUser.getUserRole().equals(UserRoleEnum.DEAL_USER)){
                        taskUserList.add(taskUser);
                    }
                }else{//兼容前版本
                    taskUserList.add(taskUser);
                }
            }
            task.setUserList(taskUserList);
            task.setCcUserList(ccUserList);
        }
        if(task.getHasAttachment() != null && task.getHasAttachment()){
            // 获取附件信息
            AttachmentGetByBizInfoRequest attachmentGetByBizInfoRequest = new AttachmentGetByBizInfoRequest();
            attachmentGetByBizInfoRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
            attachmentGetByBizInfoRequest.setBusinessId(request.getId());
            AttachmentGetByBizInfoResponse attachmentGetByBizInfoResponse = foundationService.getAttachmentsByBizInfo(attachmentGetByBizInfoRequest,passport);
            if(attachmentGetByBizInfoResponse.hasError()){
                response.addErrors(attachmentGetByBizInfoResponse.getErrors());
                return  response;
            }
            if(attachmentGetByBizInfoResponse.getAttachmentList() != null && attachmentGetByBizInfoResponse.getAttachmentList().size()>0){
                task.setAttachmentList(attachmentGetByBizInfoResponse.getAttachmentList());
            }

        }
        response.setTask(task);
        return response;
    }
    /**
     * 根据Id获取任务及任务进度列表
     *
     * @param request  获取任务请求
     * @param passport 用户护照
     * @return 获取任务应答
     */
    @Override
    public TaskGetInfoResponse getInfo(TaskGetInfoRequest request, Passport passport) {
        TaskGetInfoResponse response = new TaskGetInfoResponse();
        TaskPO entity = taskMapper.getById(request.getId(), passport);

        if (entity == null) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
            return response;
        }
        Task task = this.getMapper().map(entity, Task.class);
        //计算任务进度
        Integer processPercent = (int)Math.round(100*((double)new Date().getTime()-(double)task.getBeginTime().getTime())/((double)task.getEndTime().getTime()-(double)task.getBeginTime().getTime()));
        task.setProcessPercent(processPercent == null ? 0 :processPercent);
        //获取用户头像
        UserGetRequest userGetRequest = new UserGetRequest();
        userGetRequest.setId(task.getOwnerUserId());
        UserGetResponse userGetResponse = masterService.getUser(userGetRequest,passport);
        if(userGetResponse.hasError()){
            response.addErrors(userGetResponse.getErrors());
            return response;
        }
        task.setAvarUrl(userGetResponse.getUser().getAvatar());
        //查询任务进度列表信息
        CommentGetByBusinessIdRequest commentGetByBusinessIdRequest = new CommentGetByBusinessIdRequest();
        commentGetByBusinessIdRequest.setBusinessId(request.getId());
        commentGetByBusinessIdRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
        CommentGetByBusinessIdResponse commentGetByBusinessIdResponse = foundationService.getCommentByBusinessId(commentGetByBusinessIdRequest);
        if(commentGetByBusinessIdResponse.hasError()){
            response.addErrors(commentGetByBusinessIdResponse.getErrors());
            return response;
        }
        List<Comment> commentList = commentGetByBusinessIdResponse.getResult();

        if(CollectionUtils.isNotEmpty(commentList)){
            for(Comment comment : commentList){
                List<Comment> childList = new ArrayList<>();
                childList = FindChild(comment,childList);
                Collections.sort(childList, new Comparator<Comment>(){

                    /*
                     * int compare(Student o1, Student o2) 返回一个基本类型的整型，
                     * 返回负数表示：o1 小于o2，
                     * 返回0 表示：o1和o2相等，
                     * 返回正数表示：o1大于o2。
                     */
                    public int compare(Comment o1, Comment o2) {
                    //按照规则进行降序排列
                    if(o1.getPostTime().getTime() < o2.getPostTime().getTime()){
                        return 1;
                    }
                    if(o1.getPostTime().getTime() ==  o2.getPostTime().getTime()){
                        return 0;
                    }
                    return -1;
                    }
                });
                comment.setChildList(childList);
            }
        }
        response.setCommentList(commentList);
        response.setTask(task);
        return response;
    }

    public List<Comment> FindChild(Comment t,List<Comment> result)
    {
        List<Comment> trans = t.getChildList();
        if(trans != null){
            result.addAll(trans);
            for(Comment comment : trans){
                FindChild(comment,result);
            }
        }
        return result;

    }
    /**
     * 模糊查询任务
     *
     * @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 IndexTaskFindByTaskUserResponse findObjectByUser(TaskFindByTaskUserRequest request, Passport passport) {
        IndexTaskFindByTaskUserResponse response = new IndexTaskFindByTaskUserResponse();
        List<TaskObject> taskObjectList = new ArrayList<>();
        //置顶的任务组
        List<TaskObject> topTaskListList = new ArrayList<>();
        //非置顶的任务组
        List<TaskObject> commonTaskListList = new ArrayList<>();
        //置顶的任务
        List<TaskObject> topTaskList = new ArrayList<>();
        //有新动态的任务
        List<TaskObject> newTaskList = new ArrayList<>();
        //非置顶的任务
        List<TaskObject> commonTaskList = new ArrayList<>();
        //逾期任务组
        TaskObject taskObjectDelay = null;
        //完成任务组
        TaskObject taskObjectDone =null;
        //终止任务组
        TaskObject taskObjectAbort = null;

        //查找任务组
        TaskListFindIndexRequest taskListFindRequest = new TaskListFindIndexRequest();
        taskListFindRequest.setUserId(request.getUserId());
        taskListFindRequest.setPageSize(0);
        //查询任务组
        TaskListFindResponse taskListFindResponse = taskListManager.findIndex(taskListFindRequest,passport);
        if(taskListFindResponse.hasError()){
            response.addErrors(taskListFindResponse.getErrors());
            return response;
        }
        List<TaskList> taskListList = taskListFindResponse.getResult();
        //查询任务
        TaskFindIndexRequest taskFindIndexRequest = new TaskFindIndexRequest();
        taskFindIndexRequest.setUserId(request.getUserId());
        taskFindIndexRequest.setPageSize(0);
        TaskFindResponse taskFindResponse = this.findIndex(taskFindIndexRequest,passport);
        if(taskFindResponse.hasError()){
            response.addErrors(taskFindResponse.getErrors());
            return response;
        }
        List<Task> tasks = taskFindResponse.getResult();
        //任务组信息分组
        if(CollectionUtils.isNotEmpty(taskListList)){
            for(TaskList taskList : taskListList){
                TaskObject taskObject = this.getMapper().map(taskList,TaskObject.class);
                taskObject.setIsTaskGroup(true);
                if(taskList.getGroupTaskName() != null && !"".equals(taskList.getGroupTaskName())){
                    String[] groupTaskNames = taskList.getGroupTaskName().split(",");
                    if(groupTaskNames.length >3){
                        taskObject.setObjectDetail(groupTaskNames[0]+","+groupTaskNames[1]+","+groupTaskNames[2]);
                    }else{
                        StringBuffer sb = new StringBuffer("");
                        for(int i =0 ;i<groupTaskNames.length;i++ ){
                            if(i == groupTaskNames.length-1){
                                sb.append(groupTaskNames[i]);
                            }else{
                                sb.append(groupTaskNames[i]);
                                sb.append(",");
                            }
                        }
                        taskObject.setObjectDetail(sb.toString());
                    }
                }
                if(taskList.getIsTop() != null && taskList.getIsTop() ){
                    topTaskListList.add(taskObject);
                }else {
                    if(taskObject.getId().equals(Constant.DONE_GROUP_ID)){
                        taskObjectDone = taskObject;
                    }else if(taskObject.getId().equals(Constant.ABORT_GROUP_ID)){
                        taskObjectAbort = taskObject;
                    }else if (taskObject.getId().equals(Constant.OVER_DUE_GROUP_ID)){
                        taskObjectDelay = taskObject;
                    }else{
                        commonTaskListList.add(taskObject);
                    }

                }

            }
        }
        //任务信息分组
        if(CollectionUtils.isNotEmpty(tasks)){
            for(Task task : tasks){
                TaskObject taskObject = this.getMapper().map(task,TaskObject.class);
                taskObject.setIsTaskGroup(false);
                taskObject.setObjectDetail(taskObject.getObjectDescription());
                if(task.getIsTop() != null && task.getIsTop()){
                    topTaskList.add(taskObject);
                }else if(task.getUnReadCount() != null && task.getUnReadCount()>0){
                    newTaskList.add(taskObject);
                }else {
                    commonTaskList.add(taskObject);
                }
            }
        }
        if(CollectionUtils.isNotEmpty(topTaskList)){
            taskObjectList.addAll(topTaskList);
        }
        if(CollectionUtils.isNotEmpty(topTaskListList)){
            taskObjectList.addAll(topTaskListList);
        }
        if(CollectionUtils.isNotEmpty(newTaskList)){
            taskObjectList.addAll(newTaskList);
        }
        if(CollectionUtils.isNotEmpty(commonTaskList)){
            taskObjectList.addAll(commonTaskList);
        }
        if(CollectionUtils.isNotEmpty(commonTaskListList)){
            taskObjectList.addAll(commonTaskListList);
        }

        if(taskObjectDelay!=null){
            taskObjectList.add(taskObjectDelay);
        }
        if(taskObjectDone!=null){
            taskObjectList.add(taskObjectDone);
        }
        if(taskObjectAbort!=null){
            taskObjectList.add(taskObjectAbort);
        }
        response.setResult(taskObjectList);
        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);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    /**
     * 高级查询任务
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskFindResponse findIndex(TaskFindIndexRequest request, Passport passport) {
        TaskFindResponse response = new TaskFindResponse();
        List<Task> modelList = new ArrayList<>();
        Long count = taskMapper.findIndexCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
            //创建人id
            List<Long> userIdList = new ArrayList<>();
            List<TaskPO> entityList = taskMapper.findIndex(request, passport);
            for(TaskPO taskPO : entityList){
                Task task = this.getMapper().map(taskPO,Task.class);
                userIdList.add(task.getOwnerUserId());
                //计算任务进度
                Integer processPercent = (int)Math.round(100*((double)new Date().getTime()-(double)task.getBeginTime().getTime())/((double)task.getEndTime().getTime()-(double)task.getBeginTime().getTime()));
                task.setProcessPercent(processPercent == null ? 0 :processPercent);
                modelList.add(task);
            }
            //获取头像
            UserFindRequest userFindRequest = new UserFindRequest();
            userFindRequest.setPageSize(0);
            userFindRequest.setIds(userIdList);
            UserFindResponse userFindResponse = masterService.findUser(userFindRequest,passport);
            if(userFindResponse.hasError()){
                response.addErrors(userFindResponse.getErrors());
                return response;
            }
            List<User> userList = userFindResponse.getResult();
            //组装用户id和头像
            Map<Long,String> userAvarMap = new HashMap<>();
            for(User user :  userList){
                userAvarMap.put(user.getId(),user.getAvatar());
            }
            if(userAvarMap != null && userAvarMap.size() > 0){
                for(Task task : modelList){
                    if(userAvarMap.get(task.getId()) != null ){
                        task.setAvarUrl(userAvarMap.get(task.getId()));
                    }
                }
            }
        }

        response.setResult(modelList);
        return response;
    }


    /**
     * 根据unionid高级查询任务清单
     *
     * @param request  高级查询任务清单请求
     * @param identity 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    public TaskFindResponse findByUnion(TaskFindByUnionRequest request, Identity identity){
        TaskFindResponse response = new TaskFindResponse();
        UserFindRequest userFindRequest = new UserFindRequest();
        userFindRequest.setUnionId(request.getUnionId());
        Passport passport = new Passport();
        UserFindResponse userFindResponse = masterService.findUser(userFindRequest,passport);
        if(userFindResponse.hasError()){
            response.addErrors(userFindResponse.getErrors());
            return response;
        }
        List<User> userList = userFindResponse.getResult();
        //获取union的userId集合
        List<Long> userIdList = new ArrayList<>();
        for(User user : userList){
            if(!userIdList.contains(user.getId())){
                userIdList.add(user.getId());
            }
        }
        //获取任务信息
        TaskFindIndexRequest taskFindIndexRequest = new TaskFindIndexRequest();
        taskFindIndexRequest.setPageSize(0);
        //默认查询逾期的信息
        if(request.getIsOverDue() == null){
            taskFindIndexRequest.setIsOverdue(true);
        }
        //默认查询逾期的信息
        if(request.getListId() == null){
            taskFindIndexRequest.setListId(2L);
        }

        taskFindIndexRequest.setUserIdList(userIdList);
        TaskFindResponse taskFindResponse = this.findIndex(taskFindIndexRequest,passport);
        if(taskFindResponse.hasError()){
            response.addErrors(taskFindResponse.getErrors());
            return response;
        }
        response.setResult(taskFindResponse.getResult());
        response.setTotalCount(taskFindResponse.getTotalCount());
        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) {
        TaskCreateResponse response = new TaskCreateResponse();
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        if (entity.getId() == null) {
            long id = foundationService.getNewId();
            entity.setId(id);
        }

        /* 先检查关键数据是否有重复，在检查通过后才能做插入操作 */
        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.getBeginTime() == null ){
            entity.setBeginTime(new Date());
        }
        if (entity.getDeadlineDate() == null) {
            if(entity.getEndTime() == null){
                entity.setHasDeadline(false);
            }else{
                SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
                entity.setHasDeadline(true);
                try {
                    entity.setDeadlineDate(simpleDateFormat.parse(simpleDateFormat.format(request.getEndTime())));
                } catch (ParseException e) {
                    e.printStackTrace();
                }
            }
        } else {
            entity.setHasDeadline(true);
            if(entity.getEndTime() == null){
                entity.setEndTime(DateUtil.getEndOfDay(entity.getDeadlineDate()));
            }
        }
        if (entity.getRemindingTime() == null) {
            entity.setNeedReminding(false);
        } else {
            entity.setNeedReminding(true);
        }
        List<TaskUser> userList =new ArrayList<>();
        List<TaskUser> doUserList = request.getUserList();
        List<TaskUser> ccUserList = request.getCcUserList();
        if(CollectionUtils.isNotEmpty(doUserList)){
            for(TaskUser taskUser : userList){
                taskUser.setUserRole(UserRoleEnum.DEAL_USER);
            }
            userList.addAll(doUserList);
        }
        if(CollectionUtils.isNotEmpty(ccUserList)){
            for(TaskUser taskUser : ccUserList){
                taskUser.setUserRole(UserRoleEnum.CC_USER);
            }
            userList.addAll(ccUserList);
        }
        //任务发布者也需要创建TaskUser记录
        TaskUser taskOwnerUser = new TaskUser();
        taskOwnerUser.setTaskId(entity.getId());
        taskOwnerUser.setUserRole(UserRoleEnum.OWNER_USER);
        taskOwnerUser.setUserId(entity.getOwnerUserId());
        taskOwnerUser.setUserName(entity.getOwnerUserName());
        taskOwnerUser.setTaskName(entity.getObjectName());
        userList.add(taskOwnerUser);
        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) {
                TaskUserPO userPO = this.getMapper().map(user, TaskUserPO.class);
                userPO.setId(listUserIds.get(index));
                userPO.setTaskId(entity.getId());
                userPO.setTaskName(entity.getObjectName());
                userPO.setCommentCount(0);
                if(userPO.getUserId().equals(entity.getOwnerUserId())){
                    userPO.setHistoryCount(0);
                }else{
                    userPO.setHistoryCount(1);
                }
                userPOList.add(userPO);
                index++;
            }

        }
        if(CollectionUtils.isNotEmpty(request.getAttachmentList()) ){
            entity.setHasAttachment(true);
            //处理文件列表的创建绑定
            FileCreateBindAttachBatchRequest fileCreateBindAttachBatchRequest = this.getMapper().map(request,FileCreateBindAttachBatchRequest.class);
            List<FileAttachmentBind> attachmentList = fileCreateBindAttachBatchRequest.getAttachmentList();
            if(CollectionUtils.isNotEmpty(attachmentList)){
                for(FileAttachmentBind fileAttachmentBind : attachmentList){
                    fileAttachmentBind.setBusinessId(entity.getId());
                    fileAttachmentBind.setBusinessType(BusinessTypeEnum.TASK.toString());
                }
                fileCreateBindAttachBatchRequest.setAttachmentList(attachmentList);
            }
            FileCreateBindAttachmentBatchResponse fileCreateBindAttachmentBatchResponse = foundationService.fileCreateBindAttachmentBatch(fileCreateBindAttachBatchRequest,passport);
            if(fileCreateBindAttachmentBatchResponse.hasError()){
                //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(fileCreateBindAttachmentBatchResponse.getErrors());
                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;
        }
        //发送创建任务进度的消息
        StringBuffer s = new StringBuffer("任务已创建！");
        TaskProcessCreateMessage taskProcessCreateMessage = new TaskProcessCreateMessage();
        taskProcessCreateMessage.setId(entity.getId());
        taskProcessCreateMessage.setPassport(passport);
        taskProcessCreateMessage.setContent(s.toString());
        if(!MQUtil.send(taskProcessCreateMessage)){
            logger.warn("发送创建任务进度的消息失败！");
        }
        //判断是否需要抛送消息
        //结束时间和当前时间的差值（毫秒）
        int time = (int)(entity.getEndTime().getTime() - new Date().getTime());
        if( time < Constant.MESSAGE_DELAY_MAX_TIME){
            //发送自动逾期的消息
            TaskAutoOverdueMessage taskAutoOverdueMessage = new TaskAutoOverdueMessage();
            taskAutoOverdueMessage.setId(entity.getId());
            taskAutoOverdueMessage.setPassport(passport);
            taskAutoOverdueMessage.setDelayTime(time);
            if(!MQUtil.send(taskAutoOverdueMessage)){
                logger.warn("发送自动逾期的消息失败！");
            }
        }
        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.setRemindingTime(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 TaskTopResponse top(TaskTopRequest request, Passport passport) {
        TaskTopResponse response = new TaskTopResponse();
        TaskUserPO taskUserPO =  taskUserMapper.getByTaskId(request.getId(),passport);
        if(taskUserPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"用户任务不存在或已被删除！");
            return response;
        }
        TaskUserPO entity = this.getMapper().map(taskUserPO, TaskUserPO.class);
        entity.setIsTop(true);
        entity.setRowVersion(taskUserPO.getRowVersion());
        Long result = taskUserMapper.top(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        response.setResult(result);
        return response;
    }
    /**
     * 设置任务取消置顶
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskCancelTopResponse cancelTop(TaskCancelTopRequest request, Passport passport) {
        TaskCancelTopResponse response = new TaskCancelTopResponse();
        TaskUserPO taskUserPO =  taskUserMapper.getByTaskId(request.getId(),passport);
        if(taskUserPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"用户任务不存在或已被删除！");
            return response;
        }
        TaskUserPO entity = this.getMapper().map(taskUserPO, TaskUserPO.class);
        entity.setIsTop(false);
        entity.setRowVersion(taskUserPO.getRowVersion());
        Long result = taskUserMapper.top(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        response.setResult(result);
        return response;
    }
    /**
     * 设置任务完成
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDoneResponse done(TaskDoneRequest request, Passport passport) {
        TaskDoneResponse response = new TaskDoneResponse();
        TaskPO taskPO =  taskMapper.getById(request.getId(),passport);
        if(taskPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"任务不存在或已被删除！");
            return response;
        }
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsDone(true);
        entity.setDoUserId(passport.getUserId());
        entity.setDoUserName(passport.getUserName());
        entity.setDoTime(new Date());
        entity.setRowVersion(taskPO.getRowVersion());
        Long result = taskMapper.done(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        //将任务加到完成任务组
        GroupAddTaskRequest groupAddTaskRequest = new GroupAddTaskRequest();
        //完成任务组id
        groupAddTaskRequest.setListId(Constant.DONE_GROUP_ID);
        groupAddTaskRequest.setTaskId(request.getId());
        GroupAddTaskResponse groupAddTaskResponse = taskListManager.addTask(groupAddTaskRequest,passport);
        if(groupAddTaskResponse.hasError()){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            response.addErrors(groupAddTaskResponse.getErrors());
            return response;
        }
        //发送完成任务进度的消息
        StringBuffer s = new StringBuffer("任务已完成！");
        if(StringUtils.isNotEmpty(request.getDoneMessage())){
            s.append("\n");
            s.append("备注：");
            s.append(request.getDoneMessage());
        }
        TaskProcessCreateMessage taskProcessCreateMessage = new TaskProcessCreateMessage();
        taskProcessCreateMessage.setId(entity.getId());
        taskProcessCreateMessage.setPassport(passport);
        taskProcessCreateMessage.setContent(s.toString());
        if(!MQUtil.send(taskProcessCreateMessage)){
            logger.warn("发送创建任务进度的消息失败！");
        }
        response.setResult(result);
        return response;
    }
    /**
     * 设置任务终止
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskAbortResponse abort(TaskAbortRequest request, Passport passport) {
        TaskAbortResponse response = new TaskAbortResponse();
        TaskPO taskPO =  taskMapper.getById(request.getId(),passport);
        if(taskPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"任务不存在或已被删除！");
            return response;
        }
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsAbort(true);
        entity.setAbortUserId(passport.getUserId());
        entity.setAbortUserName(passport.getUserName());
        entity.setAbortTime(new Date());
        entity.setAbortReason(request.getAbortReason());
        entity.setRowVersion(taskPO.getRowVersion());
        Long result = taskMapper.abort(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        //将任务加到终止任务组
        GroupAddTaskRequest groupAddTaskRequest = new GroupAddTaskRequest();
        //终止任务组id
        groupAddTaskRequest.setListId(Constant.ABORT_GROUP_ID);
        groupAddTaskRequest.setTaskId(request.getId());
        GroupAddTaskResponse groupAddTaskResponse = taskListManager.addTask(groupAddTaskRequest,passport);
        if(groupAddTaskResponse.hasError()){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            response.addErrors(groupAddTaskResponse.getErrors());
            return response;
        }
        //发送终止任务进度的消息
        StringBuffer s = new StringBuffer("任务已终止！");
        if(StringUtils.isNotEmpty(request.getAbortReason())){
            s.append("\n");
            s.append("备注：");
            s.append(request.getAbortReason());
        }
        TaskProcessCreateMessage taskProcessCreateMessage = new TaskProcessCreateMessage();
        taskProcessCreateMessage.setId(entity.getId());
        taskProcessCreateMessage.setPassport(passport);
        taskProcessCreateMessage.setContent(s.toString());
        if(!MQUtil.send(taskProcessCreateMessage)){
            logger.warn("发送创建任务进度的消息失败！");
        }
        response.setResult(result);
        return response;
    }
    /**
     * 延期任务
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDelayResponse delay(TaskDelayRequest request, Passport passport) {
        TaskDelayResponse response = new TaskDelayResponse();

        TaskPO taskPO =  taskMapper.getById(request.getId(),passport);
        if(taskPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"任务不存在或已被删除！");
            return response;
        }
        if(request.getDelayToTime().getTime() <= taskPO.getEndTime().getTime() || request.getDelayToTime().getTime() <= new Date().getTime()){
            response.addError(ErrorType.BUSINESS_ERROR,"延期时间应大于结束时间且大于当前时间！");
            return response;
        }
        TaskPO entity = this.getMapper().map(request, TaskPO.class);
        entity.setIsDelay(true);
        entity.setDelayUserId(passport.getUserId());
        entity.setDelayUserName(passport.getUserName());
        if(request.getDelayToTime() != null){
            entity.setEndTime(request.getDelayToTime());
        }
        entity.setDelayTime(new Date());
        entity.setDelayReason(request.getDelayReason());
        entity.setIsOverdue(false);
        entity.setTaskId(null);
        entity.setRowVersion(taskPO.getRowVersion());
        Long result = taskMapper.delay(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        /*taskPO.setIsOverdue(false);
        taskPO.setRowVersion(taskPO.getRowVersion()+1);
        long count = taskMapper.setTaskOverdue(taskPO,passport);
        if(count != 1){
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            response.addError(ErrorType.BUSINESS_ERROR,"设置任务组是否逾期失败！");
            return response;
        }*/

        //发送终止任务进度的消息
        StringBuffer s = new StringBuffer("任务已延期！");
        if(StringUtils.isNotEmpty(request.getDelayReason())){
            s.append("\n");
            s.append("备注：");
            s.append(request.getDelayReason());
        }
        TaskProcessCreateMessage taskProcessCreateMessage = new TaskProcessCreateMessage();
        taskProcessCreateMessage.setId(entity.getId());
        taskProcessCreateMessage.setPassport(passport);
        taskProcessCreateMessage.setContent(s.toString());
        if(!MQUtil.send(taskProcessCreateMessage)){
            logger.warn("发送创建任务进度的消息失败！");
        }
        response.setResult(result);
        return response;
    }
    /**
     * 设置任务是否逾期
     *
     * @param request 请求对象
     * @return 受影响的记录条数
     */
    @Override
    public TaskOverdueResponse setOverdue(TaskOverdueRequest request, Passport passport) {
        TaskOverdueResponse response = new TaskOverdueResponse();
        TaskPO taskPO =  taskMapper.getById(request.getId(),passport);
        if(taskPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"任务不存在或已被删除！");
            return response;
        }
        taskPO.setIsOverdue(request.getIsOverdue());
        long updateCount = taskMapper.setTaskOverdue(taskPO,passport);
        if(updateCount != 1){
            response.addError(ErrorType.BUSINESS_ERROR,"设置任务是否逾期失败！");
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        //将任务加入到已逾期任务组
        GroupAddTaskRequest groupAddTaskRequest = new GroupAddTaskRequest();
        groupAddTaskRequest.setTaskId(taskPO.getId());
        //逾期任务组id (完成组id ： 0 ； 终止组id ：1 ；逾期组id ：2)
        groupAddTaskRequest.setListId(Constant.OVER_DUE_GROUP_ID);
        GroupAddTaskResponse groupAddTaskResponse = taskListManager.addTask(groupAddTaskRequest,passport);

        if(groupAddTaskResponse.hasError()){
            response.addErrors(groupAddTaskResponse.getErrors());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        response.setResult(updateCount);
        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.getRemindingTime() == null) {
            entity.setNeedReminding(false);
        } else {
            entity.setNeedReminding(true);
        }
        //查询task
        TaskPO taskPO = taskMapper.getById(request.getId(),passport);
        entity.setRowVersion(taskPO.getRowVersion());
        if(taskPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "任务不存在或已被删除！");
            return response;
        }
        /*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(request.getSubtaskList().size());
            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);
        Map<Long,TaskUserPO> userIdTaskUserMap = new HashMap<>();
        List<Long> deleteIds = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(oldList)){
            deleteIds = ListUtil.getKeyList(oldList);
            //组装userId和原TaskUserPO关系
            for(TaskUserPO taskUserPO : oldList){
                userIdTaskUserMap.put(taskUserPO.getUserId(),taskUserPO);
            }
        }

        List<TaskUser> userList =new ArrayList<>();
        List<TaskUser> doUserList = request.getUserList();
        List<TaskUser> ccUserList = request.getCcUserList();
        if(CollectionUtils.isNotEmpty(doUserList)){
            userList.addAll(doUserList);
        }
        if(CollectionUtils.isNotEmpty(ccUserList)){
            userList.addAll(ccUserList);
        }
        //任务发布者也需要创建TaskUser记录
        TaskUser taskOwnerUser = new TaskUser();
        taskOwnerUser.setTaskId(entity.getId());
        taskOwnerUser.setUserRole(UserRoleEnum.OWNER_USER);
        taskOwnerUser.setUserId(entity.getOwnerUserId());
        taskOwnerUser.setUserName(entity.getOwnerUserName());
        taskOwnerUser.setTaskName(entity.getObjectName());
        userList.add(taskOwnerUser);
        List<TaskUserPO> userPOList = new ArrayList<>();
        if (userList.size() > 0) {
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(userList.size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> idList = idsGetResponse.getIds();
            int index = 0;
            for (TaskUser user : userList) {
                TaskUserPO taskUserPO = this.getMapper().map(user,TaskUserPO.class);
                taskUserPO.setId(idList.get(index));
                taskUserPO.setTaskId(entity.getId());
                taskUserPO.setTaskName(entity.getObjectName());
                taskUserPO.setCommentCount(0);
                if(taskUserPO.getUserId().equals(entity.getOwnerUserId())){
                    taskUserPO.setHistoryCount(0);
                }else {
                    taskUserPO.setHistoryCount((userIdTaskUserMap.get(taskUserPO.getUserId()) == null ? 0: userIdTaskUserMap.get(taskUserPO.getUserId()).getHistoryCount()) +1);
                }
                userPOList.add(taskUserPO);
                index++;
            }
            if (userList.size() != taskUserMapper.insertBatch(userPOList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, "批量插入用户任务失败！");
                return response;
            }
        }
        if(deleteIds != null && deleteIds.size() > 0){
            if(deleteIds.size() != taskUserMapper.deleteBatch(deleteIds,passport)){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, "批量删除用户任务失败！");
                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;
        }

        //创建消息
        List<Long> userIdList = new ArrayList<>();
        for(TaskUser taskUser: userList){
            //排除自己
            if(!taskUser.getUserId().equals(passport.getUserId())){
                userIdList.add(taskUser.getUserId());
            }
        }
        //只有修改这几项才会记录历史
        if(request.getEndTime() !=null || request.getBeginTime() != null || StringUtils.isNotEmpty(request.getObjectName() )
                || StringUtils.isNotEmpty(request.getObjectDescription())){
            //插入编辑历史表
            TaskHistoryCreateRequest taskHistoryCreateRequest = new TaskHistoryCreateRequest();
            taskHistoryCreateRequest.setBeforeObjectName(taskPO.getObjectName());
            taskHistoryCreateRequest.setBeforeObjectDescription(taskPO.getObjectDescription());
            taskHistoryCreateRequest.setBeforeStartTime(taskPO.getBeginTime());
            taskHistoryCreateRequest.setBeforeEndTime(taskPO.getEndTime());
            if(StringUtils.isEmpty(request.getObjectName())){
                taskHistoryCreateRequest.setAfterObjectName(taskPO.getObjectName());
            }else{
                taskHistoryCreateRequest.setAfterObjectName(entity.getObjectName());
            }
            if(StringUtils.isEmpty(request.getObjectDescription())){
                taskHistoryCreateRequest.setAfterObjectDescription(taskPO.getObjectDescription());
            }else{
                taskHistoryCreateRequest.setAfterObjectDescription(entity.getObjectDescription());
            }
            if(request.getBeginTime() == null){
                taskHistoryCreateRequest.setAfterStartTime(taskPO.getBeginTime());
            }else{
                taskHistoryCreateRequest.setAfterStartTime(entity.getBeginTime());
            }
            if(request.getEndTime() == null){
                taskHistoryCreateRequest.setAfterEndTime(taskPO.getEndTime());
            }else{
                taskHistoryCreateRequest.setAfterEndTime(entity.getEndTime());
            }
            taskHistoryCreateRequest.setTaskId(taskPO.getId());
            taskHistoryCreateRequest.setSaveTime(new Date());
            taskHistoryCreateRequest.setSaveUserId(passport.getUserId());
            taskHistoryCreateRequest.setSaveUserName(passport.getUserName());
            TaskHistoryCreateResponse taskHistoryCreateResponse = taskHistoryManager.create(taskHistoryCreateRequest,passport);
            if(taskHistoryCreateResponse.hasError()){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(taskHistoryCreateResponse.getErrors());
                return  response;
            }
        }
        //发送更新任务进度的消息
        StringBuffer s = new StringBuffer("任务已更新！");
        TaskProcessCreateMessage taskProcessCreateMessage = new TaskProcessCreateMessage();
        taskProcessCreateMessage.setId(entity.getId());
        taskProcessCreateMessage.setPassport(passport);
        taskProcessCreateMessage.setContent(s.toString());
        taskProcessCreateMessage.setIsUpdate(true);
        if(!MQUtil.send(taskProcessCreateMessage)){
            logger.warn("发送更新任务进度的消息失败！");
        }
        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.getRemindingTime() == 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 TaskProcessCreateResponse createProcess(TaskProcessCreateRequest request, Passport passport){
        TaskProcessCreateResponse response = new TaskProcessCreateResponse();

        TaskPO taskPO = taskMapper.getById(request.getId(),passport);
        if(taskPO==null){
            response.addError(ErrorType.BUSINESS_ERROR,"任务不存在或已被删除！");
            return response;
        }
        //创建评论
        CommentRecordCreateRequest commentRecordCreateRequest = this.getMapper().map(request,CommentRecordCreateRequest.class);
        commentRecordCreateRequest.setBusinessId(request.getId());
        commentRecordCreateRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
        commentRecordCreateRequest.setUserId(passport.getUserId());
        CommentRecordCreateResponse commentRecordCreateResponse = foundationService.createCommentRecord(commentRecordCreateRequest,passport);
        if(commentRecordCreateResponse.hasError()){
            response.addErrors(commentRecordCreateResponse.getErrors());
            return response;
        }
        if(CollectionUtils.isNotEmpty(request.getAttachmentList()) ){
            //处理文件列表的创建绑定
            FileCreateBindAttachBatchRequest fileCreateBindAttachBatchRequest = this.getMapper().map(request,FileCreateBindAttachBatchRequest.class);
            List<FileAttachmentBind> attachmentList = fileCreateBindAttachBatchRequest.getAttachmentList();
            if(CollectionUtils.isNotEmpty(attachmentList)){
                for(FileAttachmentBind fileAttachmentBind : attachmentList){
                    fileAttachmentBind.setBusinessId(commentRecordCreateResponse.getId());
                    fileAttachmentBind.setBusinessType(BusinessTypeEnum.TASK_PROCESS.toString());
                }
                fileCreateBindAttachBatchRequest.setAttachmentList(attachmentList);
            }
            FileCreateBindAttachmentBatchResponse fileCreateBindAttachmentBatchResponse = foundationService.fileCreateBindAttachmentBatch(fileCreateBindAttachBatchRequest,passport);
            if(fileCreateBindAttachmentBatchResponse.hasError()){
                //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(fileCreateBindAttachmentBatchResponse.getErrors());
                return response;
            }
        }

        TaskUserFindRequest taskUserFindRequest = new TaskUserFindRequest();
        taskUserFindRequest.setTaskId(request.getId());
        List<TaskUserPO>  taskUserPOList = taskUserMapper.find(taskUserFindRequest,passport);
        if(CollectionUtils.isNotEmpty(taskUserPOList)){
            TaskUserPO removeTaskUserPO = new TaskUserPO();
            //批量更新用户任务的未读评论数 +1
            for(TaskUserPO taskUserPO:taskUserPOList){
                if(taskUserPO.getUserId().equals(passport.getUserId())){
                    removeTaskUserPO = taskUserPO;
                }else{
                    if(request.getIsUpdate()){
                        taskUserPO.setHistoryCount(taskUserPO.getHistoryCount());
                    }else{
                        taskUserPO.setCommentCount(taskUserPO.getCommentCount()+1);
                    }
                    taskUserPO.setLastDynamicTime(new Date());
                }
            }
            //去除创建进度的人
            taskUserPOList.remove(removeTaskUserPO);
        }
        if(CollectionUtils.isNotEmpty(taskUserPOList)){
            long batchUpdateCount = taskUserMapper.updateBatch(taskUserPOList,passport);
            if(batchUpdateCount != taskUserPOList.size()){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR,"批量更新用户任务失败！");
                return response;
            }
            //创建消息
            if(request.getNeedPushMessage() != null && request.getNeedPushMessage()){
                List<Long> userIdList = new ArrayList<>();
                for(TaskUserPO taskUser: taskUserPOList){
                    if(!taskUser.getUserId().equals(passport.getUserId())){
                        userIdList.add(taskUser.getUserId());
                    }
                }
                //返回地址：todo pageName 待确认
                String resultUrl = "xntalk://rnapp.open/tasklistRN?tenantId=" + passport.getTenantId() + "&taskId=" + taskPO.getId() + "&name=" + taskPO.getOwnerUserName();
                MessageBatchCreateRequest messageBatchCreateRequest = new MessageBatchCreateRequest();
                messageBatchCreateRequest.setMessageTitle("任务新动态");
                messageBatchCreateRequest.setMessageContent(passport.getUserName()+"对["+taskPO.getObjectName()+"]进行了 操作：\n"+request.getContent());
                messageBatchCreateRequest.setBusinessId(taskPO.getId());
                messageBatchCreateRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
                messageBatchCreateRequest.setMessageUrl(resultUrl);
                messageBatchCreateRequest.setReceiptIds(userIdList);
                messageBatchCreateRequest.setSenderId(10000L);
                messageBatchCreateRequest.setSenderName("系统管理员");
                messageBatchCreateRequest.setSendTime(new Date());
                messageBatchCreateRequest.setMessageTime(new Date());
                MessageBatchCreateResponse messageBatchCreateResponse = foundationService.batchCreateMessage(messageBatchCreateRequest,passport);
                if(messageBatchCreateResponse.hasError()){
                    //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    response.addErrors(messageBatchCreateResponse.getErrors());
                    return response;
                }
            }
        }
        //推送逾期消息告知app
        if(request.getNeedPushMessage() != null && request.getNeedPushMessage()){
            //获取推送这个unionId
            Long sendUnionId = null;
            Long receiveUnionId = null;
            NotificationUnionGetRequest notificationUnionGetRequest = new NotificationUnionGetRequest();
            notificationUnionGetRequest.setPassport(passport);
            NotificationUnionGetResponse notificationUnionGetResponse = unionService.getNotificationUnionId(notificationUnionGetRequest);
            if(!notificationUnionGetResponse.hasError()){
                sendUnionId = notificationUnionGetResponse.getUnionId();
            }
            //获取推送对象的ReceiveUnionId
            UserGetRequest userGetRequest = new UserGetRequest();
            userGetRequest.setTenantId(passport.getTenantId());
            userGetRequest.setId(taskPO.getOwnerUserId());
            UserGetResponse userGetResponse = masterService.getUser(userGetRequest,passport);
            if(!userGetResponse.hasError() && userGetResponse.getUser()!= null && userGetResponse.getUser().getUnionId() != null){
                receiveUnionId =userGetResponse.getUser().getUnionId();
            }
            //获取Identity
            Identity identity = new Identity();
            IdentityExchangeRequest identityExchangeRequest = new IdentityExchangeRequest();
            IdentityExchangeResponse identityExchangeResponse = unionService.exchangeIdentityByPassport(identityExchangeRequest,passport);
            if(!identityExchangeResponse.hasError()){
                identity = identityExchangeResponse.getIdentity();
            }
            //开始推送逾期消息给app
            if(sendUnionId != null && receiveUnionId != null) {

                AttachMessagePushRequest attachMessagePushRequest = new AttachMessagePushRequest();
                attachMessagePushRequest.setSendUnionId(sendUnionId);
                attachMessagePushRequest.setBadge(false);
                attachMessagePushRequest.setSave(true);
                attachMessagePushRequest.setNeedPushNick(false);
                attachMessagePushRequest.setReceiveUnionId(receiveUnionId);
                attachMessagePushRequest.setMessageType("UNION_EVENT_MESSAGE");
                attachMessagePushRequest.setMessageData("{type:30," +
                        "messageType:30," +
                        "data:{" +
                        "tenantId:"+passport.getTenantId()+
                        ",businessType:\"DYNAMIC_TASK_UPDATE\"" +
                        "}" +
                        "}");
                attachMessagePushRequest.setRoute(true);
                AttachMessagePushResponse attachMessagePushResponse = unionService.pushAttachMessage(attachMessagePushRequest, identity);
                if (attachMessagePushResponse.hasError()) {
                    logger.warn("---------推送动态消息告知app出错：" + JSON.toJSONString(attachMessagePushResponse));
                }
            }
        }

        response.setId(commentRecordCreateResponse.getId());
        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<>();
                List<TaskUser> ccUserList = new ArrayList<>();
                for (TaskUser user : userList) {
                    if (task.getId().equals(user.getTaskId())) {
                        if(user.getUserRole() != null){
                            if( user.getUserRole().equals(UserRoleEnum.CC_USER)){
                                ccUserList.add(user);
                            }else if(user.getUserRole().equals(UserRoleEnum.DEAL_USER)){
                                taskUserList.add(user);
                            }
                        }else{//兼容前版本
                            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;
    }

}