Java与MySQL的绝妙结合：打造高效审批流程

置顶 已于 2023-09-18 13:34:33 修改
阅读量8.2k 收藏 161
点赞数 41
文章标签： 开发语言 java spring spring boot mysql sql
于 2023-09-18 11:44:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46522803/article/details/131377730
版权

是流程思路等分析🐱‍👤

审批流程🐱‍💻

1️⃣.串行流程

当前节点审批完成后，下一次节点才能进行操作，例如经理通过之后，总监才能审批；

2️⃣.并行流程

一个审批节点需要多人联审。一般有两种方式：会签、或签；

  • 会签：

        注意：别跟串行审批混淆。会签的多个角色是平行的，没有上下级关系、前后顺序。

        例如：在某项文件、合同、决策或其他重要事项上，需要多个相关人员进行确认、批准或签署的情况下，参与该过程的人员同时批准，这时会签就能很大程度上提高效率，顺便也能解决人情世故的问题～～。

        会签支持并签：

         业务模式支持："全部投票"、"按投票比例"、"按投票通过比例"、支持设置 "百分比" 和 "分数" 两种方式。

  • 或签(也有叫"竞签"、"串签")：指同一个审批节点设置多个人，如ABC三人，三人会同时收到审批，只要其中任意一人审批即可到下一审批节点；

3️⃣.条件流程

根据不同规则，走不同流程

例如报销5000以下直属领导审批就行，5000~10000需要总监审批。

4️⃣.混合流程

就是上述的流程混合运用；

例如请假的正常流程是到直属领导审批，3天以上需要总监审批。5天以上需要总裁审批。

审批动作🙋‍♀️

1. 通过：通过申请，流转到下一人。原因选填。

2. 驳回：驳回到发起人、驳回到上一环节、驳回到之前的某一环节

3. 保存：保存当前填写的信息。

4. 转交：转交给某人审批

5. 加签：处理者可以在审批时临时增加审核人员

6. 抄送：抄送人会知晓审核过程，但不进行操作

执行动作👩‍🎓

申请：针对当前业务表单信息发起申请，开始审批流程的传递。分为2部分：由申请提交人手动发起申请、由程序自动判断满足触发规则的数据自动发起申请；另外还要注意的2点：是否允许提交人撤销（是、否）、记录编辑（不可编辑、管理员可编辑、管理员和审批人都可编辑 ）；

通过：当前步骤处理通过，进入下一步骤，若为末步骤，则流程处理完成；

退回：将步骤退回至上一步骤，即返回至上一处理人处，若为首步骤，则不进行退回；

否决：将步骤直接结束，执行结束动作拒绝活动，不再进行操作，或者回退至第一步骤；

撤回：若当前步骤已处理，下一处理人未处理的情况下可进行撤回操作。

节点状态🕵️‍♀️

提交人： 未提交、已提交、处理中、已结束。

处理人： 待处理、已处理。

创建业务工单：提交人登录系统之后，选择想要发起的业务工单，填写业务工单。填写完成可以选择提交或者保存；

未提交：列表中显示所有保存但未提交的业务工单，未提交列表中的业务工单都没有业务工单编号（唯一），状态为“未提交”。提交人可以选择某个业务工单后能方便对其进行修改、删除和提交；

已提交：列表显示所有已经提交的业务工单，有业务工单编号，并显示（未处理）。提交后的业务工单进入处理流程，提交人无法进行修改和删除；

处理中：列表显示所有提交并已经有节点处理的业务工单，提交人可以查询某个业务工单的处理进度；

已结束：列表显示所有已经处理完成的业务工单；

待处理：列表显示所有待处理业务工单；

已处理：列表显示所有当前处理人已处理的业务工单，既被当前处理人流转到下一个流程节点的业务工单；

UI预览🛹

表设计🚧

流程配置表🚗

