xuhy
2025-02-28 65c8ab3edc7001ff4a2d392039e30907f8effdbb
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
package com.ruoyi.system.service.impl;
 
 
import cn.hutool.core.util.ObjectUtil;
import com.aizuda.bpm.engine.FlowLongEngine;
import com.aizuda.bpm.engine.assist.ObjectUtils;
import com.aizuda.bpm.engine.core.FlowCreator;
import com.aizuda.bpm.engine.core.FlowLongContext;
import com.aizuda.bpm.engine.core.enums.EventType;
import com.aizuda.bpm.engine.core.enums.NodeApproveSelf;
import com.aizuda.bpm.engine.core.enums.NodeSetType;
import com.aizuda.bpm.engine.core.enums.TaskType;
import com.aizuda.bpm.engine.entity.FlwExtInstance;
import com.aizuda.bpm.engine.entity.FlwHisTask;
import com.aizuda.bpm.engine.entity.FlwTask;
import com.aizuda.bpm.engine.entity.FlwTaskActor;
import com.aizuda.bpm.engine.listener.TaskListener;
import com.aizuda.bpm.engine.model.NodeAssignee;
import com.aizuda.bpm.engine.model.NodeModel;
import com.aizuda.bpm.engine.model.ProcessModel;
import com.aizuda.bpm.mybatisplus.mapper.FlwExtInstanceMapper;
import com.aizuda.bpm.mybatisplus.mapper.FlwHisTaskMapper;
import com.aizuda.bpm.mybatisplus.mapper.FlwTaskActorMapper;
import com.aizuda.bpm.mybatisplus.mapper.FlwTaskMapper;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.google.common.collect.ImmutableMap;
import com.ruoyi.common.core.domain.entity.SysRole;
import com.ruoyi.common.enums.ProcessCategoryEnum;
import com.ruoyi.common.enums.SubmitStatusEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.system.service.ISysRoleService;
import com.ruoyi.system.service.TContractService;
import com.ruoyi.system.task.base.QuartzManager;
import com.ruoyi.system.task.base.TimeJobType;
import com.ruoyi.system.task.jobs.StateProcessJob;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
 
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.Collectors;
 
 
/**
 * 工作流程全局任务监听 同步方式  只监听流程完成、流程中断类型,修改拒绝状态
 * <p>
 * 1. 入户调查
 * 2. 价格评估
 * 3. 协议签订
 * 4. 资金管理-预算资金
 * 5. 住宅临时安置补助费
 * 6. 停产停业经济损失补助费
 * 7. 安置情况(流程图中叫做录入货币补偿金额信息)
 * 固定对应表 state_process_module
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class FlowListenerService implements TaskListener {
 
    private final FlwExtInstanceMapper flwExtInstanceMapper;
    private final FlowLongEngine flowLongEngine;
    private final FlwTaskActorMapper flwTaskActorMapper;
    private final FlwHisTaskMapper flwHisTaskMapper;
    private final ISysRoleService sysRoleService;
    private final FlwTaskMapper flwTaskMapper;
    private final TContractService contractService;
 
 
    @Override
    public boolean notify(EventType eventType, Supplier<FlwTask> supplier, NodeModel nodeModel, FlowCreator flowCreator) {
        FlwTask flwTask = supplier.get();
        if (ObjectUtil.isNull(flwTask)) {
            return true;
        }
        // 创建任务时候,判断是否自动审批通过
        if (EventType.create.eq(eventType)) {
            Integer approveSelf = nodeModel.getApproveSelf();
            if (NodeApproveSelf.AutoSkip.eq(approveSelf)) {
                // 普通成员情况
                List<NodeAssignee> nodeAssigneeList = null;
                if (NodeSetType.specifyMembers.eq(nodeModel.getSetType())) {
                    nodeAssigneeList = nodeModel.getNodeAssigneeList();
                    if (ObjectUtil.isEmpty(nodeAssigneeList)) {
                        return true;
                    }
                    //查询发起人
                    LambdaQueryWrapper<FlwHisTask> flwHisTaskLambdaQueryWrapper = new LambdaQueryWrapper<>();
                    flwHisTaskLambdaQueryWrapper.eq(FlwTask::getTaskType, TaskType.major.getValue());
                    flwHisTaskLambdaQueryWrapper.eq(FlwTask::getInstanceId, flwTask.getInstanceId());
                    FlwHisTask flwHisTask = flwHisTaskMapper.selectOne(flwHisTaskLambdaQueryWrapper);
                    if (ObjectUtil.isEmpty(flwHisTask)) {
                        return true;
                    }
 
                    // 添加定时任务
                    Map<String, ? extends Object> maps =
                            new ImmutableMap.Builder<String, Long>().
                                    put("id", flwTask.getId())
                                    .build();
                    QuartzManager.addJob(StateProcessJob.class, (StateProcessJob.name+flwTask.getId()).toUpperCase(), TimeJobType.AUTO_AUDIT,new Date(new Date().getTime()+60*1000L), maps);
 
 
                    //对比发起人和节点审批人
                    if (nodeAssigneeList.stream().noneMatch(t -> Objects.equals(t.getId(), flwHisTask.getCreateId()))) {
                        return true;
                    }
                    //查询当前节点审核人是否与创建人一致
                    List<FlwTaskActor> flwTaskActor = flwTaskActorMapper.selectListByTaskId(flwTask.getId());
                    if (ObjectUtil.isNotEmpty(flwTaskActor)) {
                        for (FlwTaskActor flwTaskActor1 : flwTaskActor) {
                            if (flwTaskActor1.getActorId().equals(flwHisTask.getCreateId())) {
                                return flowLongEngine.autoJumpTask(flwTask.getId(), flowCreator);
                            }
                        }
                    }
                } else if (NodeSetType.role.eq(nodeModel.getSetType())) {
                    //角色任务跳过
                    nodeAssigneeList = nodeModel.getNodeAssigneeList();
                    //获取角色下的用户
                    List<String> roleIds = nodeAssigneeList.stream().map(NodeAssignee::getId).collect(Collectors.toList());
                    List<SysRole> actorList = sysRoleService.selectRoleByUserIds(roleIds);
                    List<FlwTaskActor> flwTaskActors = new ArrayList<>();
                    if(ObjectUtils.isNotEmpty(actorList)) {
                        for (SysRole sysRole : actorList) {
                            if(ObjectUtil.isEmpty(sysRole.getRoleName())) {
                                continue;
                            }
                            NodeAssignee nodeAssignee = new NodeAssignee();
                            nodeAssignee.setId(String.valueOf(sysRole.getRoleId()));
                            nodeAssignee.setName(sysRole.getRoleName());
                            flwTaskActors.add(FlwTaskActor.of(nodeAssignee, 0));
                        }
                    }
                    if (ObjectUtil.isEmpty(flwTaskActors)) {
                        return true;
                    }
                    //查询发起人
                    LambdaQueryWrapper<FlwHisTask> flwHisTaskLambdaQueryWrapper = new LambdaQueryWrapper<>();
                    flwHisTaskLambdaQueryWrapper.eq(FlwTask::getTaskType, TaskType.major.getValue());
                    flwHisTaskLambdaQueryWrapper.eq(FlwTask::getInstanceId, flwTask.getInstanceId());
                    FlwHisTask flwHisTask = flwHisTaskMapper.selectOne(flwHisTaskLambdaQueryWrapper);
                    if (ObjectUtil.isEmpty(flwHisTask)) {
                        return true;
                    }
 
                    // 添加定时任务
                    Map<String, ? extends Object> maps =
                            new ImmutableMap.Builder<String, Long>().
                                    put("id", flwTask.getId())
                                    .build();
                    QuartzManager.addJob(StateProcessJob.class, (StateProcessJob.name+flwTask.getId()).toUpperCase(), TimeJobType.AUTO_AUDIT,new Date(new Date().getTime()+60*1000L), maps);
 
 
                    //对比发起人和节点审批人
                    if (flwTaskActors.stream().noneMatch(t -> Objects.equals(t.getActorId(), flwHisTask.getCreateId()))) {
                        return true;
                    }
                    //查询当前节点审核人是否与创建人一致
                    List<FlwTaskActor> flwTaskActor = flwTaskActorMapper.selectListByTaskId(flwTask.getId());
                    if (ObjectUtil.isNotEmpty(flwTaskActor)) {
                        for (FlwTaskActor flwTaskActor1 : flwTaskActor) {
                            if (flwTaskActor1.getActorId().equals(flwHisTask.getCreateId())) {
                                return flowLongEngine.autoJumpTask(flwTask.getId(), flowCreator);
                            }
                        }
                    }
                }
            }
        }
 
        if (eventType.equals(EventType.reject) || eventType.equals(EventType.autoReject)) {
            System.out.println("流程失败:" + flwTask.getVariable());
            handlerBusiness(flwTask.getVariable(), 2);
        } else if (eventType.equals(EventType.complete)) {
            // 查询流程模型
            FlwExtInstance flwExtInstance = flwExtInstanceMapper.selectById(flwTask.getInstanceId());
            String modelContent = flwExtInstance.getModelContent();
            ProcessModel processModel = FlowLongContext.parseProcessModel(modelContent, null, false);
            NodeModel node = processModel.getNode(flwTask.getTaskKey());
            if (ObjectUtil.isEmpty(node)) {
                log.error("节点不存在 TaskName:{} InstanceId:{}", flwTask.getTaskName(), flwTask.getInstanceId());
                return true;
            }
            long count = flwTaskMapper.selectCount(new LambdaQueryWrapper<FlwTask>().eq(FlwTask::getInstanceId,flwTask.getInstanceId()));
            if(count > 0){
                return true;
            }
            //最后一个节点
            if (ObjectUtil.isEmpty(node.getChildNode()) || ObjectUtil.isEmpty(node.getChildNode().getNodeName())) {
                System.out.println("流程完成:" + flwTask.getVariable());
                handlerBusiness(flwTask.getVariable(), 1);
            }
        } else if (eventType.eq(EventType.cc)) {
            // 查询流程模型//抄送
            FlwExtInstance flwExtInstance = flwExtInstanceMapper.selectById(flwTask.getInstanceId());
            String modelContent = flwExtInstance.getModelContent();
            ProcessModel processModel = FlowLongContext.parseProcessModel(modelContent, null, false);
            NodeModel node = processModel.getNode(flwTask.getTaskKey());
            if (ObjectUtil.isEmpty(node)) {
                log.error("节点不存在 TaskName:{} InstanceId:{}", flwTask.getTaskName(), flwTask.getInstanceId());
                return true;
            }
            //抄送是最后一个节点
            if (ObjectUtil.isEmpty(node.getChildNode()) || ObjectUtil.isEmpty(node.getChildNode().getNodeName())) {
                System.out.println("流程完成:" + flwTask.getVariable());
                handlerBusiness(flwTask.getVariable(), 1);
            }
        } else if(eventType.eq(EventType.autoJump)){
            // 查询流程模型 自动跳转
            FlwExtInstance flwExtInstance = flwExtInstanceMapper.selectById(flwTask.getInstanceId());
            String modelContent = flwExtInstance.getModelContent();
            ProcessModel processModel = FlowLongContext.parseProcessModel(modelContent, null, false);
            NodeModel node = processModel.getNode(flwTask.getTaskKey());
            if (ObjectUtil.isEmpty(node)) {
                log.error("节点不存在 TaskName:{} InstanceId:{}", flwTask.getTaskName(), flwTask.getInstanceId());
                return true;
            }
            long count = flwTaskMapper.selectCount(new LambdaQueryWrapper<FlwTask>().eq(FlwTask::getInstanceId,flwTask.getInstanceId()));
            if(count > 0){
                return true;
            }
            //最后一个节点
            if (ObjectUtil.isEmpty(node.getChildNode()) || ObjectUtil.isEmpty(node.getChildNode().getNodeName())) {
                System.out.println("流程完成:" + flwTask.getVariable());
                handlerBusiness(flwTask.getVariable(), 1);
            }
        }
        return true;
    }
 
    /**
     * 业务状态变更
     */
    private void handlerBusiness(String variable, Integer status) {
        JSONObject processParameter = JSON.parseObject(variable);
        //必须参数,肯定有不判断null
        Integer category = processParameter.getInteger("category");
        //状态 暂定:0待审核 1审核通过 2审核拒绝
        ProcessCategoryEnum categoryEnum = ProcessCategoryEnum.getEnumByKey(category);
        switch (categoryEnum) {
            case CATEGORY1: {
                // 合同新增审批
                int submitStatus = status==0?2:(status==1?3:5);
                contractService.updateContractAuditStatus(processParameter.getString("projectId"), submitStatus);
                // TODO 发短信
                break;
            }
            case CATEGORY2: {
                // 合同签订审批
                int submitStatus = status==0?3:(status==1?4:5);
                contractService.updateContractAuditStatus(processParameter.getString("projectId"), submitStatus);
                break;
            }
            case CATEGORY3: {
                // 合同提前终止审批
                int submitStatus = status==0?4:(status==1?6:5);
                contractService.updateContractAuditStatus(processParameter.getString("projectId"), submitStatus);
                break;
            }
            default:
                throw new ServiceException("错误类型");
        }
 
    }
 
}