merage

kimi

2020-05-27 c007f0ca1785db093d48f4846cda82fe8e955765

 src/main/java/com/highdatas/mdm/controller/ActivitiController.java

@@ -2,7 +2,6 @@

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.highdatas.mdm.entity.*;
import com.highdatas.mdm.mapper.FlowsMapper;
import com.highdatas.mdm.pojo.*;
@@ -12,8 +11,6 @@
import com.highdatas.mdm.util.DbUtils;
import com.highdatas.mdm.util.TodoClient;
import lombok.extern.slf4j.Slf4j;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.task.Task;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -26,12 +23,14 @@
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;
import java.util.stream.Collectors;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author kimi
 * @description
 * @description 工作流接口
 * @date 2019-12-13 10:57
 */

@@ -78,38 +77,65 @@
    @Autowired
    IMenuMappingService menuMappingService;



    /**
     *
     * @description:  model list 接口
     * @param  pageNo 页数
     * @param  request 请求request
     * @return: Result 返回model list
     *
     */
    @RequestMapping(value = "/list/{pageNo}", method = RequestMethod.GET)
    public Result<List<Map<String, Object>>> list(@PathVariable Integer pageNo, HttpServletRequest request) {
        /*
         * filterSegment：  filter 参数
         * pageSize：  每页数量
         *
         * */

        String filterSegment = request.getParameter("filterSegment");
        String pageSize = request.getParameter("pageSize");
        if (StringUtils.isEmpty(filterSegment)) {
            filterSegment = Constant.WHERE_DEFAULT;
        }
        /* By 最大版本的model 列表*/
        List<Map<String, Object>> list = flowsMapper.selectVersion(filterSegment);
         /*添加生成后图片的url*/
        for (Map<String, Object> one : list) {
            String newModelId = (String) one.get(Constant.ID);
            String url = "act/img/" + newModelId;
            one.put("imgurl", url);
        }
        Integer size;
        /* pageSize 默认参数*/
        if (StringUtils.isEmpty(pageSize)) {
            size = 15;
        } else {
            size = Integer.valueOf(pageSize);
        }
         /*total list 转分页后的 page list*/
        return fieldService.getPagedDataByList(list, pageNo, size);
    }

    /**
     *
     * @description:  通过modelId获取流程图片接口
     * @param  modelId model的id
     * @param  response 请求返回的response
     * @return: void 直接塞到response里
     *
     */
    @RequestMapping(value = "/img/{modelId}", method = RequestMethod.GET)
    public void image(@PathVariable String modelId, HttpServletResponse response) {
        /*通过modelId 获取 model图片的流*/
        InputStream is = repositoryService.getModelImg(modelId);
        if (is == null) {
            return;
        }
        /*设置返回的头信息*/
        response.setHeader("Content-Type", "image/png");
        try {
            /*写到response里*/
            OutputStream outputStream = response.getOutputStream();
            byte[] b = new byte[1024];
            int len;
@@ -121,6 +147,7 @@
        } finally {
            if (is != null) {
                try {
                    /*关闭流*/
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
@@ -131,8 +158,16 @@

    }

    /**
     *
     * @description:  通过modelId删除model 接口
     * @param  modelId model的id
     * @return: Result 删除信息的返回值
     *
     */
    @RequestMapping(value = "/deleteModel/{modelId}", method = RequestMethod.GET)
    public Result deleteModel(@PathVariable String modelId) {
        /*通过id删除model*/
        boolean b = repositoryService.deleteModel(modelId);
        if (b) {
            return Result.success(null);
@@ -141,18 +176,19 @@
        }
    }

    @RequestMapping(value = "/processlist", method = RequestMethod.GET)
    public Result<Result<JSONArray>> processlist(HttpServletRequest request) {
        Result<JSONArray> processList = repositoryService.getProcessList();
        return Result.success(processList);
    }
//    @RequestMapping(value = "/processlist", method = RequestMethod.GET)
//    public Result<Result<JSONArray>> processlist(HttpServletRequest request) {
//        Result<JSONArray> processList = repositoryService.getProcessList();
//        return Result.success(processList);
//    }

    @RequestMapping(value = "/modellist", method = RequestMethod.GET)
    public Result<Result<JSONArray>> modellist(HttpServletRequest request) {
        Result<JSONArray> processList = repositoryService.getProcessList();
        return Result.success(processList);
    }
    /**
     *
     * @description:  启动流程后平台回调接口

     * @return: Result 启动流程后返回
     *
     */
    @RequestMapping(value = "/started", method = RequestMethod.POST)
    public Result<Object> startRun(@RequestBody JSONArray result) {
        for (int i = 0; i < result.size(); i++) {
@@ -162,9 +198,19 @@
        return Result.success(null);
    }

    /**
     *
     * @description:  页面调用启动流程接口
     * @param: key  model的key
     * @param businessId  业务系统的id
     * @return: Result 启动流程后返回
     *
     */
    @RequestMapping(value = "/startRun/{key}", method = RequestMethod.GET)
    public Result<Object> startRun(@PathVariable String key, @RequestParam String businessId, HttpServletRequest request) {
         /*header里面获取user信息*/
        TUser user = DbUtils.getUser(request);
         /*businessType 业务系统的类型*/
        String businessType = request.getParameter("businessType");
        ActivitiBusinessType type;
        if (StringUtils.isEmpty(businessType)) {
@@ -175,13 +221,19 @@
        String content;
        if (type.equals(ActivitiBusinessType.maintain)) {
            Maintain maintain = maintainService.selectById(businessId);
             /*通过表名获取主题信息*/
            SysMenu menuByTableName = menuMappingService.getMenuByTableName(maintain.getTableName());
            /* content 通知信息的具体内容*/
            content = menuByTableName.getName() + "主题新增版本需要审批";
        } else {
            MaintainField maintainField = maintainFieldService.selectById(businessId);
             /*通过表名获取主题信息*/
            SysMenu menuByTableName = menuMappingService.getMenuByTableName(maintainField.getTableName());
             /*content 通知信息的具体内容*/
            content = menuByTableName.getName() + "主题修改字段需要审批";
        }

        /*调起平台启动流程接口*/
        boolean open = client.open(key, businessId, content, user.getUserId(), type);
        if (open) {
            return Result.success(CodeMsg.SUCCESS);
@@ -190,6 +242,18 @@
        }
    }

    /**
     *
     * @description:  平台调用启动流程接口
     * @param: key  model的key
     * @param reqObj  请求具体信息
     *                businessId： 业务系统id
     *                desc： 描述信息
     *                businessType： 业务系统类型
     *                variableMap：其他额外的信息，保存进流程里
     * @return: Result 启动流程后返回下一节点的用户信息
     *
     */
    @RequestMapping(value = "/start/{key}", method = RequestMethod.POST)
    public Result<Object> start(@PathVariable String key, @RequestBody JSONObject reqObj, HttpServletRequest request) {
        log.info("process start..");
@@ -216,6 +280,7 @@

        if (type.equals(ActivitiBusinessType.maintain)) {
            Maintain maintain = maintainService.selectById(businessId);
            /*判断本主题是否已经有流程正在启动，若已经启动则不再允许*/
            boolean canStart = maintainService.getCanAct(maintain.getTableName());
            if (!canStart) {
                return Result.error(CodeMsg.ACT_RUN_ERROR);
@@ -231,18 +296,22 @@
        }
        HttpSession session = request.getSession();
        Date startDate = new Date();
        /*启动流程*/
        Flows flows = activitiService.start(key, session, businessId, type, variableMap);
        Date endDate = new Date();
        log.info("process start:" + (endDate.getTime() - startDate.getTime()) + "ms");
        if (flows == null) {
            return Result.error(CodeMsg.INSERT_ERROR);
        } else {
            /*启动流程后的操作*/
            if (type.equals(ActivitiBusinessType.field)) {
                /*更新流程信息到 MaintainField表*/
                MaintainField maintainField = maintainFieldService.selectById(businessId);
                maintainField.setFlowId(flows.getId());
                maintainField.setDesp(desc);
                maintainField.updateById();
            } else if (type.equals(ActivitiBusinessType.maintain)) {
                /*更新流程信息到 maintain表*/
                Maintain maintain = maintainService.selectById(businessId);
                maintain.setFlowId(flows.getId());
                maintain.setDesp(desc);
@@ -251,6 +320,8 @@
            startDate = new Date();
            log.info("process save status:" + (startDate.getTime() - endDate.getTime()) + "ms");
            HashMap<String, Object> body = new HashMap();
             /*获取下一节点的用户信息*/

            NextTaskUserInfo nestTaskAssignee = taskService.getNestTaskAssignee(flows.getWorkflowId());
            endDate = new Date();
            log.info("process find user info:" + (endDate.getTime() - startDate.getTime()) + "ms");
@@ -266,111 +337,121 @@
        }
    }

    @RequestMapping(value = "/status/{flowid}", method = RequestMethod.GET)
    public ArrayList<HistoricActivityInstance> status(@PathVariable String flowid, HttpServletRequest request) {
        if (StringUtils.isEmpty(flowid)) {
            return null;
        }
        historyService.setSession(request.getSession());
        Flows flows = flowsService.selectById(flowid);
        if (flows == null) {
            return null;
        }
        String workflowid = flows.getWorkflowId();
        ArrayList<HistoricActivityInstance> historyAction = historyService.getHistoryAction(workflowid);
        return historyAction;
    }
//    @RequestMapping(value = "/status/{flowid}", method = RequestMethod.GET)
//    public ArrayList<HistoricActivityInstance> status(@PathVariable String flowid, HttpServletRequest request) {
//        if (StringUtils.isEmpty(flowid)) {
//            return null;
//        }
//        historyService.setSession(request.getSession());
//        Flows flows = flowsService.selectById(flowid);
//        if (flows == null) {
//            return null;
//        }
//        String workflowid = flows.getWorkflowId();
//        ArrayList<HistoricActivityInstance> historyAction = historyService.getHistoryAction(workflowid);
//        return historyAction;
//    }

    @RequestMapping(value = "{tableName}/history/{pageNo}", method = RequestMethod.GET)
    public Result history(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) {
        historyService.setSession(request.getSession());
        String pageSizeStr = request.getParameter("pageSize");

        List<HistoricProcessInstance> processInstanceList = historyService.getHistoryTask();
        List<HistoricProcessInstance> subList = new ArrayList<>();
        for (HistoricProcessInstance historicProcessInstance : processInstanceList) {
            Flows flows = flowsService.selectOne(new EntityWrapper<Flows>().eq("workflow_id", historicProcessInstance.getId()));
            if (flows == null) {
                continue;
            }
            ActivitiBusinessType businessType = flows.getBusinessType();
            if (ActivitiBusinessType.maintain.equals(businessType)) {
                String businessId = flows.getBusinessId();
                Maintain maintain = maintainService.selectById(businessId);
                if (maintain == null) {
                    continue;
                }
                String maintainTableName = maintain.getTableName();
                if (maintainTableName.equalsIgnoreCase(tableName)) {
                    subList.add(historicProcessInstance);
                }
            }
        }

        Page page = new Page(subList.size());
        page.setPageNo(pageNo);
        if (!StringUtils.isEmpty(pageSizeStr)) {
            page.setPageSize(Integer.valueOf(pageSizeStr));
        }

        subList = subList.stream().skip(page.getBeginRecordNo_1()).limit(page.getPageSize()).collect(Collectors.toList());
        ArrayList<Map<String, Object>> result = new ArrayList<>();
        for (HistoricProcessInstance historicProcessInstance : subList) {
            HashMap<String, Object> one = new HashMap<>();
            String workflowId = historicProcessInstance.getId();
            String startUserId = historicProcessInstance.getStartUserId();
            TUser user = DbUtils.getUserById(startUserId);
            Flows flows = flowsService.selectOne(new EntityWrapper<Flows>().eq("workflow_id", workflowId));
            Maintain maintain = maintainService.selectById(flows.getBusinessId());
            one.put("userName", user.getUserName());
            one.put("id", flows.getId());
            one.put("status", flows.getStatus());
            one.put("createTime", flows.getCreateTime());
            result.add(one);
        }

        Collections.sort(result, new Comparator<Map<String, Object>>() {
            @Override
            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
                Date o1Date = (Date) o1.get("createTime");
                Date o2Date = (Date) o2.get("createTime");
                return o2Date.compareTo(o1Date);
            }
        });

        JSONObject object = new JSONObject();
        object.fluentPut("total", page.getRecordCount());
        object.fluentPut("size", page.getPageSize());
        object.fluentPut("pages", page.getPageCount());
        object.fluentPut("current", page.getPageNo());
        object.fluentPut("record", result);

        return Result.success(object);
    }
//    @RequestMapping(value = "{tableName}/history/{pageNo}", method = RequestMethod.GET)
//    public Result history(@PathVariable String tableName, @PathVariable Integer pageNo, HttpServletRequest request) {
//        historyService.setSession(request.getSession());
//        String pageSizeStr = request.getParameter("pageSize");
//
//        List<HistoricProcessInstance> processInstanceList = historyService.getHistoryTask();
//        List<HistoricProcessInstance> subList = new ArrayList<>();
//        for (HistoricProcessInstance historicProcessInstance : processInstanceList) {
//            Flows flows = flowsService.selectOne(new EntityWrapper<Flows>().eq("workflow_id", historicProcessInstance.getId()));
//            if (flows == null) {
//                continue;
//            }
//            ActivitiBusinessType businessType = flows.getBusinessType();
//            if (ActivitiBusinessType.maintain.equals(businessType)) {
//                String businessId = flows.getBusinessId();
//                Maintain maintain = maintainService.selectById(businessId);
//                if (maintain == null) {
//                    continue;
//                }
//                String maintainTableName = maintain.getTableName();
//                if (maintainTableName.equalsIgnoreCase(tableName)) {
//                    subList.add(historicProcessInstance);
//                }
//            }
//        }
//
//        Page page = new Page(subList.size());
//        page.setPageNo(pageNo);
//        if (!StringUtils.isEmpty(pageSizeStr)) {
//            page.setPageSize(Integer.valueOf(pageSizeStr));
//        }
//
//        subList = subList.stream().skip(page.getBeginRecordNo_1()).limit(page.getPageSize()).collect(Collectors.toList());
//        ArrayList<Map<String, Object>> result = new ArrayList<>();
//        for (HistoricProcessInstance historicProcessInstance : subList) {
//            HashMap<String, Object> one = new HashMap<>();
//            String workflowId = historicProcessInstance.getId();
//            String startUserId = historicProcessInstance.getStartUserId();
//            TUser user = DbUtils.getUserById(startUserId);
//            Flows flows = flowsService.selectOne(new EntityWrapper<Flows>().eq("workflow_id", workflowId));
//            Maintain maintain = maintainService.selectById(flows.getBusinessId());
//            one.put("userName", user.getUserName());
//            one.put("id", flows.getId());
//            one.put("status", flows.getStatus());
//            one.put("createTime", flows.getCreateTime());
//            result.add(one);
//        }
//
//        Collections.sort(result, new Comparator<Map<String, Object>>() {
//            @Override
//            public int compare(Map<String, Object> o1, Map<String, Object> o2) {
//                Date o1Date = (Date) o1.get("createTime");
//                Date o2Date = (Date) o2.get("createTime");
//                return o2Date.compareTo(o1Date);
//            }
//        });
//
//        JSONObject object = new JSONObject();
//        object.fluentPut("total", page.getRecordCount());
//        object.fluentPut("size", page.getPageSize());
//        object.fluentPut("pages", page.getPageCount());
//        object.fluentPut("current", page.getPageNo());
//        object.fluentPut("record", result);
//
//        return Result.success(object);
//    }


    @RequestMapping(value = "/diagram/{flowid}", method = RequestMethod.GET)
    public void getDiagram(@PathVariable String flowid, HttpServletResponse response) {
        if (StringUtils.isEmpty(flowid)) {
            return;
        }
        Flows flows = flowsService.selectById(flowid);
        if (flows == null) {
            return;
        }
        String workflowid = flows.getWorkflowId();
        runtimeService.getDiagram(workflowid, response);
    }
//    @RequestMapping(value = "/diagram/{flowid}", method = RequestMethod.GET)
//    public void getDiagram(@PathVariable String flowid, HttpServletResponse response) {
//        if (StringUtils.isEmpty(flowid)) {
//            return;
//        }
//        Flows flows = flowsService.selectById(flowid);
//        if (flows == null) {
//            return;
//        }
//        String workflowid = flows.getWorkflowId();
//        runtimeService.getDiagram(workflowid, response);
//    }

    @RequestMapping(value = "/run", method = RequestMethod.GET)
    public List<Map<String, String>> runTask(HttpServletRequest request) {
        historyService.setSession(request.getSession());
        List<Map<String, String>> myRunTask = historyService.getMyRunTask();
        return myRunTask;
    }
//    @RequestMapping(value = "/run", method = RequestMethod.GET)
//    public List<Map<String, String>> runTask(HttpServletRequest request) {
//        historyService.setSession(request.getSession());
//        List<Map<String, String>> myRunTask = historyService.getMyRunTask();
//        return myRunTask;
//    }

    /**
     *
     * @description:  获取用户的待审批信息
     * @param :pageNo  页数
     * @param :pageSize  每页数量

     * @return: Result 待审批流程列表
     *
     */
    @RequestMapping(value = "/todo", method = RequestMethod.GET)
    public Result todoTask(HttpServletRequest request) {

        String pageNo = request.getParameter("pageNo");
        String pageSize = request.getParameter("pageSize");
        if (StringUtils.isEmpty(pageNo)) {
@@ -382,17 +463,32 @@
        return activitiService.todoTask(request.getSession(), request.getParameter(Constant.tableName), Integer.valueOf(pageNo), Integer.valueOf(pageSize));
    }

    /**
     *
     * @description:  平台调用处理流程接口
     * @param: flowid  流程id
     * @param: reqObj  请求具体信息
     *                pass： 是否同意
     *                reason： 审判理由
     *                以及其他额外的信息，保存进流程里
     * @return: Result 启动流程后返回下一节点的用户信息
     *
     */
    @RequestMapping(value = "/deal/{flowid}", method = RequestMethod.POST)
    @Transactional(rollbackFor = {RuntimeException.class, Error.class})
    public Result doTask(@PathVariable String flowid, @RequestBody JSONObject reqObj, HttpServletRequest request) {
        /*校验 flowid*/
        if (StringUtils.isEmpty(flowid)) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        /*通过id获取flow 信息*/
        Flows flows = flowsService.selectById(flowid);
        /*校验flows信息*/
        if (flows == null) {
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
        Boolean pass;
        /*转换pass*/
        try {
            pass = (boolean) reqObj.get("pass");
            if (pass == null) {
@@ -403,6 +499,7 @@
            e.printStackTrace();
            return Result.error(CodeMsg.ERROR_PARAMS_NOT_MATHED);
        }
         /*jsonobject 转为map*/
        HashMap<String, Object> vailableMap = DbUtils.JsonObjectToHashMap(reqObj);

        HttpSession session = request.getSession();
@@ -412,17 +509,20 @@
//        Task task = TimeTaskService.geTask(workflowId);
//        String id = task.getId();
        String taskId = null;
        /*判断任务是否已经被接收*/
        if (taskService.checkClaim(workflowId)) {
            taskId = taskService.claimTask(workflowId);
        }

        String reason;
        /*转换reason信息*/
        Object reasonObj = vailableMap.get("reason");
        if (reasonObj == null) {
            reason = "确认处理";
        }else  {
            reason = reasonObj.toString();
        }
        /*如果没获取到task 再从tasksetvice里获取一次*/
        if (taskId == null) {
            Task task = taskService.geTask(workflowId);
            if (task == null) {
@@ -430,13 +530,16 @@
            }
            taskId = task.getId();
        }

        /*处理任务*/
        boolean completed = taskService.completeTask(taskId, pass, reason, vailableMap);

        if (completed) {
            /*处理成功   继续后面的操作*/
            NextTaskUserInfo nextTaskDefinition = null;
            /*判断流程是否结束*/
            boolean taskFinished = historyService.isTaskFinished(workflowId);
            if (taskFinished) {
                /*处理流程状态*/
                if (ActivitiStatus.refuse.equals(status)) {
                    flows.setStatus(ActivitiStatus.close);
                } else {
@@ -446,20 +549,22 @@
                if (!pass) {
                    flows.setStatus(ActivitiStatus.close);
                }

                /*流程完成后的一些操作*/
                flowsService.aduitFinish(flows);

            } else {
                /*流程未完成， 修改流程状态*/
                if (pass && flows.getStatus().equals(ActivitiStatus.refuse)) {
                    flows.setStatus(ActivitiStatus.working);
                } else if (!pass && flows.getStatus().equals(ActivitiStatus.working)) {
                    flows.setStatus(ActivitiStatus.refuse);
                }
                /*返回 流程下一节点的信息*/
                nextTaskDefinition = taskService.getNestTaskAssignee(workflowId);

            }
            HashMap<String, Object> body = new HashMap();

        /*组装 返回信息*/
            body.put("status", flows.getStatus().name());
            if (nextTaskDefinition == null) {
                body.put("roleIdList", null);
@@ -476,43 +581,81 @@
            return Result.success(CodeMsg.INSERT_ERROR);
        }
    }

    /**
     *
     * @description:  平台调用添加工作流用户信息接口
     * @param: userId  用户id
     * @return: Result 添加用户返回信息
     *
     */
    @RequestMapping(value = "/addActUser")
    public Result addActUser(@RequestParam String userId) {
        return identityService.addUser(userId);
    }

    /**
     *
     * @description:  平台调用添加工作流角色信息接口
     * @param: roleId  角色id
     * @return: Result 添加角色返回信息
     *
     */
    @RequestMapping(value = "/addActRole")
    public Result addActRole(@RequestParam String roleId) {
        return identityService.addRole(roleId);
    }

    /**
     *
     * @description:  平台调用添加工作流角色，用户关联信息接口
     * @param: roleId  角色id
     * @param: userId  用户id
     * @return: Result 添加角色，用户关联返回信息
     *
     */

    @RequestMapping(value = "/addActUserRole")
    public Result addActUserRole(@RequestParam String roleId, @RequestParam String userId) {
        return identityService.addUserRole(roleId, userId);
    }

    /**
     *
     * @description:  平台调用删除工作流角色，用户关联信息接口
     * @param: roleId  角色id
     * @param: userId  用户id
     * @return: Result 删除角色，用户关联返回信息
     *
     */
    @RequestMapping(value = "/deleteActUserRole")
    public Result deleteActUserRole(@RequestParam String roleId, @RequestParam String userId) {
        return identityService.deleteUserRole(roleId, userId);
    }

    /**
     *
     * @description:  平台调用删除工作流角色信息接口
     * @param: roleId  角色id
     * @return: Result 删除角色返回信息
     *
     */
    @RequestMapping(value = "/deleteActRole")
    public Result deleteActRole(@RequestParam String roleId) {
        return identityService.deleteRole(roleId);
    }

    /**
     *
     * @description:  平台调用删除工作流用户信息接口
     * @param: userId  用户id
     * @return: Result 删除用户返回信息
     *
     */
    @RequestMapping(value = "/deleteActUser")
    public Result deleteActUser(@RequestParam String userId) {
        return identityService.deleteUser(userId);
    }


    @RequestMapping(value = "/test")
    public Result test(@RequestParam String roleId, @RequestParam String roleId2, @RequestParam String userId) {
        identityService.deleteUserRole(roleId, userId);
        identityService.addUserRole(roleId, userId);
        identityService.deleteUserRole(roleId2, userId);
        return identityService.addUserRole(roleId2, userId);
    }

}