CREATE TABLE `approval_config` (
  `approval_config_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '雪花算法',
  `corp_id` varchar(100) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '企业ID',
  `node_name` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '节点名称',
  `form_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '表单ID 属于那个表单的流程',
  `approval_auto_pass` tinyint(1) DEFAULT '0' COMMENT '审批节点人员相同时自动通过[1：true；0：false]',
  `current_node_approver_type` tinyint DEFAULT NULL COMMENT '审批人类型[1:发起人自己；2:指定角色；3:指定人员；4:表单内人员]；注：1/3/4存userid、2存roleId',
  `current_node_approver` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '待审批人如果是角色就是角色ID，如果是其他则是userId格式：[xxx,xxx]',
  `care_of` tinyint(1) DEFAULT NULL COMMENT '允许审批人转交[1：true;2：false]',
  `approval_type` tinyint DEFAULT NULL COMMENT '审批类型[1:会签：2：或签]',
  `approval_node` int DEFAULT NULL COMMENT '审批节点[取值：1~N 从小到大；0：发起节点 、1：是第一个节点、 2：第二个节点 N：是第N个节点；最大的是结束节点]',
  `carbon_copy_recipients_type` tinyint DEFAULT '1' COMMENT '抄送人类型[1:发起人自己；2:指定角色；3:指定人员；4:表单内人员]',
  `carbon_copy_recipients` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '抄送人userId 数组格式',
  `create_time` datetime DEFAULT NULL COMMENT '规则创建时间；默认拿最新的',
  `group_id` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '分组[标识那些节点是同一个组的]',
  `visible_fields` json DEFAULT NULL COMMENT '可见字段：[{"bt": false, "kj": true, "kx": true, "field": "create_time", "children": "purchase_requisition_details"}];\r\nkj:可见；kx:可写；kb:必填。如果是最后一个节点就需要单独拉一个配置',
  PRIMARY KEY (`approval_config_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='审批流程节点规则配置表';

 审批流程发起表🚓

CREATE TABLE `approval_info` (
  `approval_info_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '雪花算法',
  `corp_id` varchar(50) COLLATE utf8mb4_general_ci NOT NULL COMMENT '企业ID',
  `approval_config_group_id` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '规则表的groupID',
  `form_id` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '表单ID 属于那个表单',
  `founder` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '发起人',
  `launch_time` datetime NOT NULL COMMENT '发起时间',
  `end_state` tinyint(1) DEFAULT '0' COMMENT '是否结束流程[1是]',
  `end_time` datetime DEFAULT NULL COMMENT '流程结束时间',
  `object_id` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '关联某条数据',
  `process_progress` int DEFAULT '0' COMMENT '用来记录整个流程进行到那个节点',
  `record_node_history` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '记录历史经历节点,英文逗号分隔0,1,2,1,2,3 最后一个值和当前节点同步',
  PRIMARY KEY (`approval_info_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='审批流程发起表';

审批记录表🚕

CREATE TABLE `approval_record` (
  `approval_record_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '雪花算法',
  `corp_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '企业ID',
  `approval_info_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '审批发起表approval_info',
  `form_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '表单ID 属于那个表单的流程',
  `approver_user_id` varchar(50) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NOT NULL COMMENT '审批人or 转交人 userId',
  `approver_time` datetime NOT NULL COMMENT '审批时间',
  `approver_opinions` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '审批意见',
  `approver_result` tinyint NOT NULL COMMENT '审批结果[1:同意；2:拒绝：3:转交]',
  `transferee` varchar(50) COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '被转交人userId；approver_result=3时必填',
  `transferee_text` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '转交备注(此字段暂时无用)',
  `accessory_url` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci DEFAULT NULL COMMENT '附件数组',
  `approver_node` tinyint NOT NULL COMMENT '属于个节点的审批记录',
  `approver_count` tinyint DEFAULT '1' COMMENT '审批次数默认1; 例：当节点B是会签,且有人同意,有人拒绝，当拒绝后会返回上一个节点A。当再次进入节点B时，用来区分,此审批记录是第一次记录还是第二次审批记录或者第N次',
  PRIMARY KEY (`approval_record_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='审批记录表';

 抄送记录表🛺

CREATE TABLE `approval_carbon_copy` (
  `carbon_copy_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '雪花',
  `corp_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '企业ID',
  `form_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '属于那个表单',
  `approval_info_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '推送那条审批的ID',
  `user_id` varchar(255) COLLATE utf8mb4_general_ci NOT NULL COMMENT '接收抄送人',
  `create_time` datetime NOT NULL COMMENT '抄送时间',
  `read` tinyint(1) NOT NULL DEFAULT '0' COMMENT '是否已读[1:已读；0:未读]',
  `approval_node` tinyint NOT NULL COMMENT '那个节点抄送的',
  PRIMARY KEY (`carbon_copy_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci COMMENT='审批抄送记录表';

思路👩‍🎓👩‍🎓

流程配置

1.通过流程节点规则配置表，配置每个节点的审批人、抄送人、审批规则、可见、可写、必填字段的规则等(可以给不同的表单配置不同的审批规则)。

2.配置完毕即可，每次新增数据，读取流程规则配置表，生成一条审批流程发起记录，记录发起人，发起时间，关联某条流程规则(旧数据还是使用旧流程)，流程当前节点等。

3.每个节点的审批人、抄送人、可见、可写、必填字段都是根据流程规则配置表中动态配置。

代码🥇

审批按钮

  @Transactional(rollbackFor = Exception.class)
    public ResultUtils approval(String token, ApprovalDTO param) {
        String corpId = TokenUtils.getCorpId(token);
        String userId = TokenUtils.getUserId(token);
        LocalDateTime time = LocalDateTime.now();

        // 找到当前数据待审批节点,是否需要自己审批,或者已经审批过
        ApprovalInfo info = approvalInfoMapper.selectOne(new QueryWrapper<ApprovalInfo>().eq("corp_id", corpId).eq("object_id", param.getObjectId())
                .eq("form_id", param.getFormId()).select("approval_info_id", "process_progress", "record_node_history", "end_state",
                        "approval_config_group_id","founder"));
        Assert.isFalse(info.getEndState(), ErrorMsg.msg18);
        Integer currentNode = info.getProcessProgress();// 当前节点

        // 每个节点的审批设置
        List<ApprovalConfig> approvalConfigs = approvalConfigMapper.selectList(new QueryWrapper<ApprovalConfig>().eq("corp_id", corpId)
                .eq("group_id", info.getApprovalConfigGroupId())
                .eq("form_id", param.getFormId()).select("approval_auto_pass", "current_node_approver_type", "visible_fields",
                        "current_node_approver", "care_of", "approval_type", "approval_node", "carbon_copy_recipients_type", "carbon_copy_recipients"));

        Map<Integer, ApprovalConfig> configMap = approvalConfigs.stream().collect(Collectors.toMap(ApprovalConfig::getApprovalNode, ApprovalConfig -> ApprovalConfig));
        ApprovalConfig config = configMap.get(info.getProcessProgress());

        List<String> historyNode = Lists.newArrayList(info.getRecordNodeHistory().split(","));
        // 历史节点需要剔除最后一个
        historyNode.remove(historyNode.size() - 1);
        Bag bag = new HashBag(historyNode);
        int count = bag.getCount(currentNode.toString());// 这个节点历史是否出现过
        count = count == 0 ? 1 : (count + 1); // 用于标注这个节点是否多次审批

        if (param.getType() == 3) {
            // 转交
            ApprovalRecord record = new ApprovalRecord();
            record.setApprovalRecordId(SnowFlakeUtil.getDefaultSnowFlakeId() + "");
            record.setCorpId(corpId);
            record.setApprovalInfoId(info.getApprovalInfoId());
            record.setFormId(param.getFormId());
            record.setApproverUserId(userId);
            record.setApproverTime(time);
            record.setApproverOpinions(param.getMessage());
            record.setApproverResult(param.getType());
            record.setTransferee(param.getTransfereeUserId());
            if (ObjectUtil.isNotEmpty(param.getAccessoryUrl())) {
                record.setAccessoryUrl(JSONUtil.toJsonStr(param.getAccessoryUrl()));
            }
            record.setApproverNode(info.getProcessProgress().byteValue());
            record.setApproverCount(new Byte(count + ""));
            approvalRecordMapper.insertSelective(record);
            return ResultUtils.success();
        }

        ApprovalRecord records = approvalRecordMapper.selectOne(new QueryWrapper<ApprovalRecord>()
                .eq("corp_id", corpId).eq("form_id", param.getFormId())
                .eq("approver_user_id", userId).eq("approval_info_id", info.getApprovalInfoId())
                .eq("approver_node", currentNode).eq("approver_count", count));
        Assert.isFalse(ObjectUtil.isNotEmpty(records) && StrUtil.isNotBlank(records.getTransferee()), ErrorMsg.msg29);

        Assert.isFalse(ObjectUtil.isNotEmpty(records), ErrorMsg.msg16);
        // 查询是否是被转交人
        List<String> transferees = approvalRecordMapper.findTransferee(corpId, param.getFormId(), info.getApprovalInfoId(), currentNode, count);
        if (CollUtil.isEmpty(transferees)) {
            // 1.是否需要自己审批
            if (config.getCurrentNodeApproverType() == 2) {
                // 指定角色
                // 查询自己拥有那些角色
                List<UserRole> userRoles = userRoleMapper.selectList(new QueryWrapper<UserRole>().eq("user_id", userId).eq("corp_id", corpId)
                        .select("role_id"));
                List<String> roleIds = userRoles.stream().map(key -> key.getRoleId()).collect(Collectors.toList());
                List<Integer> currentNodeApproverRoleId = JSONUtil.toList(config.getCurrentNodeApprover().toString(), Integer.class);
                ArrayList<String> integers = new ArrayList<>(roleIds);
                boolean b = integers.retainAll(currentNodeApproverRoleId);// 存在交集则返回true
                Assert.isFalse(!b, ErrorMsg.msg17);
            } else if (config.getCurrentNodeApproverType()==3){
                // 指定人员 用户ID
                List<String> currentNodeApproverUserId = JSONUtil.toList(config.getCurrentNodeApprover().toString(), String.class);
                boolean contains = currentNodeApproverUserId.contains(userId);
                Assert.isFalse(!contains, ErrorMsg.msg17);
            } else if (config.getCurrentNodeApproverType() == 1) {
               // 发起人自己
                Assert.isFalse(!info.getFounder().equals(userId), ErrorMsg.msg17);
            }
        }
        if (param.getType() == 2) {
            // 拒绝
            approvalRefuse(info, approvalConfigs, param, userId, corpId, count, time);
            return ResultUtils.success();
        }

        // 判断了需要自己审批之后,先编辑数据,然后在进行审批操作
        JSONObject paramData = param.getMainData();
        approvalEditData(corpId, paramData, time, userId, param.getFormId());

        // 进行审批操作
        if (param.getType() == 1) {
            // 同意
            approvalAgreeing(currentNode, info, configMap, param, userId, corpId, time, param.getObjectId());
        }
        return ResultUtils.success();
    }

 审批按钮-拒绝

    /**
     * 审批按钮-拒绝
     *
     * @param info            当前数据的审批详情
     * @param approvalConfigs 审批规则
     * @param param           参数
     * @param userId          当前审批人id
     * @param corpId          企业id
     * @param count           审批次数
     */
    private void approvalRefuse(ApprovalInfo info, List<ApprovalConfig> approvalConfigs, ApprovalDTO param, String userId, String corpId, int count, LocalDateTime time) {
        // 生成审批记录
        ApprovalRecord record = new ApprovalRecord();
        record.setApprovalRecordId(SnowFlakeUtil.getDefaultSnowFlakeId() + "");
        record.setCorpId(corpId);
        record.setApprovalInfoId(info.getApprovalInfoId());
        record.setFormId(param.getFormId());
        record.setApproverUserId(userId);
        record.setApproverTime(time);
        record.setApproverOpinions(param.getMessage());
        record.setApproverResult(param.getType());
        if (ObjectUtil.isNotEmpty(param.getAccessoryUrl())) {
            record.setAccessoryUrl(JSONUtil.toJsonStr(param.getAccessoryUrl()));
        }
        record.setApproverNode(info.getProcessProgress().byteValue());
        record.setApproverCount(new Byte(count + ""));
        approvalRecordMapper.insertSelective(record);

        // 回滚上一个节点
        info.setProcessProgress(info.getProcessProgress() - 1);
        info.setRecordNodeHistory(info.getRecordNodeHistory() + "," + info.getProcessProgress());
        // info.setCurrentState(1);
        approvalInfoMapper.updateByPrimaryKeySelective(info);

        if (info.getProcessProgress() == 0) {
            // 如果回到第一个节点,数据状态则变成初始
            String formCode = fromConfigMapper.findFormCode(corpId, param.getFormId());
            commonMapper.updateDataState(formCode, 0, param.getObjectId(), corpId);


        }
    }

 审批按钮-同意

    /**
     * 审批按钮-同意
     *
     * @param currentNode 处理的当前节点
     * @param info        流程详情
     * @param configMap   配置集合 key=节点；val=配置
     * @param param       参数
     * @param userId      当前审批人userId
     * @param corpId      企业ID
     * @param time        当前时间
     */
    private void approvalAgreeing(Integer currentNode, ApprovalInfo info, Map<Integer, ApprovalConfig> configMap,
                                  ApprovalDTO param, String userId, String corpId, LocalDateTime time, String objectId) {
        // 查询这个节点以前是否审批过
        List<String> historyNode = Lists.newArrayList(info.getRecordNodeHistory().split(","));// 历史节点需要剔除最后一个
        historyNode.remove(historyNode.size() - 1);
        Bag bag = new HashBag(historyNode);
        int count = bag.getCount(currentNode.toString());// 这个节点历史是否出现过
        count = count == 0 ? 1 : count + 1; // 用于标注这个节点是否多次审批

        // 生成审批记录
        ApprovalRecord record2 = new ApprovalRecord();
        record2.setApprovalRecordId(SnowFlakeUtil.getDefaultSnowFlakeId() + "");
        record2.setCorpId(corpId);
        record2.setApprovalInfoId(info.getApprovalInfoId());
        record2.setFormId(param.getFormId());
        record2.setApproverUserId(userId);
        record2.setApproverTime(time);
        record2.setApproverOpinions(param.getMessage());
        record2.setApproverResult(param.getType());
        if (ObjectUtil.isNotEmpty(param.getAccessoryUrl())) {
            record2.setAccessoryUrl(JSONUtil.toJsonStr(param.getAccessoryUrl()));
        }
        record2.setApproverNode(currentNode.byteValue());
        record2.setApproverCount(new Byte(count + ""));
        approvalRecordMapper.insertSelective(record2);
        // 获取当前节点配置
        ApprovalConfig currentConfig = configMap.get(currentNode);
        if (currentConfig.getApprovalType() == 1) {// 1会签
            // 判断是否是最后一个审批的,如果不是return出去
            List<String> userIds = null;
            if (currentConfig.getCurrentNodeApproverType() == 2) {
                // 角色id
                // 查询自己拥有那些角色
                List<UserRole> userRoles = userRoleMapper.selectList(new QueryWrapper<UserRole>().eq("user_id", userId)
                        .eq("corp_id", corpId).select("user_id"));
                userIds = userRoles.stream().map(key -> key.getUserId()).collect(Collectors.toList());
            } else if (currentConfig.getCurrentNodeApproverType()==3){
                // 用户ID
                userIds = JSONUtil.toList(currentConfig.getCurrentNodeApprover().toString(), String.class);
            } else if (currentConfig.getCurrentNodeApproverType() == 1) {
                // 发起人自己
                userIds = Arrays.asList(info.getFounder());
            }
            // 查询已经审批的人!=待审批人数则不是最后一个人
            // 1.查询已经审批的人数
            Integer count1 = approvalRecordMapper.selectCount(new QueryWrapper<ApprovalRecord>().eq("corp_id", corpId).eq("approval_info_id", info.getApprovalInfoId())
                    .eq("form_id", param.getFormId()).eq("approver_node", currentNode).eq("approver_count", count));
            if (userIds.size() != count1) {
                return;// 不是最后一个可以退出
            }
        }
        Integer nextNode = currentNode + 1;
        // 更新流程信息
        info.setProcessProgress(nextNode);
        info.setRecordNodeHistory(info.getRecordNodeHistory() + "," + info.getProcessProgress());
        // info.setCurrentState(2);
        // 到这里如果不是或签,就是会签是最后一个人同意可以判断进入下一个节点
        //  判断下一个节点是不是最后一个节点,如果是可以结束节点了,不是则继续往下递归
        if ((configMap.keySet().size() - 1) == nextNode) {
            info.setEndTime(time);
            info.setEndState(true);//  结束流程
            approvalInfoMapper.updateByPrimaryKeySelective(info);
            // 数据状态变成生效
            String formCode = fromConfigMapper.findFormCode(corpId, param.getFormId());
            commonMapper.updateDataState(formCode, 2, objectId, corpId);
            return;
        }
        approvalInfoMapper.updateByPrimaryKeySelective(info);


        // 校验下一个配置是否需要审批
        ApprovalConfig nextConfig = configMap.get(nextNode);// 下一个节点的配置

        List<RuleVO> rule = JSONUtil.toList(JSONUtil.parseArray(nextConfig.getVisibleFields()), RuleVO.class);
        for (RuleVO ruleVO : rule) {
            if (ruleVO.getKx()) {
                return;// 判断是否开了可写,如果开了可写,不管有没有开相同审批人自动通过,都不能往下走
            }
        }

        if (nextConfig.getApprovalAutoPass()) {
            // 开了 审批人员相同自动通过
            // 1.是否需要自己审批
            if (nextConfig.getCurrentNodeApproverType() == 2) {
                // 角色id
                // 查询自己拥有那些角色
                List<UserRole> userRoles = userRoleMapper.selectList(new QueryWrapper<UserRole>().eq("user_id", userId).eq("corp_id", corpId).select("role_id"));
                List<String> roleIds = userRoles.stream().map(key -> key.getRoleId()).collect(Collectors.toList());
                List<Integer> currentNodeApproverRoleId = JSONUtil.toList(nextConfig.getCurrentNodeApprover().toString(), Integer.class);
                ArrayList<String> integers = new ArrayList<>(roleIds);
                boolean b = integers.retainAll(currentNodeApproverRoleId);// 存在交集返回true
                if (!b) return;
            } else {
                // 用户ID
                List<String> currentNodeApproverUserId = JSONUtil.toList(nextConfig.getCurrentNodeApprover().toString(), String.class);
                boolean contains = currentNodeApproverUserId.contains(userId);
                if (!contains) return;
            }
            // 需要自己审批
            approvalAgreeing(nextNode, info, configMap, param, userId, corpId, time, objectId);
        }
        // approvalRecordMapper.insertSelective(record2);

    }

 合并权限(如果最后一个节点存在多个自定义权限组,就需要合并)

/**
     * 合并权限组
     *
     * @param roleIds      当前用户拥有的角色
     * @param dbPowerGroup 自定义权限组
     */
    private List<RuleVO> mergePowerGroup(List<String> roleIds, List<PowerGroup> dbPowerGroup) {
        List<RuleVO> result = new ArrayList<>();
        // 判断当前自定义权限组是否包含 当前用户的角色
        for (PowerGroup power : dbPowerGroup) {
            List<Integer> dbRoleIds = JSONUtil.toList(power.getRoleId().toString(), Integer.class);
            List<String> retainAll = new ArrayList<>(roleIds);
            retainAll.retainAll(dbRoleIds);
            if (retainAll.size() != 0) {// 存在交集,证明这个自定义权限组有当前操作用户
                List<RuleVO> rule = JSONUtil.toList(JSONUtil.parseArray(power.getVisibleFields()), RuleVO.class);
                Map<String, RuleVO> tempMapDB = rule.stream().collect(Collectors.toMap(ruleVo -> ruleVo.getChildren() + ruleVo.getField(), RuleVO -> RuleVO));
                if (CollUtil.isEmpty(result)) {
                    result = rule;
                } else {
                    Map<String, RuleVO> tempListMap = result.stream().collect(Collectors.toMap(ruleVo -> ruleVo.getChildren() + ruleVo.getField(), RuleVO -> RuleVO));
                    if (tempMapDB.keySet().size() > result.size()) {// 如果B权限组字段比A权限组多,就拿多的一方进行循环
                        for (RuleVO item : rule) {
                            RuleVO ruleVO = tempListMap.get(item.getChildren() + item.getField());
                            if (ruleVO.getBt()) {
                                item.setBt(ruleVO.getBt());
                            }
                            if (ruleVO.getKj()) {
                                item.setKj(ruleVO.getKj());
                            }
                            if (ruleVO.getKx()) {
                                item.setKx(ruleVO.getKx());
                            }
                        }
                        result = rule;
                    } else {
                        // 否则就拿A权限组遍历
                        for (RuleVO item : result) {
                            // 合并组成新的规则,如果A规则为true,B规则为false,则取true的一方
                            RuleVO ruleDB = tempMapDB.get(item.getChildren() + item.getField());
                            if (ruleDB.getBt()) {
                                item.setBt(ruleDB.getBt());
                            }
                            if (ruleDB.getKj()) {
                                item.setKj(ruleDB.getKj());
                            }
                            if (ruleDB.getKx()) {
                                item.setKx(ruleDB.getKx());
                            }
                        }
                    }
                }

            }
        }
        return result;
    }

小影~
关注
  • 41
    点赞
  • 踩
  • 161
    收藏
    觉得还不错? 一键收藏
  • 33
    评论
java源码流程审批-ydl-workflow:包含流程定义，发布，任务审批，扩展监听通知，静态表单，流程自定义，驳回，退回，会签等功能
06-05
java源码流程审批 workflow V1.0 ydl-workflow基于SAAS服务,完美整合springboot + activiti5 + MyBatis 通用 Mapper + 分页插件 PageInfo! 说明 本项目 fork 自 的 ！ 项目引入了下面依赖： org.activiti activiti-spring-boot-starter-basic 5.22.0 # 扩展说明 1. 增加了审批配置，业务表单，审批抄送人，操作流程等扩展表 2 支持流程会签，驳回，消息通知审批人 3 生成了节点实体类，支持用户原生生成流程定义 4 支持扩展用户自定义流程 ## 功能简介 1. 流程定义 2. 流程发布 3. 流程审批 4. 流程驳回 5. 查询待办任务 6. 查询审批历史 7. 查询流程定义 ### 如何启动项目 workflow目前支持三种启动方式: 1. 在IDE里运行App
java-设计模式-状态模式-模拟审批流程-二级审批 完整代码
12-31
博客地址：https://blog.csdn.net/xiaoluo5238/article/details/104592927 完整的代码，就是包名需要注意一下
企业级 OA 多级审批流程设计、实现方案（细节满满）
最新发布
犬小哈
06-08 295
来源：blog.csdn.net/cslx5zx5/article/details/107566070???? 欢迎加入小哈的星球，你将获得:专属的项目实战 / Java 学习路线 /一对一提问 / 学习打卡 / 每月赠书新项目:仿小红书(微服务架构)正在更新中... , 全栈前后端分离博客项目 2.0 版本完结啦，演示链接：http://116.62.199.48/。全程手摸手，后端 + ...
流程审批管理系统源代码
10-20
权限管理，流程审批系统，实现了网上流程的审批。
activity审核节点任务（签领、完成任务、跳过节点、新增节点、设置委托人）
weixin_43830468的博客
05-06 3537
activity审核节点任务（签领、完成任务、跳过节点、新增节点、设置委托人）
- java实现审核流程
coolitor的博客
02-02 5691
【代码】- java实现审核流程。
Java 与 MySQL 的绝妙结合：打造高效审批流程
犬小哈
12-24 113
来源：blog.csdn.net/weixin_46522803/article/details/131377730???? 欢迎加入小哈的星球，你将获得:专属的项目实战 / Java 学习路线 /一对一提问 / 学习打卡/ 赠书福利全栈前后端分离博客项目 1.0 版本完结啦，2.0 正在更新中...,演示链接：http://116.62.199.48/，全程手摸手，后端 + 前端全栈开发，...
（附源码）springboot+mysql+基于Java的学生请销假审批管理系统的设计与实现 毕业设计130939
Weixin_CXSJ881的博客
03-01 1108
本设计主要实现集人性化、高效率、便捷等优点于一身的学生请假审批管理系统，完成首页、用户管理、公告通知、请假申请、请假审批等功能模块。系统通过浏览器与服务器进行通信，实现数据的交互与变更。本系统通过科学的管理方式、便捷的服务提高了工作效率，减少了数据存储上的错误和遗漏。学生请假审批管理系统使用Java语言，采用基于 MVVM模式的spring boot技术进行开发，使用 Eclipse 2017 CI 10 编译器编写，数据方面主要采用的是微软的Mysql数据库来作为数据存储媒介，配合前台HTML+CSS
Springboot企业报销审批系统设计与实现 计算机毕设源码44362
VX_ZYKJ985的博客
06-30 817
个人报销（报销单号、员工工号、员工姓名、部门、职位、报销名称、规格、单价、报销数量、报销金额、发票附件、用途）。 专项购买报销（专项报销编号、报销标题、员工工号、员工姓名、部门、职位、商品、数量、支出类型、总支出、用途、发票附件）。 个报主管审批（报销单号、员工工号、员工姓名、部门、职位、报销名称、规格、单价、报销数量、报销金额、发票附件、用途、主管工号、主管姓名、主管职位、主管审批、主管审批意见）。 个报财务审批（报销单号、员工工号、员工姓名、部门、职位、报销名称、规格、单价、报销数量、报销金额.....
Java基于Java技术的工作流0A审批系统(源码+mysql+文档)
卢卡毕设程序
01-08 683
通过友好的用户界面和交互设计，用户可以方便地使用系统进行审批操作，提高了用户的满意度和忠诚度。• 在这种开发技术模式下，系统的开发流程主要是前端专注于使用Vue.js构建动态和响应式的用户界面，同时通过Ajax技术与后端进行数据交换，实现了前后端的逻辑分离。后端SSM框架结合了Spring的依赖注入和事务管理、SpringMVC的模型-视图-控制器架构以及MyBatis的数据持久化功能，为后端开发提供全面的支持。随着企业对于工作流程管理的不断需求，该系统的开发将会得到广泛的应用和推广。
MySQL.rar_java与mysql
09-21
将Java与MySQL结合使用，可以构建高效、可扩展的数据驱动的应用程序。下面我们将深入探讨Java与MySQL的相关知识点。 1. **Java数据库连接（JDBC）**： JDBC是Java中用于访问数据库的标准API，它提供了与各种数据库...
JAVA+MySQL学生成绩管理系统
12-08
总的来说，"JAVA+MySQL学生成绩管理系统"结合了JAVA的编程优势和MySQL的数据管理能力，为学校提供了一个实用且高效的工具，简化了成绩管理流程，提高了工作效率。对于学习者来说，理解并掌握这种系统的开发，不仅...
mysql-connector-java.zip 两个版本：5.1.47、8.0.28
06-29
java连接mysql数据库的驱动，里边包含两个版本：5.1.47、8.0.28 也可从以下两个地址免费下载： 1. https://repo1.maven.org/maven2/mysql/mysql-connector-java/ 2. ...
java-mysql-example:显示如何连接到 MySQL 的示例项目
05-30
JavaMysql示例 这是一个示例项目，展示了如何在 Maven 项目中连接到 MySQL。 构建项目。 mvn clean install 运行程序。 java -jar target/java-mysql-example-1.0-SNAPSHOT.jar
基于java高校在线请假与审批系统设计与实现.docx
08-10
基于 Java 高校在线请假与审批系统设计与实现 在高等教育的不断发展中，高校学生请假管理系统的重要性日益凸显。传统的请假方式效率低下，增加了学生和教师的负担，且无法实时掌握学生的请假信息。为解决该问题，...
Java设计模式：使用责任链模式和状态模式优化‘审批流程‘
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
04-26 1万+
在现代软件开发过程中，动态审核流程是确保数据质量和流程合规性的关键环节。本文将深入探讨一种链式处理模式，通过详实的代码示例和理论分析，展示如何高效构建一个灵活的审核流程。关键词：动态审核流程，链式处理模式，Java实现。链式处理模式（Chain of Responsibility）是一种常用的设计模式，通过将请求的发送者和接收者解耦，让多个对象都有机会处理这个请求。在本案例中，我们将使用Java语言演示一个简单的发布审核流程，其中包含多个审核阶段。在前两个示例中，责任链模式被用来处理一个请求的审批流程。
OA多级审批流程表设计方案（干货满满）
芋艿V
08-19 1400
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析作业调度中间件 E...
java审批流创建及代码流程
weixin_43981261的博客
07-11 1万+
工具：使用idea和安装activity插件 教程可以网上有 /** * 新增一个你的申请 */ @PostMapping public AjaxResult add(@RequestBody 你的申请类 对象 ) { logger.info(JSON.toJSONString(对象)); Long userid = getUserId(); 对象.setUserId(userid); //审批编号 Date dt = new Date(); S
mysql:mysql-connector-java:pom:8.0.28
09-01
mysql-connector-java:pom:8.0.28是MySQL官方提供的Java驱动程序，用于Java应用程序与MySQL数据库进行连接和交互。 MySQL是一个开源的数据库管理系统，被广泛应用于各种类型的应用程序中。在Java开发中，为了能够连接MySQL数据库并进行数据的读写操作，需要使用合适的驱动程序。 mysql-connector-java:pom:8.0.28是一个Maven坐标，表示了MySQL官方提供的8.0.28版本的Java驱动程序。 为了在Java项目中使用该驱动程序，我们可以通过Maven或者手动下载并导入相关的jar包。在Maven中，可以在pom.xml文件中添加如下依赖项： <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.28</version> </dependency> 这样，当我们构建项目时，Maven会自动下载并导入相关的jar包到项目中。 使用mysql-connector-java:pom:8.0.28可以实现Java应用程序与MySQL数据库的连接，包括连接数据库、执行SQL语句、读取查询结果等操作。通过该驱动程序，我们可以方便地使用Java语言对MySQL数据库进行数据的增删改查。 总结来说，mysql-connector-java:pom:8.0.28是MySQL官方提供的Java驱动程序，用于在Java应用程序中连接和交互MySQL数据库。
评论 33
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值