This commit is contained in:
=
2026-04-11 16:42:03 +08:00
32 changed files with 1560 additions and 892 deletions
@@ -27,10 +27,10 @@ import java.util.Map;
@IocBean
public class SmsJshvcServiceImpl implements SmsService {
private static final String APPID = "1430576717768122368";
private static final String APP_SECRET = "19A0ACB03FBQHL4R4XQD";
private static final String TOKEN_URL = "https://gateway.jshvc.edu.cn/token/gateway/accessToken";
private static final String MSG_URL = "https://gateway.jshvc.edu.cn/mp/restful/v2/message/send";
private static final String APPID = "";
private static final String APP_SECRET = "";
private static final String TOKEN_URL = "";
private static final String MSG_URL = "";
private static final String REDIS_KEY_MSG_ACCESS_TOKEN = "msg:token:";
@Inject
@@ -9,6 +9,7 @@ import com.budwk.app.flow.enums.ProcessTaskStateEnum;
import com.budwk.app.web.commons.auth.utils.AuthUtil;
import com.budwk.app.web.commons.auth.utils.SecurityUtil;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalSearchParam;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalCaseCheckService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
@@ -39,6 +40,8 @@ public class ProposalCaseCheckController {
@Inject
private BaseService baseService;
@Inject
private ProposalCaseCheckService proposalCaseCheckService;
@At("")
@Ok("beetl:/platform/zhgh/democratic/proposal/transact/caseCheck/index.html")
@@ -103,4 +106,11 @@ public class ProposalCaseCheckController {
Pagination pagination = baseService.listPageMap(pageForm.getPageNumber(),pageForm.getPageSize(), sql);
return Result.success(pagination);
}
@At
@SaCheckPermission("proposal.caseCheck")
@ApiOperation("查询当前提案承办单位")
public Result listReplyUnits(String proposalId) {
return Result.success(proposalCaseCheckService.listReplyUnits(proposalId));
}
}
@@ -5,12 +5,9 @@ import cn.hutool.core.lang.Dict;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.page.Pagination;
import com.budwk.app.base.result.Result;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.enums.ProcessTaskStateEnum;
import com.budwk.app.flow.service.FlowCommonService;
import com.budwk.app.web.commons.auth.utils.AuthUtil;
import com.budwk.app.web.commons.auth.utils.SecurityUtil;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalMerge;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalSearchParam;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalCommitteeFilingService;
import io.swagger.annotations.Api;
@@ -25,7 +22,6 @@ import org.nutz.ioc.aop.Aop;
import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.json.Json;
import org.nutz.lang.random.R;
import org.nutz.mvc.annotation.At;
import org.nutz.mvc.annotation.Ok;
import org.nutz.mvc.annotation.Param;
@@ -44,9 +40,6 @@ public class ProposalCommitteeFilingController {
private Dao dao;
@Inject
private ProposalCommitteeFilingService proposalCommitteeFilingService;
@Inject
private FlowCommonService flowCommonService;
@At("")
@Ok("beetl:/platform/zhgh/democratic/proposal/transact/committeeFiling/index.html")
@@ -118,27 +111,16 @@ public class ProposalCommitteeFilingController {
@Aop(TransAop.READ_COMMITTED)
public Result merge(@Param("data") String data) {
Dict args = Json.fromJson(Dict.class, data);
proposalCommitteeFilingService.merge(args);
return Result.success();
}
List<Integer> taskIds = (List<Integer>) args.get("processTaskIds");
List<String> proposalIds = (List<String>) args.get("proposalIds");
// 记录提案并案
dao.clear(ProposalMerge.class, Cnd.where(ProposalMerge::getProposalId, "in", proposalIds));
String groupId = R.UU32();
List<ProposalMerge> merges = proposalIds.stream().map(proposalId -> {
ProposalMerge merge = new ProposalMerge();
merge.setProposalId(proposalId);
merge.setGroupId(groupId);
return merge;
}).toList();
dao.insert(merges);
for (Integer taskId : taskIds) {
Dict taskArgs = args.clone();
taskArgs.put(FlowConst.PROCESS_TASK_ID_KEY, taskId);
flowCommonService.executeTask(taskArgs);
}
@At
@SaCheckPermission("proposal.committeeFiling")
@ApiOperation("撤回任务")
@Aop(TransAop.READ_COMMITTED)
public Result revokeTask(@Param("taskId") Long taskId, @Param("proposalId") String proposalId) {
proposalCommitteeFilingService.revokeTask(taskId, proposalId);
return Result.success();
}
@@ -8,7 +8,6 @@ import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.page.Pagination;
import com.budwk.app.base.result.Result;
import com.budwk.app.base.service.BaseService;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.entity.ProcessInstance;
import com.budwk.app.flow.entity.ProcessTask;
import com.budwk.app.flow.entity.ProcessTaskActor;
@@ -128,28 +127,7 @@ public class ProposalCommitteeFilingUnitController {
@Aop(TransAop.READ_COMMITTED)
public Result executeTask(@Param("data") String data) {
Dict args = Json.fromJson(Dict.class, data);
String proposalId = args.getStr("proposalId");
// 查询是否提案
// 单条审核
List<String> mergeProposalIds = proposalCommonService.mergeProposal(proposalId);
if (ObjectUtil.isEmpty(mergeProposalIds)) {
flowCommonService.executeTask(args);
return Result.success();
}
// 并案审核
ProcessTask thisTask = baseService.dao().fetch(ProcessTask.class, args.getLong(FlowConst.PROCESS_TASK_ID_KEY));
List<ProcessTask> mergeTasks = processTaskService.getDoingTaskByBizIdTaskName(mergeProposalIds, thisTask.getTaskName());
for (ProcessTask mergeTask : mergeTasks) {
Dict cloneArgs = args.clone();
cloneArgs.put(FlowConst.PROCESS_TASK_ID_KEY, mergeTask.getId());
flowCommonService.executeTask(cloneArgs);
}
ProposalInfo info = proposalCommonService.fetch(proposalId);
info.setCaseFilingResult(args.getStr("caseFilingResult"));
proposalCommitteeFilingUnitService.executeFlowTask(args);
return Result.success();
}
@@ -3,6 +3,7 @@ package com.budwk.app.zhgh.democratic.proposal.controller.transact;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.page.Pagination;
@@ -23,10 +24,12 @@ import com.budwk.app.zhgh.democratic.proposal.service.common.ProposalCommonServi
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.nutz.aop.interceptor.ioc.TransAop;
import org.nutz.dao.Cnd;
import org.nutz.dao.Dao;
import org.nutz.dao.Sqls;
import org.nutz.dao.sql.Sql;
import org.nutz.ioc.aop.Aop;
import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.json.Json;
@@ -35,6 +38,7 @@ import org.nutz.mvc.annotation.Ok;
import org.nutz.mvc.annotation.Param;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.List;
@IocBean
@@ -95,6 +99,8 @@ public class ProposalSchoolLeaderApprovalController {
t.finishTime,
t.taskParentId,
t.variable taskVariable,
GROUP_CONCAT(DISTINCT CASE WHEN pru.isMaster = 1 THEN pru.unitName END) AS masterUnitName,
GROUP_CONCAT(DISTINCT CASE WHEN pru.isMaster = 0 THEN pru.unitName END) AS slaveUnitNames,
IFNULL(GROUP_CONCAT(DISTINCT nt.displayName),'结束') curTaskName,
IF(rt.id IS NOT NULL, 1, 0) AS canRevoke,
GROUP_CONCAT(DISTINCT ta.actorName, '(', ta.actorAccount, ')' ) AS auditUser
@@ -107,6 +113,7 @@ public class ProposalSchoolLeaderApprovalController {
LEFT JOIN proposal_info info ON info.id = ins.businessNo
LEFT JOIN proposal_type type on type.id = info.typeId
LEFT JOIN proposal_merge mer ON mer.proposalId = info.id
LEFT JOIN proposal_reply_unit pru ON pru.proposalId = info.id
LEFT JOIN teacher_congress_session tcs on tcs.id = info.sessionId
LEFT JOIN teacher_congress_delegation tcd on tcd.id = info.delegationId
$condition
@@ -142,6 +149,7 @@ public class ProposalSchoolLeaderApprovalController {
@At
@SaCheckPermission("proposal.schoolLeaderApproval")
@ApiOperation("执行任务")
@Aop(TransAop.READ_COMMITTED)
public Result executeTask(@Param("data") String data) {
Dict args = Json.fromJson(Dict.class, data);
@@ -156,18 +164,34 @@ public class ProposalSchoolLeaderApprovalController {
ProcessTask thisTask = dao.fetch(ProcessTask.class, args.getLong(FlowConst.PROCESS_TASK_ID_KEY));
ProcessTask parentTask = dao.fetch(ProcessTask.class, Cnd.where("id", "=", thisTask.getTaskParentId()));
Dict dict = Json.fromJson(Dict.class, parentTask.getVariable());
args.put("tf_caseFilingResult", dict.getStr("tf_caseFilingResult"));
args.put("tf_helpunitreply", dict.getStr("tf_helpunitreply"));
args.put("tf_masterUnitId", dict.getStr("tf_masterUnitId"));
args.put("tf_slaveUnitIds", dict.getObj("tf_slaveUnitIds"));
Dict dict = ObjectUtil.defaultIfNull(Json.fromJson(Dict.class, parentTask.getVariable()), Dict.create());
ProcessInstance instance = dao.fetch(ProcessInstance.class, Cnd.where(ProcessInstance::getId, "=", thisTask.getProcessInstanceId()));
Dict instanceDict = Json.fromJson(Dict.class, instance.getVariable());
instanceDict.put("tf_helpunitreply", dict.getStr("tf_helpunitreply"));
instanceDict.put("tf_masterUnitId", dict.getStr("tf_masterUnitId"));
instanceDict.put("tf_slaveUnitIds", dict.getObj("tf_slaveUnitIds"));
Dict instanceDict = ObjectUtil.defaultIfNull(Json.fromJson(Dict.class, instance.getVariable()), Dict.create());
// 分管领导审批需要把提委会立案环节的承办单位信息继续透传,兼容主办单位由单个改为多个的场景。
Object masterUnitIds = getProcessVariable(dict, instanceDict, "tf_masterUnitIds");
String masterUnitId = getProcessVariableStr(dict, instanceDict, "tf_masterUnitId");
if (ObjectUtil.isEmpty(masterUnitIds) && StrUtil.isNotBlank(masterUnitId)) {
masterUnitIds = List.of(masterUnitId);
}
if (StrUtil.isBlank(masterUnitId)) {
List<String> masterUnitIdList = toStringList(masterUnitIds);
if (ObjectUtil.isNotEmpty(masterUnitIdList)) {
masterUnitId = masterUnitIdList.get(0);
}
}
args.put("tf_caseFilingResult", getProcessVariableStr(dict, instanceDict, "tf_caseFilingResult"));
args.put("tf_helpunitreply", getProcessVariableStr(dict, instanceDict, "tf_helpunitreply"));
args.put("tf_masterUnitId", masterUnitId);
args.put("tf_masterUnitIds", masterUnitIds);
args.put("tf_slaveUnitIds", getProcessVariable(dict, instanceDict, "tf_slaveUnitIds"));
instanceDict.put("tf_helpunitreply", getProcessVariableStr(dict, instanceDict, "tf_helpunitreply"));
instanceDict.put("tf_masterUnitId", masterUnitId);
instanceDict.put("tf_masterUnitIds", masterUnitIds);
instanceDict.put("tf_slaveUnitIds", getProcessVariable(dict, instanceDict, "tf_slaveUnitIds"));
instance.setVariable(JSONUtil.toJsonStr(instanceDict));
dao.update(instance);
@@ -190,4 +214,55 @@ public class ProposalSchoolLeaderApprovalController {
}
return Result.success();
}
/**
* 优先取当前父任务变量,没有时回退到流程实例变量,避免审批流转时丢失承办单位信息。
*/
private Object getProcessVariable(Dict taskDict, Dict instanceDict, String key) {
Object taskValue = taskDict.getObj(key);
if (ObjectUtil.isNotEmpty(taskValue)) {
return taskValue;
}
return instanceDict.getObj(key);
}
/**
* 字符串类型流程变量统一做空值兼容,便于兼容老流程里单主办字段的读取。
*/
private String getProcessVariableStr(Dict taskDict, Dict instanceDict, String key) {
Object value = getProcessVariable(taskDict, instanceDict, key);
return ObjectUtil.isEmpty(value) ? "" : String.valueOf(value);
}
/**
* 主办单位可能以集合、数组、JSON 字符串或逗号分隔字符串保存,这里统一转换为字符串列表。
*/
private List<String> toStringList(Object value) {
if (ObjectUtil.isEmpty(value)) {
return List.of();
}
if (value instanceof List<?> list) {
return list.stream().filter(ObjectUtil::isNotEmpty).map(String::valueOf).toList();
}
if (value instanceof Object[] array) {
List<String> result = new ArrayList<>();
for (Object item : array) {
if (ObjectUtil.isNotEmpty(item)) {
result.add(String.valueOf(item));
}
}
return result;
}
if (value instanceof String strValue) {
if (StrUtil.isBlank(strValue)) {
return List.of();
}
if (JSONUtil.isTypeJSONArray(strValue)) {
return JSONUtil.parseArray(strValue).toList(String.class);
}
return StrUtil.splitTrim(strValue, ",");
}
return List.of(String.valueOf(value));
}
}
@@ -6,10 +6,8 @@ import cn.hutool.core.util.ObjectUtil;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.page.Pagination;
import com.budwk.app.base.result.Result;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.entity.ProcessTask;
import com.budwk.app.flow.enums.ProcessTaskStateEnum;
import com.budwk.app.flow.service.FlowCommonService;
import com.budwk.app.flow.service.ProcessTaskService;
import com.budwk.app.sys.models.Sys_role;
import com.budwk.app.sys.models.Sys_user_role;
@@ -18,6 +16,7 @@ import com.budwk.app.sys.services.SysUserService;
import com.budwk.app.web.commons.auth.utils.AuthUtil;
import com.budwk.app.web.commons.auth.utils.SecurityUtil;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalSearchParam;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalUnderTakeReplyService;
import com.budwk.app.zhgh.democratic.proposal.service.common.ProposalCommonService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
@@ -38,6 +37,8 @@ import org.nutz.mvc.annotation.Ok;
import org.nutz.mvc.annotation.Param;
import javax.validation.Valid;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.util.List;
import java.util.stream.Stream;
@@ -53,7 +54,7 @@ public class ProposalUnderTakeReplyController {
@Inject
private ProposalCommonService proposalCommonService;
@Inject
private FlowCommonService flowCommonService;
private ProposalUnderTakeReplyService proposalUnderTakeReplyService;
@Inject
private ProcessTaskService processTaskService;
@Inject
@@ -77,6 +78,11 @@ public class ProposalUnderTakeReplyController {
@SaCheckPermission("proposal.unitReply")
@ApiOperation("分页列表")
public Result pageData(@Valid ProposalSearchParam pageForm, boolean approval, boolean transfer) {
/*
* 承办单位答复列表需要按“承办单位”维度展示。
* 同一个任务可能挂了多个承办单位负责人,若只按 taskId 分组会把多条待审核合并成一条,
* 因此这里优先使用任务参与人的承办单位信息拆行,历史数据缺失时再回退到流程变量。
*/
Sql sql = Sqls.create("""
SELECT
info.*,
@@ -121,10 +127,11 @@ public class ProposalUnderTakeReplyController {
$condition
""");
Cnd cnd = Cnd.NEW();
cnd.and("t.taskName", "in", List.of("master_reply", "slave_reply", "opinion_master_reply"));
// cnd.and("t.taskName", "in", List.of("master_reply", "slave_reply", "opinion_master_reply"));
cnd.and("t.taskName", "in", List.of("unit_reply", "two_unit_reply", "opinion_unit_reply"));
if (!AuthUtil.hasRole(RoleConstant.SYSADMIN.name())) {
cnd.and("ta.actorId", "in", List.of(SecurityUtil.getUserId()));
if (!SecurityUtil.getUserLoginname().equals("superadmin")) {
cnd.and("ta.actorId", "=", SecurityUtil.getUserId());
}
if (approval) {
@@ -140,45 +147,85 @@ public class ProposalUnderTakeReplyController {
List<NutMap> list = pagination.getList();
for (NutMap row : list) {
if (row.getInt("taskIsMaster") == 1) {
boolean b = Stream.of("master_reply", "slave_reply", "school_leader")
.anyMatch(a -> row.getString("curTaskKey").contains(a));
row.setv("canRevoke", b && row.getInt("taskState") == ProcessTaskStateEnum.FINISHED.getCode());
} else {
boolean b = Stream.of("master_reply", "slave_reply").anyMatch(a -> row.getString("curTaskKey").contains(a));
row.setv("canRevoke", b && row.getInt("taskState") == ProcessTaskStateEnum.FINISHED.getCode());
}
/*
* 承办单位答复撤回必须按“当前整组待办节点”统一判断。
* 这里不能再用 contains,只要出现过 unit_reply/two_unit_reply 就会误判可撤回;
* 正确规则是:curTaskKey 必须精确等于某一个允许撤回的节点编码,
* 像 unit_reply,two_unit_reply 这种混合状态一律不允许撤回。
*/
row.setv("canRevoke", isReplyTaskGroupRevocable(row));
}
pagination.setList(list);
return Result.success(pagination);
}
/**
* 承办单位答复节点撤回需要基于整组当前节点判断。
* 只有“当前流程正在办理的节点”和“这条列表记录所属节点”完全一致时,才允许撤回;
* 这样流程已经从 unit_reply 走到 two_unit_reply 后,历史 unit_reply 记录会自动失去撤回资格。
* 主办只能撤回 unit_reply、two_unit_reply、school_leader
* 协办只能撤回 unit_reply、two_unit_reply。
*/
private boolean isReplyTaskGroupRevocable(NutMap row) {
if (!ObjectUtil.equal(row.getInt("taskState"), ProcessTaskStateEnum.FINISHED.getCode())) {
return false;
}
String taskKey = row.getString("taskKey");
String curTaskKey = row.getString("curTaskKey");
if (!ObjectUtil.equal(taskKey, curTaskKey)) {
return false;
}
if (row.getInt("underTakeIsMaster") == 1) {
return Stream.of("unit_reply", "two_unit_reply", "school_leader")
.anyMatch(a -> ObjectUtil.equal(a, taskKey));
}
return Stream.of("unit_reply", "two_unit_reply")
.anyMatch(a -> ObjectUtil.equal(a, taskKey));
}
@At
@Aop(TransAop.READ_COMMITTED)
@SaCheckPermission("proposal.unitReply")
@ApiOperation("执行任务")
public Result executeTask(@Param("data") String data) {
Dict args = Json.fromJson(Dict.class, data);
String proposalId = args.getStr("proposalId");
proposalUnderTakeReplyService.executeFlowTask(args);
return Result.success();
}
// 查询是否提案
// 单条审核
List<String> mergeProposalIds = proposalCommonService.mergeProposal(proposalId);
if (ObjectUtil.isEmpty(mergeProposalIds)) {
flowCommonService.executeTask(args);
return Result.success();
@At
@SaCheckPermission("proposal.unitReply")
@ApiOperation("查询历史答复内容")
public Result getReplyOpinion(@Param("taskId") @NotNull(message = "任务ID不能为空") Long taskId) {
/*
* 页面上的“编辑答复内容”入口只对超级管理员开放。
* 这里继续在服务端做一次角色兜底,避免前端绕过按钮显隐后越权修改历史答复。
*/
if (!AuthUtil.hasRole(RoleConstant.SYSADMIN.name())) {
return Result.error("只有超级管理员可以编辑答复内容");
}
return Result.success(proposalUnderTakeReplyService.getReplyOpinion(taskId));
}
// 并案审核
ProcessTask thisTask = dao.fetch(ProcessTask.class, args.getLong(FlowConst.PROCESS_TASK_ID_KEY));
List<ProcessTask> mergeTasks = processTaskService.getDoingTaskByBizIdTaskName(mergeProposalIds, thisTask.getTaskName());
for (ProcessTask mergeTask : mergeTasks) {
Dict cloneArgs = args.clone();
cloneArgs.put(FlowConst.PROCESS_TASK_ID_KEY, mergeTask.getId());
flowCommonService.executeTask(cloneArgs);
@At
@SaCheckPermission("proposal.unitReply")
@ApiOperation("更新历史答复内容")
@Aop(TransAop.READ_COMMITTED)
public Result updateReplyOpinion(@Param("taskId") @NotNull(message = "任务ID不能为空") Long taskId,
@Param("opinion") @NotBlank(message = "答复内容不能为空") String opinion) {
/*
* 这里只允许超级管理员改历史答复内容,且只改 tf_opinion 字段。
* 具体的任务范围和状态校验放在 service 层统一处理,避免控制器承载业务逻辑。
*/
if (!AuthUtil.hasRole(RoleConstant.SYSADMIN.name())) {
return Result.error("只有超级管理员可以编辑答复内容");
}
proposalUnderTakeReplyService.updateReplyOpinion(taskId, opinion);
return Result.success();
}
@@ -0,0 +1,172 @@
package com.budwk.app.zhgh.democratic.proposal.handler;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.exception.BaseException;
import com.budwk.app.flow.engine.AssignmentHandler;
import com.budwk.app.flow.engine.core.Execution;
import com.budwk.app.flow.engine.core.ServiceContext;
import com.budwk.app.flow.engine.model.TaskModel;
import com.budwk.app.sys.models.Sys_role;
import com.budwk.app.sys.models.Sys_user_role;
import com.budwk.app.sys.services.SysRoleService;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalReplyUnit;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalUndertake;
import org.nutz.aop.interceptor.ioc.TransAop;
import org.nutz.dao.Cnd;
import org.nutz.dao.Dao;
import org.nutz.ioc.aop.Aop;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
/**
* 提案承办单位处理人
*/
public class ProposalUnitAssignmentHandler implements AssignmentHandler {
@Override
@Aop(TransAop.READ_COMMITTED)
public List<String> assign(TaskModel model, Execution execution) {
Dao dao = ServiceContext.find(Dao.class);
SysRoleService sysRoleService = ServiceContext.find(SysRoleService.class);
String proposalId = execution.getProcessInstance().getBusinessNo();
// 当前节点需要同时处理主办和协办负责人。
// 这里不能按单位ID去重,必须保留每个承办单位对应的一条分派记录,
// 否则同一用户负责多个单位时,会被错误合并成更少的待办。
List<String> unitIds = new ArrayList<>();
unitIds.addAll(resolveMasterUnitIds(execution, dao, proposalId));
unitIds.addAll(resolveSlaveUnitIds(execution, dao, proposalId));
if (unitIds.isEmpty()) {
throw new BaseException("提案没有配置承办单位");
}
Sys_role sysRole = sysRoleService.getByCode(RoleConstant.PROPOSAL_UNIT_LEADER);
if (sysRole == null) {
throw new BaseException("提案承办单位领导角色不存在");
}
List<String> assignee = new ArrayList<>();
for (String unitId : unitIds) {
ProposalUndertake undertake = dao.fetch(ProposalUndertake.class, unitId);
if (undertake == null) {
throw new BaseException("承办单位不存在");
}
// 只要存在单位 ID,就必须找到该单位负责人,否则流程无法继续往下分派。
List<Sys_user_role> sysUserRoles = dao.query(Sys_user_role.class,
Cnd.where(Sys_user_role::getRoleId, "=", sysRole.getId())
.and(Sys_user_role::getUnderTakeId, "=", undertake.getId()));
if (ObjectUtil.isEmpty(sysUserRoles)) {
throw new BaseException(undertake.getName() + "单位没有设置负责人!");
}
/*
* 会签需要按“承办单位”创建实例。
* 同一个用户若同时负责主办、协办多个承办单位,不能在这里跨单位去重;
* 否则流程会把多个承办单位合并成一个会签实例,导致“全部承办单位答复完”判断失真。
*/
assignee.addAll(sysUserRoles.stream().map(Sys_user_role::getUserId).toList());
}
return assignee;
}
/**
* 优先从当前流程变量读取主办单位,读不到时回落到承办单位记录表,兼容重新流转场景。
*/
private List<String> resolveMasterUnitIds(Execution execution, Dao dao, String proposalId) {
List<String> masterUnitIds = new ArrayList<>();
/*
* 页面会同时提交 tf_masterUnitId 和 tf_masterUnitIds
* 前者是给旧流程兼容的“第一个主办单位”,后者才是当前页面真实的主办单位列表。
* 这里必须优先使用列表字段;只有列表为空时,才回退到单值字段,
* 否则单主办场景会把同一个单位重复加入两次,最终多生成一条会签任务。
*/
List<String> masterUnitIdList = getStringList(execution.getArgs(), "tf_masterUnitIds");
if (ObjectUtil.isNotEmpty(masterUnitIdList)) {
masterUnitIds.addAll(masterUnitIdList);
} else {
String masterUnitId = execution.getArgs().getStr("tf_masterUnitId");
if (StrUtil.isNotBlank(masterUnitId)) {
masterUnitIds.add(masterUnitId);
}
}
if (masterUnitIds.isEmpty()) {
List<ProposalReplyUnit> masterUnits = dao.query(ProposalReplyUnit.class,
Cnd.where(ProposalReplyUnit::getProposalId, "=", proposalId)
.and(ProposalReplyUnit::getIsMaster, "=", true));
if (ObjectUtil.isNotEmpty(masterUnits)) {
masterUnitIds.addAll(masterUnits.stream().map(ProposalReplyUnit::getUnitId).toList());
}
}
return masterUnitIds;
}
/**
* 协办单位不区分是否需要答复,只要流程变量或记录表里存在协办单位 ID,就分派给对应负责人。
*/
private List<String> resolveSlaveUnitIds(Execution execution, Dao dao, String proposalId) {
List<String> slaveUnitIds = new ArrayList<>();
List<String> slaveUnitIdList = getStringList(execution.getArgs(), "tf_slaveUnitIds");
if (ObjectUtil.isNotEmpty(slaveUnitIdList)) {
slaveUnitIds.addAll(slaveUnitIdList);
}
if (slaveUnitIds.isEmpty()) {
List<ProposalReplyUnit> slaveUnits = dao.query(ProposalReplyUnit.class,
Cnd.where(ProposalReplyUnit::getProposalId, "=", proposalId)
.and(ProposalReplyUnit::getIsMaster, "=", false));
if (ObjectUtil.isNotEmpty(slaveUnits)) {
slaveUnitIds.addAll(slaveUnits.stream().map(ProposalReplyUnit::getUnitId).toList());
}
}
return slaveUnitIds;
}
/**
* 流程变量里的单位ID可能是 List、数组、JSON 字符串或逗号分隔字符串,这里统一转成字符串列表。
*/
private List<String> getStringList(Dict args, String key) {
Object value = args.getObj(key);
if (ObjectUtil.isEmpty(value)) {
return List.of();
}
if (value instanceof Collection<?> collection) {
return collection.stream().filter(ObjectUtil::isNotEmpty).map(String::valueOf).toList();
}
if (value instanceof Object[] array) {
return Arrays.stream(array).filter(ObjectUtil::isNotEmpty).map(String::valueOf).toList();
}
if (value instanceof String strValue) {
if (StrUtil.isBlank(strValue)) {
return List.of();
}
if (JSONUtil.isTypeJSONArray(strValue)) {
return JSONUtil.parseArray(strValue).toList(String.class);
}
return Arrays.stream(strValue.split(","))
.map(String::trim)
.filter(StrUtil::isNotBlank)
.toList();
}
return List.of(String.valueOf(value));
}
@Override
public String getMessage() {
return "提案单位处理人";
}
@Override
public int getOrder() {
return 210;
}
}
@@ -26,6 +26,9 @@ import org.nutz.ioc.aop.Aop;
import org.nutz.json.Json;
import org.nutz.lang.util.NutMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
/**
@@ -36,62 +39,26 @@ public class ProposalCaseFilingInterceptor implements FlowInterceptor {
@Override
@Aop(TransAop.READ_COMMITTED)
public void intercept(Execution execution) {
if ("0".equals(execution.getArgs().getStr("tf_caseCheckNeedSecondReply"))){
return;
}
Dao dao = ServiceContext.find(Dao.class);
// 提案ID
String proposalId = execution.getProcessInstance().getBusinessNo();
// 立案结果
String caseFilingResult = execution.getArgs().getStr(FlowConst.TASK_FORM_DATA_PREFIX + "caseFilingResult");
// 储存承办单位
if (StrUtil.isNotBlank(caseFilingResult) && List.of("CONFIRM_FILING", "SUGGESTION").contains(caseFilingResult)) {
// 删除原来的记录
dao.clear(ProposalReplyUnit.class,Cnd.where(ProposalReplyUnit::getProposalId, "=", proposalId));
// 主办单位
String masterUnitId = execution.getArgs().getStr(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitId");
ProposalUndertake masterUnit = dao.fetch(ProposalUndertake.class, masterUnitId);
ProposalReplyUnit masterReplyUnit = new ProposalReplyUnit();
masterReplyUnit.setProposalId(proposalId);
masterReplyUnit.setUnitId(masterUnit.getId());
masterReplyUnit.setUnitCode(masterUnit.getCode());
masterReplyUnit.setUnitName(masterUnit.getName());
masterReplyUnit.setIsMaster(true);
dao.insert(masterReplyUnit);
// 协办单位
List<String> helpUnitIds = (List<String>) execution.getArgs().getObj(FlowConst.TASK_FORM_DATA_PREFIX + "slaveUnitIds");
if(ObjectUtil.isNotEmpty(helpUnitIds)){
for (String helpUnitId : helpUnitIds) {
ProposalUndertake helpUnit = dao.fetch(ProposalUndertake.class, helpUnitId);
ProposalReplyUnit helpReplyUnit = new ProposalReplyUnit();
helpReplyUnit.setProposalId(proposalId);
helpReplyUnit.setUnitId(helpUnit.getId());
helpReplyUnit.setUnitCode(helpUnit.getCode());
helpReplyUnit.setUnitName(helpUnit.getName());
helpReplyUnit.setIsMaster(false);
dao.insert(helpReplyUnit);
}
}
}
// 更新立案结果、立案类型
ProcessInstance processInstance = execution.getProcessInstance();
String businessNo = processInstance.getBusinessNo();
Chain chain = Chain.make("caseFilingResult", execution.getArgs().getStr(FlowConst.TASK_FORM_DATA_PREFIX + "caseFilingResult"));
chain.add("caseFilingType", execution.getArgs().getStr(FlowConst.TASK_FORM_DATA_PREFIX + "caseFilingType"));
dao.update(ProposalInfo.class, chain, Cnd.where(ProposalInfo::getId, "=", businessNo));
// 当前任务
List<ProcessTask> processTaskList = execution.getProcessTaskList();
for (ProcessTask task : processTaskList) {
// 办理人
ProcessTaskActor taskActor = dao.fetch(ProcessTaskActor.class, Cnd.where(ProcessTaskActor::getProcessTaskId, "=", task.getId()));
if (taskActor == null) {
continue;
}
String actorUnitId = taskActor.getActorUnitId();
ProposalReplyUnit replyUnit = dao.fetch(ProposalReplyUnit.class, Cnd.where(ProposalReplyUnit::getProposalId, "=", proposalId).and(ProposalReplyUnit::getUnitId, "=", actorUnitId));
if (replyUnit == null) {
continue;
}
Dict variable = FlowUtil.variableToDict(task.getVariable());
variable.set("underTakeName", replyUnit.getUnitName());
@@ -1,5 +1,6 @@
package com.budwk.app.zhgh.democratic.proposal.interceptor;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.StrUtil;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.engine.FlowInterceptor;
@@ -13,7 +14,7 @@ import org.nutz.dao.Dao;
/**
* 提案分管领导审批前缀拦截器
* 用于设置主办单位变量 tf_masterUnitId
* 用于设置主办单位变量,兼容主办单位由单个改为多个的场景
*/
public class ProposalFgxldPrefixInterceptor implements FlowInterceptor {
@Override
@@ -27,8 +28,12 @@ public class ProposalFgxldPrefixInterceptor implements FlowInterceptor {
.and(ProcessTask::getTaskState, "=", ProcessTaskStateEnum.FINISHED.getCode())
.desc(ProcessTask::getCreatedAt)
);
String masterUnitId = FlowUtil.variableToDict(task.getVariable()).getStr(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitId");
Dict variable = FlowUtil.variableToDict(task.getVariable());
String masterUnitId = variable.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitId");
execution.getArgs().set(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitId", masterUnitId);
// 退回提委会时保留主办单位集合,避免多主办场景下页面无法完整回显。
execution.getArgs().set(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitIds",
variable.getObj(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitIds"));
}
}
}
@@ -0,0 +1,17 @@
package com.budwk.app.zhgh.democratic.proposal.service;
import org.nutz.lang.util.NutMap;
import java.util.List;
public interface ProposalCaseCheckService {
/**
* 查询当前提案已经配置的承办单位。
* 二次答复只能从当前提案已有的主办/协办单位里选择,避免页面误选到无关单位。
*
* @param proposalId 提案ID
* @return 承办单位列表
*/
List<NutMap> listReplyUnits(String proposalId);
}
@@ -1,12 +1,24 @@
package com.budwk.app.zhgh.democratic.proposal.service;
import com.budwk.app.base.service.BaseService;
import cn.hutool.core.lang.Dict;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalInfo;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalCommitteeFilingApprovalParam;
public interface ProposalCommitteeFilingService extends BaseService<ProposalInfo> {
void approval(ProposalCommitteeFilingApprovalParam approvalParam);
/**
* 提案委员会并案审核。
*
* @param args 页面提交的流程参数
*/
void merge(Dict args);
void revoke(String taskId);
/**
* 提案委员会立案撤回。
* 单条提案只撤回当前任务;并案提案需要整组一起撤回,确保流程状态一致。
*
* @param taskId 当前已办任务ID
* @param proposalId 当前提案ID
*/
void revokeTask(Long taskId, String proposalId);
}
@@ -1,12 +1,19 @@
package com.budwk.app.zhgh.democratic.proposal.service;
import cn.hutool.core.lang.Dict;
import com.budwk.app.base.service.BaseService;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalInfo;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalCommitteeFilingUnitApprovalParam;
public interface ProposalCommitteeFilingUnitService extends BaseService<ProposalInfo> {
void approval(ProposalCommitteeFilingUnitApprovalParam approvalParam);
void revoke(String taskId);
/**
* old-flow 提案委员会确认承办单位执行。
* 执行流程任务后,同步落库立案结果以及主协办单位配置。
*
* @param args 页面提交的流程参数
*/
void executeFlowTask(Dict args);
}
@@ -1,10 +1,10 @@
package com.budwk.app.zhgh.democratic.proposal.service;
import cn.hutool.core.lang.Dict;
import com.budwk.app.base.page.Pagination;
import com.budwk.app.base.service.BaseService;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalInfo;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalSearchParam;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalUnderTakeReplyApprovalParam;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalUnderTakeReplyTransferParam;
import org.nutz.lang.util.NutMap;
@@ -15,7 +15,15 @@ public interface ProposalUnderTakeReplyService extends BaseService<ProposalInfo>
Pagination pageData(ProposalSearchParam param);
void approval(ProposalUnderTakeReplyApprovalParam param);
/**
* old-flow 提案承办单位答复执行。
* 同一批次存在多个 wf_process_task 时,前面的任务只完结当前待办,
* 最后一条待办才真正驱动流程流转到下一节点。
*
* @param args 页面提交的流程参数
*/
void executeFlowTask(Dict args);
/**
* 查询本单位可转办用户
@@ -24,26 +32,21 @@ public interface ProposalUnderTakeReplyService extends BaseService<ProposalInfo>
List<NutMap> queryTransferUser(String keyword);
/**
* 转办
* @param param
* 查询历史承办单位答复任务中的答复内容。
* 该能力仅用于超级管理员在页面上回显“编辑答复内容”弹窗,
* 因此只返回当前编辑场景所需的最小字段,避免误改其他流程数据。
*
* @param taskId 历史承办单位答复任务ID
* @return 包含任务ID和 tf_opinion 的回显数据
*/
void transfer(ProposalUnderTakeReplyTransferParam param);
NutMap getReplyOpinion(Long taskId);
/**
* 撤回
* @param taskId
* 更新历史承办单位答复任务中的答复内容。
* 这里只允许修改流程任务变量里的 tf_opinion,其他字段如落实情况、附件、流程状态均保持不变。
*
* @param taskId 历史承办单位答复任务ID
* @param opinion 最新答复内容
*/
void revokeTask(@Valid String taskId);
/**
* 检查是否可以办理
* @param taskId
*/
String checkCanReply(String taskId);
/**
* 撤回转办
* @param taskId
*/
void revokeTransfer(String taskId);
void updateReplyOpinion(Long taskId, String opinion);
}
@@ -0,0 +1,41 @@
package com.budwk.app.zhgh.democratic.proposal.service.impl;
import com.budwk.app.base.exception.BaseException;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalReplyUnit;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalCaseCheckService;
import org.nutz.dao.Cnd;
import org.nutz.dao.Dao;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.lang.util.NutMap;
import java.util.List;
@IocBean(args = {"refer:dao"})
public class ProposalCaseCheckServiceImpl implements ProposalCaseCheckService {
private final Dao dao;
public ProposalCaseCheckServiceImpl(Dao dao) {
this.dao = dao;
}
@Override
public List<NutMap> listReplyUnits(String proposalId) {
if (proposalId == null || proposalId.isBlank()) {
throw new BaseException("提案ID不能为空");
}
/*
* 二次答复的承办单位来源于当前提案已落库的主办/协办配置。
* 这里按主办优先、再按单位名称排序,便于页面选择时直观看到主协办顺序。
*/
List<ProposalReplyUnit> replyUnits = dao.query(ProposalReplyUnit.class,
Cnd.where(ProposalReplyUnit::getProposalId, "=", proposalId)
.desc(ProposalReplyUnit::getIsMaster)
.asc(ProposalReplyUnit::getUnitName));
return replyUnits.stream().map(replyUnit -> NutMap.NEW()
.setv("unitId", replyUnit.getUnitId())
.setv("unitName", replyUnit.getUnitName())
.setv("isMaster", replyUnit.getIsMaster())
).toList();
}
}
@@ -1,40 +1,26 @@
package com.budwk.app.zhgh.democratic.proposal.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.exception.BaseException;
import com.budwk.app.base.service.impl.BaseServiceImpl;
import com.budwk.app.bpm.dto.BpmAssignmentDto;
import com.budwk.app.bpm.enums.BpmTaskApprovalTypeEnum;
import com.budwk.app.bpm.models.BpmProcessInstance;
import com.budwk.app.bpm.models.BpmProcessTask;
import com.budwk.app.bpm.service.BpmService;
import com.budwk.app.sys.models.Sys_user_role;
import com.budwk.app.sys.services.SysMsgService;
import com.budwk.app.web.commons.auth.utils.SecurityUtil;
import com.budwk.app.web.controllers.open.commons.service.CommonService;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.entity.ProcessTask;
import com.budwk.app.flow.service.FlowCommonService;
import com.budwk.app.flow.service.ProcessTaskService;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalConsolidation;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalInfo;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalUndertake;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalCommitteeFilingApprovalParam;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalMerge;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalCommitteeFilingService;
import com.budwk.app.zhgh.democratic.proposal.service.common.ProposalCommonService;
import org.nutz.aop.interceptor.ioc.TransAop;
import org.nutz.dao.Chain;
import org.nutz.dao.Cnd;
import org.nutz.dao.Dao;
import org.nutz.dao.util.cri.Static;
import org.nutz.ioc.aop.Aop;
import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.lang.random.R;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
@IocBean(args = {"refer:dao"})
public class ProposalCommitteeFilingServiceImpl extends BaseServiceImpl<ProposalInfo> implements ProposalCommitteeFilingService {
@@ -42,155 +28,61 @@ public class ProposalCommitteeFilingServiceImpl extends BaseServiceImpl<Proposal
@Inject
private ProposalCommonService proposalCommonService;
@Inject
private BpmService bpmService;
private FlowCommonService flowCommonService;
@Inject
private CommonService commonService;
@Inject
private SysMsgService sysMsgService;
private ProcessTaskService processTaskService;
public ProposalCommitteeFilingServiceImpl(Dao dao) {
super(dao);
}
@Override
public void approval(ProposalCommitteeFilingApprovalParam approvalParam) {
approvalParam.getBpmTaskApprovalTypeEnum();
Map<String, Object> variables = BeanUtil.beanToMap(approvalParam);
variables.put("proposalIds", approvalParam.getProposalIds());
variables.put("hostUnitId", approvalParam.getHostUnitId());
variables.put("helpUnitIds", approvalParam.getHelpUnitIds());
variables.put("caseFilingResult", approvalParam.getCaseFilingResult());
variables.put("consolidationIds", approvalParam.getProposalIds());
@Aop(TransAop.READ_COMMITTED)
public void merge(Dict args) {
List<Integer> taskIds = (List<Integer>) args.get("processTaskIds");
List<String> proposalIds = (List<String>) args.get("proposalIds");
ProposalUndertake hostUnit = null;
List<ProposalUndertake> helpUnits = null;
//承办单位答复人初步阅览
List<BpmAssignmentDto> nextApprovals = new ArrayList<>();
// 记录提案并案,后续撤回、查询等场景都依赖这组并案关系。
dao().clear(ProposalMerge.class, Cnd.where(ProposalMerge::getProposalId, "in", proposalIds));
ProposalConsolidation proposalConsolidation = new ProposalConsolidation();
proposalConsolidation.setConsolidationIds(proposalIds);
dao().insert(proposalConsolidation);
if (approvalParam.getBpmTaskApprovalTypeEnum().equals(BpmTaskApprovalTypeEnum.DYNAMIC)) {
if (List.of("CONFIRM_FILING", "SUGGESTION").contains(approvalParam.getCaseFilingResult())) {
hostUnit = dao().fetch(ProposalUndertake.class, approvalParam.getHostUnitId());
helpUnits = dao().query(ProposalUndertake.class, Cnd.where(ProposalUndertake::getId, "in", approvalParam.getHelpUnitIds()));
variables.put("hostUnit", hostUnit.getName());
variables.put("helpUnits", helpUnits.stream().map(ProposalUndertake::getName).toArray(String[]::new));
String groupId = R.UU32();
List<ProposalMerge> merges = proposalIds.stream().map(proposalId -> {
ProposalMerge merge = new ProposalMerge();
merge.setProposalId(proposalId);
merge.setGroupId(groupId);
return merge;
}).toList();
dao().insert(merges);
List<JSONObject> units = new ArrayList<>();
units.add(new JSONObject()
.set("isMaster",true)
.set("underTakeId", hostUnit.getId())
.set("underTakeName", hostUnit.getName())
.set("underTakeCode", hostUnit.getCode())
);
if(ObjectUtil.isNotEmpty(helpUnits)){
for (ProposalUndertake helpUnit : helpUnits) {
units.add(new JSONObject()
.set("isMaster",false)
.set("underTakeId", helpUnit.getId())
.set("underTakeName", helpUnit.getName())
.set("underTakeCode", helpUnit.getCode())
);
}
}
variables.put("units",units);
}
//并案审核
if (approvalParam.getProposalIds().length > 1) {
ProposalConsolidation proposalConsolidation = new ProposalConsolidation();
proposalConsolidation.setConsolidationIds(Arrays.asList(approvalParam.getProposalIds()));
dao().insert(proposalConsolidation);
}
//立案和作为意见会有承办单位
if (approvalParam.getCaseFilingResult().equals("CONFIRM_FILING") || approvalParam.getCaseFilingResult().equals("SUGGESTION")) {
List<ProposalUndertake> units = new ArrayList<>();
units.add(hostUnit);
if (ObjectUtil.isNotNull(helpUnits)) {
units.addAll(helpUnits);
}
for (ProposalUndertake unit : units) {
String approvalLoginName = commonService.findUserLoginNameByRoleCode(RoleConstant.PROPOSAL_UNIT_LEADER, Cnd.where(Sys_user_role::getUnderTakeId, "=", unit.getId()));
if (StrUtil.isBlank(approvalLoginName)) {
throw new BaseException("{}答复人没有配置,请到承办单位管理页面设置!", unit.getName());
}
assert hostUnit != null;
nextApprovals.add(new BpmAssignmentDto()
.setLoginName(approvalLoginName)
.setJsonObject(new JSONObject()
.set("isMaster", hostUnit.getId().equals(unit.getId()))
.set("underTakeId", unit.getId())
.set("underTakeName", unit.getName())
.set("underTakeCode", unit.getCode())
)
);
}
}
//下一个审批人
String nextApprovalLoginName = proposalCommonService.getCommitteeDirectorByProposalId(approvalParam.getProcessInstanceBusinessId());
//提交并案
for (String consolidationProposalId : approvalParam.getProposalIds()) {
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationProposalId));
// bpmService.completeTaskWithNextTaskVariable(instance.getProcessInstanceTaskIds().get(0), approvalParam.getBpmTaskApprovalTypeEnum(), variables, nextApprovals);
bpmService.completeTask(instance.getProcessInstanceTaskIds().get(0), approvalParam.getBpmTaskApprovalTypeEnum(), variables, List.of(nextApprovalLoginName));
}
//修改提案立案结果
dao().update(ProposalInfo.class, Chain.make("caseFilingResult", approvalParam.getCaseFilingResult()), Cnd.where(ProposalInfo::getId, "in", approvalParam.getProposalIds()));
List<ProposalInfo> proposalInfos = dao().query(ProposalInfo.class, Cnd.where(ProposalInfo::getId, "in", approvalParam.getProposalIds()));
for (ProposalInfo proposalInfo : proposalInfos) {
//给代表发送消息
if("CONFIRM_FILING".equals(approvalParam.getCaseFilingResult())){
String template = "{}代表您好!您的提案《{}》提案委员会已立案审核,审核结果为准予立案,您可登陆智慧校园下的暖心工会查看详情。";
String content = StrUtil.format(template, proposalInfo.getCreateUserName(), proposalInfo.getName());
sysMsgService.sendMsg(proposalInfo.getCreateUserLoginName(), "提案委员会立案审核", content, SecurityUtil.getUserId());
}else if("SUGGESTION".equals(approvalParam.getCaseFilingResult())){
}else if("NOT".equals(approvalParam.getCaseFilingResult())){
String template = "{}代表您好!您的提案《{}》提案委员会已立案审核,审核结果为不予立案,您可登陆智慧校园下的暖心工会查看详情。";
String content = StrUtil.format(template, proposalInfo.getCreateUserName(), proposalInfo.getName());
sysMsgService.sendMsg(proposalInfo.getCreateUserLoginName(), "提案委员会立案审核", content, SecurityUtil.getUserId());
}
//给承办单位发送消息
if("CONFIRM_FILING".equals(approvalParam.getCaseFilingResult())){
for (BpmAssignmentDto nextApproval : nextApprovals) {
String template = "经提案委员会立案审核,提案《{}》由{}作为{}单位,您可登陆智慧校园下的暖心工会查看详情,感谢您对教代会提案工作的大力支持!。";
String underTakeName = nextApproval.getJsonObject().getStr("underTakeName");
Boolean isMaster = nextApproval.getJsonObject().getBool("isMaster", false);
String content = StrUtil.format(template, proposalInfo.getName(), underTakeName,isMaster?"主办":"协办");
sysMsgService.sendMsg(nextApproval.getLoginName(), "承办单位初步意见", content, SecurityUtil.getUserId());
}
}
}
// 并案审核需要把同一批提案的当前节点一起提交,保持整组流程同步往下走。
for (Integer taskId : taskIds) {
Dict taskArgs = args.clone();
taskArgs.put(FlowConst.PROCESS_TASK_ID_KEY, taskId);
flowCommonService.executeTask(taskArgs);
}
}
@Override
@Aop(TransAop.READ_COMMITTED)
public void revoke(String taskId) {
BpmProcessTask task = dao().fetch(BpmProcessTask.class, taskId);
String instanceId = task.getProcessInstanceId();
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, instanceId);
String instanceBusinessId = instance.getProcessInstanceBusinessId();
List<String> consolidationIds = proposalCommonService.getConsolidation(instanceBusinessId);
for (String consolidationId : consolidationIds) {
BpmProcessInstance consolidationProposalInstance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationId));
if (ObjectUtil.isNotEmpty(consolidationProposalInstance.getProcessInstanceTaskIds())) {
//还有待处理的任务 那么走的就是确定立案
String activeTaskId = consolidationProposalInstance.getProcessInstanceTaskIds().get(0);
BpmProcessTask activeTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getId, "=", activeTaskId));
bpmService.revokeTask(activeTask.getPrevTaskId());
}else{
//不予立案后撤回
bpmService.revokeTask(taskId);
}
public void revokeTask(Long taskId, String proposalId) {
/*
* 提委会立案撤回统一走 flowCommonService。
* 非并案时直接撤回当前任务;并案时按当前节点找出整组已办任务,逐条撤回,避免只回退一部分提案。
*/
List<String> mergeProposalIds = proposalCommonService.mergeProposal(proposalId);
if (ObjectUtil.isEmpty(mergeProposalIds)) {
flowCommonService.revokeTask(taskId);
return;
}
ProcessTask thisTask = dao().fetch(ProcessTask.class, taskId);
List<ProcessTask> mergeTasks = processTaskService.getDoneTaskByBizIdTaskName(mergeProposalIds, thisTask.getTaskName());
for (ProcessTask mergeTask : mergeTasks) {
flowCommonService.revokeTask(mergeTask.getId());
}
dao().update(ProposalInfo.class, Chain.make("caseFilingResult", null), Cnd.where(ProposalInfo::getId, "in", consolidationIds));
dao().clear(ProposalConsolidation.class, Cnd.where(new Static("JSON_CONTAINS(consolidationIds,'\"" + instanceBusinessId + "\"')")));
}
}
@@ -1,8 +1,10 @@
package com.budwk.app.zhgh.democratic.proposal.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import cn.hutool.json.JSONObject;
import com.budwk.app.base.constant.RoleConstant;
import com.budwk.app.base.exception.BaseException;
@@ -12,6 +14,10 @@ import com.budwk.app.bpm.enums.BpmProcessTaskStatusEnum;
import com.budwk.app.bpm.models.BpmProcessInstance;
import com.budwk.app.bpm.models.BpmProcessTask;
import com.budwk.app.bpm.service.BpmService;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.entity.ProcessTask;
import com.budwk.app.flow.service.FlowCommonService;
import com.budwk.app.flow.service.ProcessTaskService;
import com.budwk.app.sys.models.Sys_user_role;
import com.budwk.app.sys.services.SysMsgService;
import com.budwk.app.web.commons.auth.utils.SecurityUtil;
@@ -19,6 +25,7 @@ import com.budwk.app.web.controllers.open.commons.service.CommonService;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalConfig;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalConsolidation;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalInfo;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalReplyUnit;
import com.budwk.app.zhgh.democratic.proposal.models.ProposalUndertake;
import com.budwk.app.zhgh.democratic.proposal.param.ProposalCommitteeFilingUnitApprovalParam;
import com.budwk.app.zhgh.democratic.proposal.service.ProposalCommitteeFilingUnitService;
@@ -33,9 +40,12 @@ import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@IocBean(args = {"refer:dao"})
public class ProposalCommitteeFilingUnitServiceImpl extends BaseServiceImpl<ProposalInfo> implements ProposalCommitteeFilingUnitService {
@@ -48,6 +58,10 @@ public class ProposalCommitteeFilingUnitServiceImpl extends BaseServiceImpl<Prop
private BpmService bpmService;
@Inject
private SysMsgService sysMsgService;
@Inject
private FlowCommonService flowCommonService;
@Inject
private ProcessTaskService processTaskService;
public ProposalCommitteeFilingUnitServiceImpl(Dao dao) {
super(dao);
@@ -55,129 +69,134 @@ public class ProposalCommitteeFilingUnitServiceImpl extends BaseServiceImpl<Prop
@Override
@Aop(TransAop.READ_COMMITTED)
public void approval(ProposalCommitteeFilingUnitApprovalParam approvalParam) {
approvalParam.getBpmTaskApprovalTypeEnum();
Map<String, Object> variables = BeanUtil.beanToMap(approvalParam);
//审批变量
variables.put("proposalIds", approvalParam.getProposalIds());
variables.put("hostUnitId", approvalParam.getHostUnitId());
variables.put("helpUnitIds", approvalParam.getHelpUnitIds());
variables.put("caseFilingResult", approvalParam.getCaseFilingResult());
//承办单位
ProposalUndertake hostUnit = dao().fetch(ProposalUndertake.class, approvalParam.getHostUnitId());
List<ProposalUndertake> helpUnits = dao().query(ProposalUndertake.class, Cnd.where(ProposalUndertake::getId, "in", approvalParam.getHelpUnitIds()));
variables.put("hostUnit", hostUnit.getName());
variables.put("helpUnits", helpUnits.stream().map(ProposalUndertake::getName).toArray(String[]::new));
//查询提案配置协办单位是否需要答复
ProposalConfig proposalConfig = dao().fetch(ProposalConfig.class, Cnd.NEW());
Boolean slaveUnitNeedReply = proposalConfig.getSlaveUnitNeedReply();
if (ObjectUtil.isNull(slaveUnitNeedReply)) {
throw new BaseException("协办是否需要答复提案配置缺失,请联系校工会!");
public void executeFlowTask(Dict args) {
Long processTaskId = args.getLong(FlowConst.PROCESS_TASK_ID_KEY);
ProcessTask currentTask = dao().fetch(ProcessTask.class, processTaskId);
if (currentTask == null) {
throw new BaseException("没有进行中的流程任务");
}
//重新并案审核
if (approvalParam.getProposalIds().length > 1) {
for (String proposalId : approvalParam.getProposalIds()) {
dao().clear(ProposalConsolidation.class, Cnd.where(new Static("JSON_CONTAINS(consolidationIds,'\"%s\"')".formatted(proposalId))));
}
ProposalConsolidation proposalConsolidation = new ProposalConsolidation();
proposalConsolidation.setConsolidationIds(Arrays.asList(approvalParam.getProposalIds()));
dao().insert(proposalConsolidation);
String proposalId = args.getStr("proposalId");
List<String> proposalIds = proposalCommonService.mergeProposal(proposalId);
if (ObjectUtil.isEmpty(proposalIds)) {
proposalIds = List.of(proposalId);
}
List<ProposalUndertake> proposalUndertakes = new ArrayList<>();
proposalUndertakes.add(hostUnit);
if (ObjectUtil.isNotEmpty(helpUnits) && slaveUnitNeedReply) {
proposalUndertakes.addAll(helpUnits);
/*
* 并案场景下,同一个节点会在每条提案实例上各有一条待办。
* 这里统一按 taskName 找出整组正在办理中的任务,逐条执行,确保并案提案的流程状态保持一致。
*/
List<ProcessTask> executeTasks = processTaskService.getDoingTaskByBizIdTaskName(proposalIds, currentTask.getTaskName());
if (ObjectUtil.isEmpty(executeTasks)) {
executeTasks = List.of(currentTask);
}
for (ProcessTask executeTask : executeTasks) {
Dict cloneArgs = args.clone();
cloneArgs.put(FlowConst.PROCESS_TASK_ID_KEY, executeTask.getId());
flowCommonService.executeTask(cloneArgs);
}
//承办单位答复人
List<BpmAssignmentDto> nextApprovals = new ArrayList<>();
// if (approvalParam.getCaseFilingResult().equals("CONFIRM_FILING") || approvalParam.getCaseFilingResult().equals("SUGGESTION")) {
//南邮 只有立案需要答复
if (approvalParam.getCaseFilingResult().equals("CONFIRM_FILING")) {
for (ProposalUndertake undertake : proposalUndertakes) {
String approvalLoginName = commonService.findUserLoginNameByRoleCode(RoleConstant.PROPOSAL_UNIT_LEADER, Cnd.where(Sys_user_role::getUnderTakeId, "=", undertake.getId()));
if (StrUtil.isBlank(approvalLoginName)) {
throw new BaseException("{}答复人没有配置,请到承办单位管理页面进行配置。", undertake.getName());
}
syncCommitteeFilingUnitData(proposalIds, args);
}
/**
* old-flow 页面提交后,需要把立案结果以及主协办单位同步落业务表。
* 若这次改成“不予立案”等无需承办单位的结果,也要先清掉旧的承办单位记录,避免脏数据残留。
*/
private void syncCommitteeFilingUnitData(List<String> proposalIds, Dict args) {
String caseFilingResult = args.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "caseFilingResult");
String caseFilingType = args.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "caseFilingType");
nextApprovals.add(new BpmAssignmentDto()
.setLoginName(approvalLoginName)
.setJsonObject(new JSONObject()
.set("isMaster", hostUnit.getId().equals(undertake.getId()))
.set("underTakeId", undertake.getId())
.set("underTakeName", undertake.getName())
.set("underTakeCode", undertake.getCode())
)
);
dao().update(ProposalInfo.class,
Chain.make("caseFilingResult", caseFilingResult).add("caseFilingType", caseFilingType),
Cnd.where(ProposalInfo::getId, "in", proposalIds));
dao().clear(ProposalReplyUnit.class, Cnd.where(ProposalReplyUnit::getProposalId, "in", proposalIds));
if (!List.of("CONFIRM_FILING", "SUGGESTION").contains(caseFilingResult)) {
return;
}
List<String> masterUnitIds = getUnitIdList(args, FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitIds");
if (ObjectUtil.isEmpty(masterUnitIds)) {
String masterUnitId = args.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "masterUnitId");
if (StrUtil.isNotBlank(masterUnitId)) {
masterUnitIds = List.of(masterUnitId);
}
}
List<String> slaveUnitIds = getUnitIdList(args, FlowConst.TASK_FORM_DATA_PREFIX + "slaveUnitIds");
for (String consolidationProposalId : approvalParam.getProposalIds()) {
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationProposalId));
BpmProcessTask caseUnitTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getProcessInstanceId, "=", instance.getId())
.and(BpmProcessTask::getProcessTaskNodeCode, "=", 70)
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.ACTIVE.name())
.and(BpmProcessTask::getDelFlag, "=", 0)
.desc(BpmProcessTask::getCreatedOn)
);
bpmService.completeTaskWithNextTaskVariable(caseUnitTask.getId(), approvalParam.getBpmTaskApprovalTypeEnum(), variables, nextApprovals);
List<String> allUnitIds = new ArrayList<>();
allUnitIds.addAll(masterUnitIds);
allUnitIds.addAll(slaveUnitIds);
if (allUnitIds.isEmpty()) {
return;
}
//修改提案立案结果
dao().update(ProposalInfo.class, Chain.make("caseFilingResult", approvalParam.getCaseFilingResult())
, Cnd.where(ProposalInfo::getId, "in", approvalParam.getProposalIds()));
Map<String, ProposalUndertake> undertakeMap = dao().query(ProposalUndertake.class, Cnd.where(ProposalUndertake::getId, "in", allUnitIds))
.stream()
.collect(Collectors.toMap(ProposalUndertake::getId, v -> v));
List<ProposalInfo> proposalInfos = dao().query(ProposalInfo.class, Cnd.where(ProposalInfo::getId, "in", approvalParam.getProposalIds()));
for (ProposalInfo proposalInfo : proposalInfos) {
//给代表发送消息
// if("CONFIRM_FILING".equals(approvalParam.getCaseFilingResult())){
// String template = "{}代表您好!您的提案《{}》提案委员会已立案审核,审核结果为准予立案,您可登陆智慧校园下的暖心工会查看详情。";
// String content = StrUtil.format(template, proposalInfo.getCreateUserName(), proposalInfo.getName());
// sysMsgService.sendMsg(proposalInfo.getCreateUserLoginName(), "提案委员会立案审核", content, SecurityUtil.getUserId());
// }else if("SUGGESTION".equals(approvalParam.getCaseFilingResult())){
//
// }else if("NOT".equals(approvalParam.getCaseFilingResult())){
// String template = "{}代表您好!您的提案《{}》提案委员会已立案审核,审核结果为不予立案,您可登陆智慧校园下的暖心工会查看详情。";
// String content = StrUtil.format(template, proposalInfo.getCreateUserName(), proposalInfo.getName());
// sysMsgService.sendMsg(proposalInfo.getCreateUserLoginName(), "提案委员会立案审核", content, SecurityUtil.getUserId());
// }
//给承办单位发送消息
if("CONFIRM_FILING".equals(approvalParam.getCaseFilingResult())) {
for (BpmAssignmentDto nextApproval : nextApprovals) {
String template = "经提案委员会立案审核,提案《{}》最终由{}作为{}单位,您可登陆智慧校园下的暖心工会进行答复,感谢您对教代会提案工作的大力支持!。";
String underTakeName = nextApproval.getJsonObject().getStr("underTakeName");
Boolean isMaster = nextApproval.getJsonObject().getBool("isMaster", false);
String content = StrUtil.format(template, proposalInfo.getName(), underTakeName, isMaster ? "主办" : "协办");
sysMsgService.sendMsg(nextApproval.getLoginName(), "承办单位答复", content, SecurityUtil.getUserId());
}
}
List<ProposalReplyUnit> replyUnits = new ArrayList<>();
for (String proposalId : proposalIds) {
replyUnits.addAll(buildReplyUnits(proposalId, masterUnitIds, undertakeMap, true));
replyUnits.addAll(buildReplyUnits(proposalId, slaveUnitIds, undertakeMap, false));
}
if (!replyUnits.isEmpty()) {
dao().insert(replyUnits);
}
}
@Override
@Aop(TransAop.READ_COMMITTED)
public void revoke(String taskId) {
BpmProcessTask task = dao().fetch(BpmProcessTask.class, taskId);
String instanceId = task.getProcessInstanceId();
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, instanceId);
String instanceBusinessId = instance.getProcessInstanceBusinessId();
List<String> consolidationIds = proposalCommonService.getConsolidation(instanceBusinessId);
for (String consolidationId : consolidationIds) {
BpmProcessInstance consolidationProposalInstance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationId));
String activeTaskId = consolidationProposalInstance.getProcessInstanceTaskIds().get(0);
BpmProcessTask activeTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getId, "=", activeTaskId));
bpmService.revokeTask(activeTask.getPrevTaskId());
/**
* 一个提案可以配置多个主办单位和多个协办单位。
* 这里按页面提交顺序逐条生成承办单位记录,兼容多主办的业务场景。
*/
private List<ProposalReplyUnit> buildReplyUnits(String proposalId, List<String> unitIds, Map<String, ProposalUndertake> undertakeMap, boolean isMaster) {
List<ProposalReplyUnit> replyUnits = new ArrayList<>();
for (String unitId : unitIds) {
ProposalUndertake undertake = undertakeMap.get(unitId);
if (undertake == null) {
continue;
}
ProposalReplyUnit replyUnit = new ProposalReplyUnit();
replyUnit.setProposalId(proposalId);
replyUnit.setUnitId(undertake.getId());
replyUnit.setUnitCode(undertake.getCode());
replyUnit.setUnitName(undertake.getName());
replyUnit.setIsMaster(isMaster);
replyUnits.add(replyUnit);
}
dao().update(ProposalInfo.class, Chain.make("caseFilingResult", null), Cnd.where(ProposalInfo::getId, "in", consolidationIds));
dao().clear(ProposalConsolidation.class, Cnd.where(new Static("JSON_CONTAINS(consolidationIds,'\"" + instanceBusinessId + "\"')")));
return replyUnits;
}
/**
* 页面里的单位字段可能是数组、JSON 字符串或逗号分隔字符串,这里统一转成去空去重后的列表。
*/
private List<String> getUnitIdList(Dict args, String key) {
Object value = args.get(key);
if (ObjectUtil.isEmpty(value)) {
return List.of();
}
List<String> unitIds = new ArrayList<>();
if (value instanceof Collection<?> collection) {
collection.forEach(item -> {
if (ObjectUtil.isNotEmpty(item)) {
unitIds.add(String.valueOf(item));
}
});
} else if (value instanceof String strValue) {
if (StrUtil.isBlank(strValue)) {
return List.of();
}
if (JSONUtil.isTypeJSONArray(strValue)) {
unitIds.addAll(JSONUtil.parseArray(strValue).toList(String.class));
} else {
Arrays.stream(strValue.split(","))
.map(String::trim)
.filter(StrUtil::isNotBlank)
.forEach(unitIds::add);
}
} else {
unitIds.add(String.valueOf(value));
}
return new ArrayList<>(new LinkedHashSet<>(unitIds));
}
}
@@ -1,6 +1,7 @@
package com.budwk.app.zhgh.democratic.proposal.service.impl;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import com.budwk.app.base.constant.BpmProcessConstant;
@@ -16,6 +17,16 @@ import com.budwk.app.bpm.models.BpmProcessInstance;
import com.budwk.app.bpm.models.BpmProcessNodeDefine;
import com.budwk.app.bpm.models.BpmProcessTask;
import com.budwk.app.bpm.service.BpmService;
import com.budwk.app.flow.constant.FlowConst;
import com.budwk.app.flow.entity.ProcessInstance;
import com.budwk.app.flow.entity.ProcessTask;
import com.budwk.app.flow.engine.util.FlowUtil;
import com.budwk.app.flow.enums.ProcessSubmitTypeEnum;
import com.budwk.app.flow.enums.ProcessTaskPerformTypeEnum;
import com.budwk.app.flow.enums.ProcessTaskStateEnum;
import com.budwk.app.flow.service.FlowCommonService;
import com.budwk.app.flow.service.ProcessInstanceService;
import com.budwk.app.flow.service.ProcessTaskService;
import com.budwk.app.sys.models.Sys_role;
import com.budwk.app.sys.models.Sys_user;
import com.budwk.app.sys.models.Sys_user_role;
@@ -43,6 +54,7 @@ import org.nutz.ioc.aop.Aop;
import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.lang.util.NutMap;
import org.nutz.json.Json;
import java.util.ArrayList;
import java.util.List;
@@ -65,6 +77,12 @@ public class ProposalUnderTakeReplyServiceImpl extends BaseServiceImpl<ProposalI
private SysUserService sysUserService;
@Inject
private SysMsgService sysMsgService;
@Inject
private FlowCommonService flowCommonService;
@Inject
private ProcessTaskService processTaskService;
@Inject
private ProcessInstanceService processInstanceService;
public ProposalUnderTakeReplyServiceImpl(Dao dao) {
super(dao);
@@ -77,115 +95,25 @@ public class ProposalUnderTakeReplyServiceImpl extends BaseServiceImpl<ProposalI
@Override
@Aop(TransAop.READ_COMMITTED)
public void approval(ProposalUnderTakeReplyApprovalParam approvalParam) {
approvalParam.getBpmTaskApprovalTypeEnum();
Map<String, Object> variables = BeanUtil.beanToMap(approvalParam);
String processInstanceBusinessId = approvalParam.getProcessInstanceBusinessId();
ProposalInfo proposalInfo = dao().fetch(ProposalInfo.class, processInstanceBusinessId);
//查询是否都答复完成
boolean ALL_REPLY = false;
BpmProcessTask task = dao().fetch(BpmProcessTask.class, approvalParam.getProcessInstanceTaskId());
String prevTaskId = task.getPrevTaskId();
//查询一同分配的承办单位的答复记录
int otherUnderTakeTasks = dao().count(BpmProcessTask.class, Cnd.where("prevTaskId", "=", prevTaskId)
.and(BpmProcessTask::getProcessInstanceId, "=", approvalParam.getProcessInstanceId())
.and(BpmProcessTask::getId, "!=", task.getId())
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.ACTIVE.name())
.and(BpmProcessTask::getDelFlag, "=", 0)
);
if (otherUnderTakeTasks == 0) {
//说明其他单位都答复完成了
ALL_REPLY = true;
}
variables.put("ALL_REPLY", ALL_REPLY);
variables.put("caseFilingResult", proposalInfo.getCaseFilingResult());
//查询提案配置
ProposalConfig proposalConfig = dao().fetch(ProposalConfig.class, Cnd.NEW());
Boolean slaveUnitLeaderNeedApprove = proposalConfig.getSlaveUnitLeaderNeedApprove();
//查询出分配的承办单位
BpmProcessDefine proposalProcessDefine = dao().fetch(BpmProcessDefine.class, Cnd.where(BpmProcessDefine::getCode, "=", BpmProcessConstant.PROPOSAL.name()));
BpmProcessNodeDefine caseUnitNode = dao().fetch(BpmProcessNodeDefine.class, Cnd.where(BpmProcessNodeDefine::getProcessDefineId, "=", proposalProcessDefine.getId())
.and(BpmProcessNodeDefine::getNodeCode, "=", 70));
BpmProcessTask caseUnitTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getProcessInstanceId, "=", approvalParam.getProcessInstanceId())
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.COMPLETE.name())
.and(BpmProcessTask::getDelFlag, "=", 0)
.and(BpmProcessTask::getProcessTaskNodeId, "=", caseUnitNode.getId())
);
JSONObject caseUnitExtVariable = caseUnitTask.getExtVariable();
List<String> helpUnitIds = caseUnitExtVariable.getBeanList("helpUnitIds", String.class);
String hostUnitId = caseUnitExtVariable.getStr("hostUnitId");
//任务接收人
List<BpmAssignmentDto> assignmentDTOS = new ArrayList<>();
if (ALL_REPLY) {
String masterApprovalLoginName = commonService.findUserLoginNameByRoleCode(RoleConstant.PROPOSAL_BRANCH_SCHOOL_LEADER, Cnd.where(Sys_user_role::getUnderTakeId, "=", hostUnitId));
if (StrUtil.isBlank(masterApprovalLoginName)) {
throw new BaseException("主办单位分管校领导没有配置!");
}
ProposalUndertake masterUndertake = dao().fetch(ProposalUndertake.class, hostUnitId);
assignmentDTOS.add(new BpmAssignmentDto()
.setLoginName(masterApprovalLoginName)
.setJsonObject(new JSONObject()
.set("isMaster", true)
.set("underTakeId", masterUndertake.getId())
.set("underTakeName", masterUndertake.getName())
.set("underTakeCode", masterUndertake.getCode())
)
);
//如果需要协办领导审批
if (slaveUnitLeaderNeedApprove) {
for (String helpUnitId : helpUnitIds) {
String slaveApprovalLoginName = commonService.findUserLoginNameByRoleCode(RoleConstant.PROPOSAL_BRANCH_SCHOOL_LEADER, Cnd.where(Sys_user_role::getUnderTakeId, "=", helpUnitId));
if (StrUtil.isBlank(slaveApprovalLoginName)) {
throw new BaseException("协办单位分管校领导没有配置!");
}
ProposalUndertake slaveUndertake = dao().fetch(ProposalUndertake.class, helpUnitId);
assignmentDTOS.add(new BpmAssignmentDto()
.setLoginName(slaveApprovalLoginName)
.setJsonObject(new JSONObject()
.set("isMaster", false)
.set("underTakeId", slaveUndertake.getId())
.set("underTakeName", slaveUndertake.getName())
.set("underTakeCode", slaveUndertake.getCode())
)
);
}
}
public void executeFlowTask(Dict args) {
String proposalId = args.getStr("proposalId");
List<String> mergeProposalIds = proposalCommonService.mergeProposal(proposalId);
if (mergeProposalIds == null || mergeProposalIds.isEmpty()) {
executeSingleFlowTask(args);
return;
}
//查询并案的提案
List<String> consolidationProposalIds = proposalCommonService.getConsolidation(proposalInfo.getId());
//完成本单位的任务
for (String consolidationProposalId : consolidationProposalIds) {
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationProposalId));
BpmProcessTask otherTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getProcessInstanceId, "=", instance.getId())
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.ACTIVE.name())
.and(BpmProcessTask::getProcessTaskNodeCode, "=", task.getProcessTaskNodeCode())
.and("JSON_EXTRACT(createVariable, '$.underTakeId')", "=", approvalParam.getUnderTakeId())
.and(BpmProcessTask::getDelFlag, "=", 0)
);
bpmService.completeTaskWithNextTaskVariable(otherTask.getId(), BpmTaskApprovalTypeEnum.DYNAMIC, variables, assignmentDTOS);
ProcessTask currentTask = dao().fetch(ProcessTask.class, args.getLong(FlowConst.PROCESS_TASK_ID_KEY));
if (currentTask == null) {
throw new BaseException("没有进行中的流程任务");
}
//全部答复完成发送消息到校领导
if(ALL_REPLY){
List<ProposalInfo> proposalInfos = dao().query(ProposalInfo.class, Cnd.where(ProposalInfo::getId, "in", consolidationProposalIds));
for (ProposalInfo info : proposalInfos) {
for (BpmAssignmentDto assignmentDTO : assignmentDTOS) {
String template = "尊敬的校领导您好!提案《{}》承办单位已经全部答复完毕,请您登陆智慧校园下的暖心工会进行审批,感谢您对教代会提案工作的大力支持!。";
String content = StrUtil.format(template, info.getName());
sysMsgService.sendMsg(assignmentDTO.getLoginName(), "分管校领导审批", content, SecurityUtil.getUserId());
}
}
List<ProcessTask> mergeTasks = processTaskService.getDoingTaskByBizIdTaskName(mergeProposalIds, currentTask.getTaskName());
for (ProcessTask mergeTask : mergeTasks) {
Dict cloneArgs = args.clone();
cloneArgs.put(FlowConst.PROCESS_TASK_ID_KEY, mergeTask.getId());
executeSingleFlowTask(cloneArgs);
}
}
@Override
@@ -203,154 +131,218 @@ public class ProposalUnderTakeReplyServiceImpl extends BaseServiceImpl<ProposalI
return pagination.getList();
}
@Override
public NutMap getReplyOpinion(Long taskId) {
ProcessTask replyTask = getEditableReplyTask(taskId);
Dict variable = FlowUtil.variableToDict(replyTask.getVariable());
String opinion = variable.getStr("tf_opinion");
return NutMap.NEW()
.addv("taskId", replyTask.getId())
.addv("tf_opinion", opinion == null ? "" : opinion);
}
@Override
@Aop(TransAop.READ_COMMITTED)
public void transfer(com.budwk.app.zhgh.democratic.proposal.param.ProposalUnderTakeReplyTransferParam param) {
BpmProcessTask task = dao().fetch(BpmProcessTask.class, param.getProcessInstanceTaskId());
Sys_role sysRole = sysRoleService.getByCode(RoleConstant.PROPOSAL_UNIT_PROXY);
List<String> consolidation = proposalCommonService.getConsolidation(param.getProposalId());
for (String proposalId : consolidation) {
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", proposalId));
//查询出其他并案提案的任务ID
BpmProcessTask otherTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getProcessInstanceId, "=", instance.getId())
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.ACTIVE.name())
.and(BpmProcessTask::getProcessTaskNodeId, "=", task.getProcessTaskNodeId())
.and("JSON_EXTRACT(createVariable, '$.underTakeId')", "=", param.getUnderTakeId())
.and(BpmProcessTask::getDelFlag, "=", 0)
);
bpmService.transferTask(otherTask.getId(), param.getTransferUserLoginName(), BeanUtil.beanToMap(param));
//分配权限
FieldFilter fieldFilter = FieldFilter.create(Sys_user.class, "^id$");
Sys_user proxyUser = Daos.ext(dao(), fieldFilter).fetch(Sys_user.class, Cnd.where(Sys_user::getLoginname, "=", param.getTransferUserLoginName()));
Sys_user_role sysUserRole = new Sys_user_role();
sysUserRole.setUserId(proxyUser.getId());
sysUserRole.setRoleId(sysRole.getId());
dao().insert(sysUserRole);
sysRoleService.clearCache();
sysUserService.deleteCache(proxyUser.getId());
}
//发送消息
List<ProposalInfo> proposalInfos = dao().query(ProposalInfo.class, Cnd.where(ProposalInfo::getId, "in", consolidation));
for (ProposalInfo info : proposalInfos) {
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", info.getId()));
//查询出其他并案提案的任务ID
BpmProcessTask otherTask = dao().fetch(BpmProcessTask.class, Cnd.where(BpmProcessTask::getProcessInstanceId, "=", instance.getId())
.and(BpmProcessTask::getProcessTaskNodeId, "=", task.getProcessTaskNodeId())
.and("JSON_EXTRACT(createVariable, '$.underTakeId')", "=", param.getUnderTakeId())
.and(BpmProcessTask::getDelFlag, "=", 0)
);
String underTakeName = otherTask.getCreateVariable().getStr("underTakeName");
String template = "您好!提案《{}》{}单位的答复工作已由{}转交给您,请您登陆智慧校园下的暖心工会进行答复,感谢您对教代会提案工作的大力支持!。";
String content = StrUtil.format(template, info.getName(),underTakeName,SecurityUtil.getUserUsername());
sysMsgService.sendMsg(param.getTransferUserLoginName(), "承办单位答复", content, SecurityUtil.getUserId());
}
public void updateReplyOpinion(Long taskId, String opinion) {
ProcessTask replyTask = getEditableReplyTask(taskId);
Dict variable = FlowUtil.variableToDict(replyTask.getVariable());
/*
* 超级管理员编辑入口只允许修改答复内容。
* 因此这里仅覆盖 tf_opinion,避免把落实情况、附件或办理人信息一并改掉。
*/
variable.put("tf_opinion", opinion);
replyTask.setVariable(Json.toJson(variable));
dao().update(replyTask, "variable");
}
@Override
@Aop({TransAop.READ_COMMITTED})
public void revokeTask(String taskId) {
BpmProcessTask task = dao().fetch(BpmProcessTask.class, taskId);
String instanceId = task.getProcessInstanceId();
BpmProcessInstance instance = dao().fetch(BpmProcessInstance.class, instanceId);
String instanceBusinessId = instance.getProcessInstanceBusinessId();
List<String> consolidationIds = proposalCommonService.getConsolidation(instanceBusinessId);
for (String consolidationId : consolidationIds) {
BpmProcessInstance consolidationProposalInstance = dao().fetch(BpmProcessInstance.class, Cnd.where(BpmProcessInstance::getProcessInstanceBusinessId, "=", consolidationId));
BpmProcessTask caseUnitTask = dao().fetch(BpmProcessTask.class,
Cnd.where(BpmProcessTask::getProcessInstanceId, "=", consolidationProposalInstance.getId())
.and(BpmProcessTask::getProcessTaskNodeCode, "=", 70)
.and(BpmProcessTask::getDelFlag, "=", 0)
.desc(BpmProcessTask::getCreatedOn)
);
BpmProcessTask replyTask = dao().fetch(BpmProcessTask.class,
Cnd.where(BpmProcessTask::getPrevTaskId, "=", caseUnitTask.getId())
.and("JSON_EXTRACT(createVariable, '$.underTakeId')", "=", task.getCreateVariable().getStr("underTakeId"))
.and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.COMPLETE.name())
.and(BpmProcessTask::getDelFlag, "=", 0)
);
Boolean isMaster = replyTask.getCreateVariable().getBool("isMaster", false);
if (isMaster) {
bpmService.revokeTask(replyTask.getId());
}else{
//判断主办是否已答复完
// int masterActiveTaskCount = dao().count(BpmProcessTask.class, Cnd.where(BpmProcessTask::getPrevTaskId, "=", caseUnitTask.getId())
// .and("JSON_EXTRACT(createVariable, '$.isMaster')", "=", task.getCreateVariable().getBool("isMaster") ? "true" : "false")
// .and(BpmProcessTask::getTaskStatus, "=", BpmProcessTaskStatusEnum.ACTIVE.name())
// .and(BpmProcessTask::getDelFlag, "=", 0)
// );
Sql sql = Sqls.create("""
SELECT
COUNT(*)\s
FROM
bpm_process_task\s
WHERE
prevTaskId = @prevTaskId
AND JSON_EXTRACT( createVariable, '$.isMaster' )= TRUE\s
AND taskStatus = 'ACTIVE'\s
AND processTaskNodeCode = 80\s
AND delFlag =0
""");
sql.setParam("prevTaskId",caseUnitTask.getId());
sql.setCallback(Sqls.callback.integer());
execute(sql);
int anInt = sql.getInt();
if(anInt == 0){
throw new BaseException("主办单位已经答复完成,无法撤回,如需修改答复内容请联系校工会");
}else{
bpmService.revokeTask(replyTask.getId());
}
}
/**
* 同一批次承办单位答复任务未全部完成时,只完结当前任务,不触发流程流转。
* 等最后一条 reply 任务提交时,再交给流程引擎继续往下走。
*/
private void executeSingleFlowTask(Dict args) {
Long processTaskId = args.getLong(FlowConst.PROCESS_TASK_ID_KEY);
ProcessTask currentTask = dao().fetch(ProcessTask.class, processTaskId);
if (currentTask == null || !ProcessTaskStateEnum.DOING.getCode().equals(currentTask.getTaskState())) {
throw new BaseException("没有进行中的流程任务");
}
String operator = resolveFlowExecuteOperator(args);
if (!processTaskService.isAllowed(currentTask, operator)) {
throw new BaseException("当前参与者不能执行该流程任务");
}
Dict executeArgs = buildFlowExecuteArgs(args);
if (shouldOnlyFinishCurrentReplyTask(currentTask, executeArgs)) {
/*
* 主办单位可能先于协办单位提交,此时校领导候选人要先写入流程实例变量,
* 这样最后一条 reply 任务触发流转时,下一节点仍能拿到主办单位选择的办理人。
*/
persistSharedReplyArgs(currentTask.getProcessInstanceId(), executeArgs);
/*
* 会签节点如果配置了完成条件,最后一条任务真正走引擎时仍会读取流程实例里的计数器。
* 因此前面这些“只完结不流转”的任务,也要同步补齐会签统计,避免最后一条被误判退回。
*/
persistCountersignProgress(currentTask, executeArgs);
processTaskService.finishProcessTask(currentTask.getId(), operator, executeArgs);
return;
}
flowCommonService.executeTask(args);
}
@Override
public String checkCanReply(String taskId) {
// 获取提案配置
ProposalConfig config = dao().fetch(ProposalConfig.class, Cnd.NEW());
// 如果不需要协办单位先答复,直接返回null
if (!Boolean.TRUE.equals(config.getSlaveUnitFirstReply())) {
return null;
/**
* 仅在“正常提交”场景下拦截流程继续往后流转。
* 只要同一批次还有别的承办单位 reply 待办,就让当前任务先单独完结。
*/
private boolean shouldOnlyFinishCurrentReplyTask(ProcessTask currentTask, Dict executeArgs) {
Integer submitType = executeArgs.getInt(FlowConst.SUBMIT_TYPE);
if (!ProcessSubmitTypeEnum.AGREE.getCode().equals(submitType)) {
return false;
}
BpmProcessTask task = dao().fetch(BpmProcessTask.class, taskId);
// 如果不是主办单位,直接返回null
if (!task.getCreateVariable().getBool("isMaster", false)) {
return null;
Long batchParentTaskId = resolveReplyBatchParentTaskId(currentTask, currentTask.getTaskName());
if (batchParentTaskId == null || batchParentTaskId <= 0) {
return false;
}
// 查询同一批次的其他活动任务
List<BpmProcessTask> activeTasks = dao().query(BpmProcessTask.class,
Cnd.where("prevTaskId", "=", task.getPrevTaskId())
.and("id", "!=", task.getId())
.and("taskStatus", "=", BpmProcessTaskStatusEnum.ACTIVE.name())
.and("delFlag", "=", 0)
List<ProcessTask> doingReplyTasks = dao().query(
ProcessTask.class,
Cnd.where("processInstanceId", "=", currentTask.getProcessInstanceId())
.and("taskState", "=", ProcessTaskStateEnum.DOING.getCode())
.and("taskName", "=", currentTask.getTaskName())
);
// 如果还有未完成的协办任务,返回提示信息
return activeTasks.isEmpty() ? null :
activeTasks.stream()
.map(t -> t.getCreateVariable().getStr("underTakeName"))
.filter(Objects::nonNull)
.collect(Collectors.joining(",")) + "协办单位还未答复完成,暂时无法操作,您可以点击查看按钮关注协办单位办理进度。<br/> 如果您已经线下和协办单位交流沟通完成,请点击答复按钮进行答复。";
return doingReplyTasks.stream()
.filter(task -> !task.getId().equals(currentTask.getId()))
.anyMatch(task -> batchParentTaskId.equals(resolveReplyBatchParentTaskId(task, currentTask.getTaskName())));
}
@Override
public void revokeTransfer(String taskId) {
bpmService.revokeTask(taskId);
/**
* 转办会把新任务的 parentId 指向原 reply 任务,因此这里要一直向上追溯,
* 找到本批次承办单位答复任务共同归属的上游节点ID,作为“同一批次”的判定依据。
*/
private Long resolveReplyBatchParentTaskId(ProcessTask task, String taskName) {
Long batchParentTaskId = task.getTaskParentId();
Long parentTaskId = task.getTaskParentId();
while (parentTaskId != null && parentTaskId > 0) {
ProcessTask parentTask = dao().fetch(ProcessTask.class, parentTaskId);
if (parentTask == null || !taskName.equals(parentTask.getTaskName())) {
break;
}
batchParentTaskId = parentTask.getTaskParentId();
parentTaskId = parentTask.getTaskParentId();
}
return batchParentTaskId;
}
/**
* old-flow 的 executeTask 会补齐办理人信息并移除 processTaskId。
* 前置完结当前任务时,也要保持同样的数据结构,避免任务变量格式不一致。
*/
private Dict buildFlowExecuteArgs(Dict args) {
Dict executeArgs = args.clone();
executeArgs.remove(FlowConst.PROCESS_TASK_ID_KEY);
Integer submitType = executeArgs.getInt(FlowConst.SUBMIT_TYPE);
if (submitType == null) {
submitType = ProcessSubmitTypeEnum.AGREE.getCode();
}
executeArgs.put(FlowConst.SUBMIT_TYPE, submitType);
executeArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "userName", SecurityUtil.getUserUsername());
executeArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "loginName", SecurityUtil.getUserLoginname());
executeArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "unitId", SecurityUtil.getUnitId());
executeArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "unitName", SecurityUtil.getUnitId());
executeArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "unionId", SecurityUtil.getUnionId());
return executeArgs;
}
/**
* 承办单位答复环节真正往下流转时,下一节点可能依赖主办单位预先选择的候选人。
* 这里只把跨任务共享所需的字段写入流程实例,避免把每个单位自己的答复内容互相覆盖。
*/
private void persistSharedReplyArgs(Long processInstanceId, Dict executeArgs) {
Dict sharedArgs = Dict.create();
if (StrUtil.isNotBlank(executeArgs.getStr(FlowConst.NEXT_NODE_OPERATOR))) {
sharedArgs.put(FlowConst.NEXT_NODE_OPERATOR, executeArgs.getStr(FlowConst.NEXT_NODE_OPERATOR));
}
if (StrUtil.isNotBlank(executeArgs.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "nextNodeOperatorName"))) {
sharedArgs.put(FlowConst.TASK_FORM_DATA_PREFIX + "nextNodeOperatorName", executeArgs.getStr(FlowConst.TASK_FORM_DATA_PREFIX + "nextNodeOperatorName"));
}
if (!sharedArgs.isEmpty()) {
processInstanceService.addVariable(processInstanceId, sharedArgs);
}
}
/**
* 前面的 reply 任务虽然不触发节点流转,但依然属于会签实例的一部分。
* 这里补齐流程实例上的会签计数,保证最后一条任务进入引擎时,计数与真实完结数一致。
*/
private void persistCountersignProgress(ProcessTask currentTask, Dict executeArgs) {
if (!ProcessTaskPerformTypeEnum.COUNTERSIGN.getCode().equals(currentTask.getPerformType())) {
return;
}
String prefix = FlowConst.COUNTERSIGN_VARIABLE_PREFIX + currentTask.getTaskName() + "_";
List<ProcessTask> doingSameNameTasks = dao().query(
ProcessTask.class,
Cnd.where("processInstanceId", "=", currentTask.getProcessInstanceId())
.and("taskState", "=", ProcessTaskStateEnum.DOING.getCode())
.and("taskName", "=", currentTask.getTaskName())
);
Dict addVariable = Dict.create();
addVariable.put(prefix + FlowConst.NR_OF_COMPLETED_INSTANCES,
getProcessInstanceIntValue(currentTask.getProcessInstanceId(), prefix + FlowConst.NR_OF_COMPLETED_INSTANCES) + 1);
if (!executeArgs.containsKey(FlowConst.COUNTERSIGN_DISAGREE_FLAG)) {
addVariable.put(prefix + FlowConst.NR_OF_COMPLETED_AGREE_INSTANCES,
getProcessInstanceIntValue(currentTask.getProcessInstanceId(), prefix + FlowConst.NR_OF_COMPLETED_AGREE_INSTANCES) + 1);
}
addVariable.put(prefix + FlowConst.NR_OF_ACTIVATE_INSTANCES,
Math.max(doingSameNameTasks.size() - 1, 0));
processInstanceService.addVariable(currentTask.getProcessInstanceId(), addVariable);
}
/**
* old-flow 会签计数统一保存在流程实例变量里,这里读取当前值并转成整型,便于补写增量。
*/
private int getProcessInstanceIntValue(Long processInstanceId, String key) {
ProcessInstance processInstance = processInstanceService.getById(processInstanceId);
if (processInstance == null || StrUtil.isBlank(processInstance.getVariable())) {
return 0;
}
Dict variable = cn.hutool.json.JSONUtil.toBean(processInstance.getVariable(), Dict.class);
/*
* 当前项目使用的 Hutool Dict 不支持 getInt(key, defaultValue) 这种重载。
* 会签计数键在首次提交前可能还没写入流程实例变量,这里需要先显式判空,
* 避免 Integer 为 null 时自动拆箱触发空指针。
*/
Integer value = variable.getInt(key);
return value == null ? 0 : value;
}
/**
* 与 old-flow 公共执行逻辑保持一致,支持开启扩展执行人时以管理员身份提交。
*/
private String resolveFlowExecuteOperator(Dict args) {
String operator = SecurityUtil.getUserId();
if (args.containsKey(FlowConst.EXT_ENABLE_OPERATOR) && args.getBool(FlowConst.EXT_ENABLE_OPERATOR)) {
operator = FlowConst.ADMIN_ID;
}
return operator;
}
/**
* “编辑答复内容”只能针对已经完成的承办单位答复任务。
* 这里统一校验任务存在性、节点范围和任务状态,避免页面把其他流程节点误传进来。
*/
private ProcessTask getEditableReplyTask(Long taskId) {
ProcessTask replyTask = dao().fetch(ProcessTask.class, taskId);
if (replyTask == null) {
throw new BaseException("未找到答复任务");
}
if (!List.of("unit_reply", "two_unit_reply", "opinion_master_reply").contains(replyTask.getTaskName())) {
throw new BaseException("当前任务不支持编辑答复内容");
}
if (!Objects.equals(ProcessTaskStateEnum.FINISHED.getCode(), replyTask.getTaskState())) {
throw new BaseException("只有已完成的答复任务才能编辑内容");
}
return replyTask;
}
}
@@ -21,10 +21,10 @@ const PROPOSAL_INFO = {
</el-descriptions-item>
<el-descriptions-item label="提案类别">
{{viewData.typeName}}
</el-descriptions-item>
</el-descriptions-item><!--
<el-descriptions-item label="建议承办单位">
{{viewData.suggestUnits}}
</el-descriptions-item>
</el-descriptions-item>-->
<el-descriptions-item label="立案结果" :span="2">
<dict-tag :options="dict.type.PROPOSAL_CASE_FILING_RESULT"
:value="viewData.caseFilingResult"></dict-tag>
@@ -144,7 +144,7 @@ const PROPOSAL_INFO = {
<!--提案委员会立案-->
<el-descriptions border class="flow-task-form" :column="3" :key="task.id"
v-else-if="task.taskName === 'committee'">
v-else-if="task.taskName === 'committee'||task.taskName === 'committeeFilingUnit'">
<el-descriptions-item label="办理用户">{{ task.taskFormData.userName
}}({{task.taskFormData.loginName}})
</el-descriptions-item>
@@ -162,10 +162,16 @@ const PROPOSAL_INFO = {
</template>
</div>
</el-descriptions-item>
<el-descriptions-item label="主办单位" :span="3">{{task.ext.tf_masterUnitName}}
</el-descriptions-item>
<el-descriptions-item label="协办单位" :span="3">{{task?.ext?.tf_slaveUnitNameStr}}
</el-descriptions-item>
<template v-if="['CONFIRM_FILING','SUGGESTION'].includes(task.ext.tf_caseFilingResult)">
<el-descriptions-item v-if="task.ext.tf_caseFilingResult === 'SUGGESTION'" label="承办单位" :span="3">{{task?.ext?.tf_masterUnitNameStr || task?.ext?.tf_slaveUnitNameStr}}
</el-descriptions-item>
<template v-else>
<el-descriptions-item label="主办单位" :span="3">{{task?.ext?.tf_masterUnitNameStr}}
</el-descriptions-item>
<el-descriptions-item label="协办单位" :span="3">{{task?.ext?.tf_slaveUnitNameStr}}
</el-descriptions-item>
</template>
</template>
<el-descriptions-item label="办理意见" :span="3">
<div v-html="task.taskFormData.tf_opinion"></div>
</el-descriptions-item>
@@ -173,7 +179,7 @@ const PROPOSAL_INFO = {
<el-descriptions border class="flow-task-form" :column="3" :key="task.id" v-else>
<el-descriptions-item label="承办单位"
v-if="['master_reply','slave_reply'].includes(task.taskName)" :span="3">
v-if="['opinion_unit_reply','unit_reply','two_unit_reply','master_reply','slave_reply'].includes(task.taskName)" :span="3">
{{task.ext.underTakeName}}
</el-descriptions-item>
@@ -244,6 +250,8 @@ const PROPOSAL_INFO = {
this.$axios.post("/flow/common/doneTasks", {bizId: this.row.id}).then((res) => {
if (res.code === 0) {
this.doneTasks = res.data
// 通知外层页面已办节点数据已加载完成,便于当前环节做表单回显。
this.$emit("done-tasks", res.data)
}
})
},
@@ -156,6 +156,9 @@ layout("/layouts/platform.html"){
<enum-tag :value="row.instanceState" name="ProcessInstanceStateEnum" label_key="message"
size="small"></enum-tag>
</template>
<template v-else-if="column.prop === 'undertakeUnits'" scope="{row}">
{{ getUndertakeDisplay(row) }}
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" min-width="200px">
<template scope="{row}">
@@ -211,14 +214,41 @@ layout("/layouts/platform.html"){
{label: "是否并案", prop: "merge"},
{label: "案由", prop: "brief", visible: false},
{label: "建议措施", prop: "measures", visible: false},
{label: "办单位", prop: "masterUnitName"},
{label: "协办单位", prop: "slaveUnitNames"},
{label: "办单位", prop: "undertakeUnits", width: "260px"},
{label: "当前节点", prop: "curTaskName"},
{label: "流程状态", prop: "instanceState"}
]
}
},
methods: {
/**
* 导出列表页沿用查询口径,确保“作为建议”展示为承办单位,
* “确定立案”则保留主办/协办信息。
*/
getUndertakeDisplay(row) {
var masterUnitNames = this.formatUnitNames(row.masterUnitName)
var slaveUnitNames = this.formatUnitNames(row.slaveUnitNames)
if (row.caseFilingResult === "SUGGESTION") {
return masterUnitNames || slaveUnitNames
}
if (row.caseFilingResult === "CONFIRM_FILING") {
return [masterUnitNames ? "主办:" + masterUnitNames : "", slaveUnitNames ? "协办:" + slaveUnitNames : ""].filter(function(item) {
return item
}).join("")
}
return ""
},
formatUnitNames(unitNames) {
if (!unitNames) {
return ""
}
if (Array.isArray(unitNames)) {
return unitNames.filter(function(item) {
return item
}).join("")
}
return unitNames
},
openView(row) {
this.$refs.guava.view(() => {
this.$refs.infoRef.onOpen(row)
@@ -222,6 +222,9 @@ layout("/layouts/platform.html"){
<enum-tag :value="row.instanceState" name="ProcessInstanceStateEnum" label_key="message"
size="small"></enum-tag>
</template>
<template v-else-if="column.prop === 'undertakeUnits'" scope="{row}">
{{ getUndertakeDisplay(row) }}
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" width="200px">
<template scope="{row}">
@@ -260,8 +263,7 @@ layout("/layouts/platform.html"){
{label: "立案结果", prop: "caseFilingResult"},
{label: "立案类型", prop: "caseFilingType"},
{label: "是否并案", prop: "merge"},
{label: "办单位", prop: "masterUnitName"},
{label: "协办单位", prop: "slaveUnitNames"},
{label: "办单位", prop: "undertakeUnits", width: "260px"},
{label: "当前节点", prop: "curTaskName"},
{label: "流程状态", prop: "instanceState"}
],
@@ -301,6 +303,34 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* 查询列表按立案结果切换承办单位展示口径:
* 立案显示“主办/协办”,作为建议只显示“承办单位”。
*/
getUndertakeDisplay(row) {
var masterUnitNames = this.formatUnitNames(row.masterUnitName)
var slaveUnitNames = this.formatUnitNames(row.slaveUnitNames)
if (row.caseFilingResult === "SUGGESTION") {
return masterUnitNames || slaveUnitNames
}
if (row.caseFilingResult === "CONFIRM_FILING") {
return [masterUnitNames ? "主办:" + masterUnitNames : "", slaveUnitNames ? "协办:" + slaveUnitNames : ""].filter(function(item) {
return item
}).join("")
}
return ""
},
formatUnitNames(unitNames) {
if (!unitNames) {
return ""
}
if (Array.isArray(unitNames)) {
return unitNames.filter(function(item) {
return item
}).join("")
}
return unitNames
},
openView(row) {
this.$refs.guava.view(() => {
this.$refs.infoRef.onOpen(row)
@@ -116,8 +116,11 @@ layout("/layouts/platform.html"){
<el-tag v-else type="warning" size="small"></el-tag>
</template>
</el-table-column>
<el-table-column label="办单位" prop="masterUnitName" show-overflow-tooltip></el-table-column>
<el-table-column label="协办单位" prop="slaveUnitNames" show-overflow-tooltip></el-table-column>
<el-table-column label="办单位" prop="undertakeUnits" show-overflow-tooltip>
<template slot-scope="{row}">
{{ getUndertakeDisplay(row) }}
</template>
</el-table-column>
<el-table-column prop="curTaskName" label="当前节点"></el-table-column>
<el-table-column prop="instanceState" label="流程状态">
<template slot-scope="{row}">
@@ -169,6 +172,34 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* 历史查询里统一把承办单位合并成一列展示,
* 便于“确定立案”和“作为建议”两种口径同时查看。
*/
getUndertakeDisplay(row) {
var masterUnitNames = this.formatUnitNames(row.masterUnitName)
var slaveUnitNames = this.formatUnitNames(row.slaveUnitNames)
if (row.caseFilingResult === "SUGGESTION") {
return masterUnitNames || slaveUnitNames
}
if (row.caseFilingResult === "CONFIRM_FILING") {
return [masterUnitNames ? "主办:" + masterUnitNames : "", slaveUnitNames ? "协办:" + slaveUnitNames : ""].filter(function(item) {
return item
}).join("")
}
return ""
},
formatUnitNames(unitNames) {
if (!unitNames) {
return ""
}
if (Array.isArray(unitNames)) {
return unitNames.filter(function(item) {
return item
}).join("")
}
return unitNames
},
openView(row) {
this.$refs.guava.view(() => {
this.$refs.infoRef.onOpen(row)
@@ -112,8 +112,11 @@ layout("/layouts/platform.html"){
<el-tag size="mini" v-else type="danger"></el-tag>
</template>
</el-table-column>
<el-table-column label="办单位" prop="masterUnitName" show-overflow-tooltip></el-table-column>
<el-table-column label="协办单位" prop="slaveUnitNames" show-overflow-tooltip></el-table-column>
<el-table-column label="办单位" prop="undertakeUnits" show-overflow-tooltip>
<template slot-scope="{row}">
{{ getUndertakeDisplay(row) }}
</template>
</el-table-column>
<el-table-column prop="curTaskName" label="当前节点"></el-table-column>
<el-table-column prop="instanceState" label="流程状态">
<template slot-scope="{row}">
@@ -163,6 +166,34 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* 年报查询列表里,把主办/协办与建议承办统一折叠成一个展示口径,
* 避免“作为建议”场景下仍显示主办/协办文案。
*/
getUndertakeDisplay(row) {
var masterUnitNames = this.formatUnitNames(row.masterUnitName)
var slaveUnitNames = this.formatUnitNames(row.slaveUnitNames)
if (row.caseFilingResult === "SUGGESTION") {
return masterUnitNames || slaveUnitNames
}
if (row.caseFilingResult === "CONFIRM_FILING") {
return [masterUnitNames ? "主办:" + masterUnitNames : "", slaveUnitNames ? "协办:" + slaveUnitNames : ""].filter(function(item) {
return item
}).join("")
}
return ""
},
formatUnitNames(unitNames) {
if (!unitNames) {
return ""
}
if (Array.isArray(unitNames)) {
return unitNames.filter(function(item) {
return item
}).join("")
}
return unitNames
},
openView(row) {
this.$refs.guava.view(() => {
this.$refs.infoRef.onOpen(row)
@@ -2,106 +2,118 @@
layout("/layouts/platform.html"){
#-->
<div id="app" v-cloak>
<guava ref="guava">
<el-card shadow="never">
<search @search="doSearch">
<search-item label="教代会">
<el-select @change="meetingChange" clearable filterable placeholder="所属教代会"
v-model="pageForm.sessionId">
<el-option :key="item.id" :label="item.fullName" :value="item.id"
v-for="item in sessionOptions"></el-option>
</el-select>
</search-item>
<search-item label="提案名称">
<el-input v-model="pageForm.name" placeholder="提案名称" @keyup.enter.native="doSearch" clearable
style="width: 100%"></el-input>
</search-item>
<search-item label="姓名/工号">
<el-input placeholder="请输入姓名或工号" clearable v-model="pageForm.createUserKeyword"></el-input>
</search-item>
</search>
</el-card>
<el-card shadow="never">
<table-tool :columns.sync="tableColumns">
</table-tool>
<el-table :data="tableData" @sort-change="pageOrder" style="width: 100%">
<el-table-column label="序号" width="50" type="index" :index="indexMethod" fixed="left"></el-table-column>
<el-table-column
:label="column.label"
:prop="column.prop"
:key="column.key"
:min-width="column.width"
:fixed="column.fixed"
show-overflow-tooltip
v-for="column in tableColumns"
v-if="column.visible !== false"
>
<template v-if="column.prop === 'instanceState'" scope="{row}">
<enum-tag :value="row.instanceState" name="ProcessInstanceStateEnum" label_key="message"
size="small"></enum-tag>
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" width="300px">
<template slot-scope="{row}">
<el-button @click="openView(row)" size="mini" type="primary">查看</el-button>
<el-button v-if="row.taskState === 10" @click="openAudit(row)" size="mini" type="primary">审核
</el-button>
<el-button v-if="row.canRevoke" @click="onRevoke(row)" size="mini" type="danger">撤回
</el-button>
</template>
</el-table-column>
</el-table>
<!--#include("/layouts/pagination.html"){}#-->
</el-card>
</guava>
<guava ref="guava">
<el-card shadow="never">
<search @search="doSearch">
<search-item label="教代会">
<el-select @change="meetingChange" clearable filterable placeholder="所属教代会"
v-model="pageForm.sessionId">
<el-option :key="item.id" :label="item.fullName" :value="item.id"
v-for="item in sessionOptions"></el-option>
</el-select>
</search-item>
<search-item label="提案名称">
<el-input v-model="pageForm.name" placeholder="提案名称" @keyup.enter.native="doSearch" clearable
style="width: 100%"></el-input>
</search-item>
<search-item label="姓名/工号">
<el-input placeholder="请输入姓名或工号" clearable v-model="pageForm.createUserKeyword"></el-input>
</search-item>
</search>
</el-card>
<el-card shadow="never">
<table-tool :columns.sync="tableColumns">
</table-tool>
<el-table :data="tableData" @sort-change="pageOrder" style="width: 100%">
<el-table-column label="序号" width="50" type="index" :index="indexMethod"
fixed="left"></el-table-column>
<el-table-column
:label="column.label"
:prop="column.prop"
:key="column.key"
:min-width="column.width"
:fixed="column.fixed"
show-overflow-tooltip
v-for="column in tableColumns"
v-if="column.visible !== false"
>
<template v-if="column.prop === 'instanceState'" scope="{row}">
<enum-tag :value="row.instanceState" name="ProcessInstanceStateEnum" label_key="message"
size="small"></enum-tag>
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" width="100px">
<template slot-scope="{row}">
<el-button @click="openView(row)" size="mini" type="primary">查看</el-button>
</template>
</el-table-column>
</el-table>
<!--#include("/layouts/pagination.html"){}#-->
</el-card>
<template #edit>
<proposal-info ref="proposalInfoRef">
</proposal-info>
</template>
</guava>
</div>
<script nonce="${cspNonce!}">
<!--#include('../../common/info.js'){}#-->
new Vue({
el: "#app",
store,
mixins: [initTableMixins],
components: {
"proposal-info": PROPOSAL_INFO
},
data() {
return {
tableColumns: [
{label: "提案编号", prop: "code"},
{label: "提案名称", prop: "name", width: "200px"},
{label: "提案人", prop: "createUserName", width: "80px"},
{label: "提案类别", prop: "typeName"},
{label: "届次", prop: "sessionName"},
{label: "代表团", prop: "delegationName"},
{label: "流程状态", prop: "instanceState"}
],
pageForm: {
approval: false
},
showApprovalForm: false,
}
},
created() {
this.pageData()
this.listOpenSession()
},
methods: {
// 查询开启的教代会
listOpenSession() {
this.$axios.post("/platform/proposal/common/listOpenSession").then((res) => {
if (res.code === 0) {
this.sessionOptions = res.data
if (this.sessionOptions) {
this.$set(this.pageForm, "sessionId", this.sessionOptions[0].id)
this.pageData()
this.listDelegation()
}
}
})
},
}
})
<!--#include('../../common/info.js'){}#-->
new Vue({
el: "#app",
store,
mixins: [initTableMixins],
components: {
"proposal-info": PROPOSAL_INFO
},
data() {
return {
tableColumns: [
{label: "提案编号", prop: "code"},
{label: "提案名称", prop: "name", width: "200px"},
{label: "提案人", prop: "createUserName", width: "80px"},
{label: "提案类别", prop: "typeName"},
{label: "届次", prop: "sessionName"},
{label: "代表团", prop: "delegationName"},
{label: "流程状态", prop: "instanceState"}
],
pageForm: {
approval: false
},
showApprovalForm: false,
sessionOptions:[]
}
},
created() {
this.pageData()
this.listOpenSession()
},
methods: {
// 教代会
async meetingChange(val) {
this.doSearch()
},
openView(row) {
this.$refs.guava.edit(() => {
this.showApprovalForm = false
this.$refs.proposalInfoRef.onOpen(row)
})
},
// 查询开启的教代会
listOpenSession() {
this.$axios.post("/platform/proposal/common/listOpenSession").then((res) => {
if (res.code === 0) {
this.sessionOptions = res.data
if (this.sessionOptions) {
this.$set(this.pageForm, "sessionId", this.sessionOptions[0].id)
this.pageData()
this.listDelegation()
}
}
})
},
}
})
</script>
<!--#
}
@@ -45,7 +45,7 @@ layout("/layouts/platform.html"){
size="small"></enum-tag>
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" width="300px">
<el-table-column label="操作" fixed="right" width="200px">
<template slot-scope="{row}">
<el-button @click="openView(row)" size="mini" type="primary">查看</el-button>
<el-button v-if="row.taskState === 10" @click="openAudit(row)" size="mini" type="primary">审核
@@ -57,7 +57,7 @@ layout("/layouts/platform.html"){
</el-table>
<!--#include("/layouts/pagination.html"){}#-->
</el-card>
<template #edit>
<proposal-info ref="proposalInfoRef">
<div v-if="showApprovalForm">
@@ -65,7 +65,7 @@ layout("/layouts/platform.html"){
{{formData.taskName}}
</div>
<el-form :model="formData" ref="formRef" :rules="formRules" label-width="150px" label-suffix="">
<el-row gutter="20">
<el-row :gutter="20">
<el-col :span="12">
<el-form-item label="审核人" proop="tf_username">
<el-input readonly v-model="formData.tf_username"></el-input>
@@ -87,9 +87,24 @@ layout("/layouts/platform.html"){
</el-radio>
</el-radio-group>
<span class="text-primary ml10" v-if="formData.tf_caseCheckNeedSecondReply">
(二次答复只需要主办单位答复)
(请选择需要进入二次答复的承办单位,可多选)
</span>
</el-form-item>
<el-form-item
label="答复单位"
prop="tf_secondReplyUnitIds"
v-if="formData.tf_caseCheckNeedSecondReply"
:rules="[{required:formData.tf_caseCheckNeedSecondReply === 1,message:'请选择需要二次答复的承办单位',trigger:['change','blur']}]"
>
<el-select v-model="formData.tf_secondReplyUnitIds" clearable filterable multiple style="width: 100%">
<el-option
v-for="item in replyUnitOptions"
:key="item.unitId"
:label="item.unitName + '' + (item.isMaster ? '主办' : '协办') + ''"
:value="item.unitId"
></el-option>
</el-select>
</el-form-item>
<el-form-item label="审批意见" prop="tf_opinion"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<user-opinion-textarea v-model="formData.tf_opinion"></user-opinion-textarea>
@@ -97,8 +112,8 @@ layout("/layouts/platform.html"){
</el-form>
<el-row type="flex" justify="end">
<el-button @click="$refs.guava.index()" size="small">取消</el-button>
<el-button @click="handleTaskAction(6)" size="small" type="info">退回到提案人</el-button>
<el-button @click="handleTaskAction(2)" size="small" type="danger">不同意</el-button>
<!-- <el-button @click="handleTaskAction(6)" size="small" type="info">退回到提案人</el-button>-->
<!-- <el-button @click="handleTaskAction(2)" size="small" type="danger">不同意</el-button>-->
<el-button @click="handleTaskAction(1)" size="small" type="primary">同意</el-button>
</el-row>
</div>
@@ -125,12 +140,15 @@ layout("/layouts/platform.html"){
{label: "届次", prop: "sessionName"},
{label: "代表团", prop: "delegationName"},
{label: "当前节点", prop: "curTaskName"},
{label: "流程状态", prop: "instanceState"}
{label: "流程状态", prop: "instanceState"},
{label: "办理时间", prop: "finishTime"}
],
pageForm: {
approval: false
},
showApprovalForm: false,
replyUnitOptions: [],
sessionOptions: [],
}
},
created() {
@@ -144,19 +162,27 @@ layout("/layouts/platform.html"){
this.$refs.proposalInfoRef.onOpen(row)
})
},
openAudit(row) {
this.loadReplyUnits(row.id)
this.$refs.guava.edit(() => {
this.showApprovalForm = true
this.formData = {
proposalId: row.id,
processTaskId: row.taskId,
taskName: row.curTaskName,
tf_auditTime: this.$moment().format('YYYY-MM-DD'),
tf_username: this.$store.state.user.username
tf_username: this.$store.state.user.username,
tf_caseCheckNeedSecondReply: 0,
tf_secondReplyUnitIds: []
}
this.$refs.proposalInfoRef.onOpen(row)
})
},
// 教代会
async meetingChange(val) {
this.doSearch()
},
// 查询开启的教代会
listOpenSession() {
this.$axios.post("/platform/proposal/common/listOpenSession").then((res) => {
@@ -170,7 +196,16 @@ layout("/layouts/platform.html"){
}
})
},
// 二次答复只能选择当前提案已配置的承办单位,避免误选到别的单位。
loadReplyUnits(proposalId) {
this.$axios.post("/platform/proposal/case/check/listReplyUnits", { proposalId: proposalId }).then((res) => {
if (res.code === 0) {
this.replyUnitOptions = res.data || []
}
})
},
handleTaskAction(val) {
this.$refs.formRef.validate(valid => {
if (!valid) return
@@ -179,9 +214,35 @@ layout("/layouts/platform.html"){
cancelButtonText: "取消",
type: "warning"
}).then(() => {
let submitData = Object.assign({}, this.formData)
if (submitData.tf_caseCheckNeedSecondReply === 1) {
let secondReplyUnits = this.replyUnitOptions.filter(item => submitData.tf_secondReplyUnitIds.indexOf(item.unitId) > -1)
let masterUnitIds = secondReplyUnits.filter(item => item.isMaster).map(item => item.unitId)
let slaveUnitIds = secondReplyUnits.filter(item => !item.isMaster).map(item => item.unitId)
let masterUnitNames = secondReplyUnits.filter(item => item.isMaster).map(item => item.unitName)
let slaveUnitNames = secondReplyUnits.filter(item => !item.isMaster).map(item => item.unitName)
submitData.tf_masterUnitIds = masterUnitIds
submitData.tf_masterUnitId = masterUnitIds.length ? masterUnitIds[0] : ""
submitData.tf_masterUnitName = masterUnitNames.length ? masterUnitNames[0] : ""
submitData.tf_masterUnitNames = masterUnitNames
submitData.tf_masterUnitNameStr = masterUnitNames.join(",")
submitData.tf_slaveUnitIds = slaveUnitIds
submitData.tf_slaveUnitNames = slaveUnitNames
submitData.tf_slaveUnitNameStr = slaveUnitNames.join(",")
} else {
submitData.tf_secondReplyUnitIds = []
submitData.tf_masterUnitIds = []
submitData.tf_masterUnitId = ""
submitData.tf_masterUnitName = ""
submitData.tf_masterUnitNames = []
submitData.tf_masterUnitNameStr = ""
submitData.tf_slaveUnitIds = []
submitData.tf_slaveUnitNames = []
submitData.tf_slaveUnitNameStr = ""
}
this.$axios.post("/flow/common/executeTask", {
data: JSON.stringify({
...this.formData,
...submitData,
submitType: val
})
}).then((res) => {
@@ -193,7 +254,22 @@ layout("/layouts/platform.html"){
})
})
})
}
},
onRevoke(row) {
this.$confirm("您确定要撤回吗?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "info"
}).then(() => {
this.$axios.post("/flow/common/revokeTask", { taskId: row.taskId }).then((res) => {
if (res.code === 0) {
this.$message.success(res.msg)
this.doSearch()
}
})
})
},
}
})
</script>
@@ -102,7 +102,7 @@ layout("/layouts/platform.html"){
<el-form :model="formData" ref="formRef" label-width="120px" :rules="formRules" label-suffix="">
<el-form-item label="立案结果" prop="tf_caseFilingResult"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small" @change="handleCaseFilingResultChange">
<el-radio v-for="item in dict.type.PROPOSAL_CASE_FILING_RESULT" :label="item.code"
border>{{item.label}}
</el-radio>
@@ -118,12 +118,13 @@ layout("/layouts/platform.html"){
</el-radio-group>
</el-form-item>
<el-form-item
label="主办单位"
:label="formData.tf_caseFilingResult === 'SUGGESTION' ? '承办单位' : '主办单位'"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:'必填',trigger:['change','blur']}]"
prop="tf_masterUnitId"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:formData.tf_caseFilingResult === 'SUGGESTION' ? '请选择承办单位' : '请选择主办单位',trigger:['change','blur']}]"
prop="tf_masterUnitIds"
>
<el-select v-model="formData.tf_masterUnitId" filterable clearable style="width: 100%">
<el-select v-model="formData.tf_masterUnitIds" filterable clearable multiple
style="width: 100%">
<el-option
v-for="item in underTakeOptions"
:label="item.name"
@@ -134,7 +135,7 @@ layout("/layouts/platform.html"){
</el-select>
</el-form-item>
<el-form-item label="协办单位"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
v-if="formData.tf_caseFilingResult === 'CONFIRM_FILING'"
prop="tf_slaveUnitIds"
>
<el-select v-model="formData.tf_slaveUnitIds" filterable clearable multiple
@@ -144,7 +145,7 @@ layout("/layouts/platform.html"){
:label="item.name"
:value="item.id"
:key="item.id"
:disabled="item.id===formData.tf_masterUnitId"
:disabled="formData && formData.tf_masterUnitIds.includes(item.id)"
></el-option>
</el-select>
</el-form-item>
@@ -197,13 +198,13 @@ layout("/layouts/platform.html"){
approval: false
},
formData: {
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
},
formRules: {
formRules: {
tf_caseFilingResult: [{ required: true, message: "请选择立案结果", trigger: ["blur", "change"] }],
tf_caseFilingType: [{ required: true, message: "请选择立案类型", trigger: ["blur", "change"] }],
tf_masterUnitId: [{ required: true, message: "请选择主办单位", trigger: "blur" }],
tf_masterUnitIds: [{ required: true, message: "请选择主办单位", trigger: "blur" }],
approvalOpinion: [{ required: true, message: "请填写审核意见", trigger: "blur" }]
},
showApprovalForm: false,
@@ -213,6 +214,23 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* “作为建议”不再区分主办/协办,只保留承办单位;
* 切到“不予立案”等结果时,同时清空已选单位,避免旧值被误提交。
*/
handleCaseFilingResultChange(caseFilingResult) {
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_caseFilingType", "")
}
if (caseFilingResult === "SUGGESTION") {
this.$set(this.formData, "tf_slaveUnitIds", [])
return
}
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_masterUnitIds", [])
this.$set(this.formData, "tf_slaveUnitIds", [])
}
},
openView(row) {
this.$refs.guava.edit(() => {
this.showApprovalForm = false
@@ -225,7 +243,7 @@ layout("/layouts/platform.html"){
this.formData = {
processTaskId: row.taskId,
taskName: row.curTaskName,
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
}
this.$refs.proposalInfoRef.onOpen(row)
@@ -240,9 +258,12 @@ layout("/layouts/platform.html"){
cancelButtonText: "取消",
type: "warning"
}).then(() => {
// “作为建议”统一按承办单位处理,提交时不再携带协办单位数据。
const masterUnitIds = this.formData.tf_masterUnitIds || []
const slaveUnitIds = this.formData.tf_caseFilingResult === "CONFIRM_FILING" ? (this.formData.tf_slaveUnitIds || []) : []
// 是否有协办单位
let tf_helpunitreply
if (this.formData.tf_slaveUnitIds && this.formData.tf_slaveUnitIds.length > 0) {
if (slaveUnitIds.length > 0) {
tf_helpunitreply = "HAS_HELP_UNIT"
} else {
tf_helpunitreply = "NO_HELP_UNIT"
@@ -252,10 +273,16 @@ layout("/layouts/platform.html"){
this.$axios.post("/flow/common/executeTask", {
data: JSON.stringify({
...this.formData,
tf_masterUnitIds: masterUnitIds,
tf_slaveUnitIds: slaveUnitIds,
submitType: val,
tf_masterUnitName: this.formData.tf_masterUnitId ? this.underTakeOptions.find(v => v.id === this.formData.tf_masterUnitId)?.name : null,
tf_slaveUnitNames: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(","),
// 兼容旧流程仍按单个主办单位字段取值的场景,这里保留第一个主办单位ID和名称。
tf_masterUnitId: masterUnitIds.length ? masterUnitIds[0] : "",
tf_masterUnitName: masterUnitIds.length ? this.underTakeOptions.find(v => v.id === masterUnitIds[0])?.name : "",
tf_masterUnitNames: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_masterUnitNameStr: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(","),
tf_slaveUnitNames: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(","),
tf_helpunitreply: tf_helpunitreply
})
}).then((res) => {
@@ -283,7 +310,7 @@ layout("/layouts/platform.html"){
this.$refs.mergeRef.onOpen(selection, {
processTaskIds: selection.map(v => v.taskId),
taskName: selection[0].curTaskName,
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
})
})
@@ -295,7 +322,8 @@ layout("/layouts/platform.html"){
cancelButtonText: "取消",
type: "info"
}).then(() => {
this.$axios.post("/flow/common/revokeTask", { taskId: row.taskId }).then((res) => {
// 提委会立案撤回需要走专用接口,确保并案提案会整组一起撤回。
this.$axios.post("/platform/proposal/committeeFiling/revokeTask", { taskId: row.taskId, proposalId: row.id }).then((res) => {
if (res.code === 0) {
this.$message.success(res.msg)
this.doSearch()
@@ -25,7 +25,7 @@ const merge = {
<el-form :model="formData" ref="formRef" label-width="120px" :rules="formRules" label-suffix="">
<el-form-item label="立案结果" prop="tf_caseFilingResult"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small" @change="handleCaseFilingResultChange">
<el-radio v-for="item in dict.type.PROPOSAL_CASE_FILING_RESULT" :label="item.code"
border>{{item.label}}
</el-radio>
@@ -41,12 +41,12 @@ const merge = {
</el-radio-group>
</el-form-item>
<el-form-item
label="主办单位"
:label="formData.tf_caseFilingResult === 'SUGGESTION' ? '承办单位' : '主办单位'"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:'必填',trigger:['change','blur']}]"
prop="tf_masterUnitId"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:formData.tf_caseFilingResult === 'SUGGESTION' ? '请选择承办单位' : '请选择主办单位',trigger:['change','blur']}]"
prop="tf_masterUnitIds"
>
<el-select v-model="formData.tf_masterUnitId" filterable clearable style="width: 100%">
<el-select v-model="formData.tf_masterUnitIds" filterable clearable multiple style="width: 100%">
<el-option
v-for="item in underTakeOptions"
:label="item.name"
@@ -57,7 +57,7 @@ const merge = {
</el-select>
</el-form-item>
<el-form-item label="协办单位"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
v-if="formData.tf_caseFilingResult === 'CONFIRM_FILING'"
prop="tf_slaveUnitIds"
>
<el-select v-model="formData.tf_slaveUnitIds" filterable clearable multiple
@@ -67,13 +67,13 @@ const merge = {
:label="item.name"
:value="item.id"
:key="item.id"
:disabled="item.id===formData.tf_masterUnitId"
:disabled="formData && formData.tf_masterUnitIds.includes(item.id)"
></el-option>
</el-select>
</el-form-item>
<el-form-item label="审核意见" prop="approvalOpinion"
<el-form-item label="审核意见" prop="tf_opinion"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<user-opinion-textarea v-model="formData.approvalOpinion"></user-opinion-textarea>
<user-opinion-textarea v-model="formData.tf_opinion"></user-opinion-textarea>
</el-form-item>
</el-form>
<el-row type="flex" justify="end">
@@ -89,19 +89,36 @@ const merge = {
return {
selection: [],
formData: {
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
},
formRules: {
tf_caseFilingResult: [{ required: true, message: "请选择立案结果", trigger: ["blur", "change"] }],
tf_caseFilingType: [{ required: true, message: "请选择立案类型", trigger: ["blur", "change"] }],
tf_masterUnitId: [{ required: true, message: "请选择主办单位", trigger: "blur" }],
approvalOpinion: [{ required: true, message: "请填写审核意见", trigger: "blur" }],
tf_masterUnitIds: [{ required: true, message: "请选择主办单位", trigger: "blur" }],
tf_opinion: [{ required: true, message: "请填写审核意见", trigger: "blur" }],
},
underTakeOptions: []
}
},
methods: {
/**
* 并案审核与单案审核保持同一口径
* 作为建议只录入承办单位不再区分协办单位
*/
handleCaseFilingResultChange(caseFilingResult) {
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_caseFilingType", "")
}
if (caseFilingResult === "SUGGESTION") {
this.$set(this.formData, "tf_slaveUnitIds", [])
return
}
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_masterUnitIds", [])
this.$set(this.formData, "tf_slaveUnitIds", [])
}
},
onOpen(selection, formData) {
this.selection = selection
this.formData = formData
@@ -124,40 +141,52 @@ const merge = {
})
},
handleTaskAction(val) {
this.$confirm("您确定要提交吗?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning"
}).then(() => {
debugger
// 是否有协办单位
let tf_helpunitreply;
if (this.formData.tf_slaveUnitIds && this.formData.tf_slaveUnitIds.length > 0) {
tf_helpunitreply = 'HAS_HELP_UNIT'
} else {
tf_helpunitreply = 'NO_HELP_UNIT'
}
this.$refs.formRef.validate(valid => {
if (valid) {
this.$confirm("您确定要提交吗?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning"
}).then(() => {
// 并案审核提交参数与单案立案页保持一致,避免两个入口的流程变量不一致。
const masterUnitIds = this.formData.tf_masterUnitIds || []
const slaveUnitIds = this.formData.tf_caseFilingResult === "CONFIRM_FILING" ? (this.formData.tf_slaveUnitIds || []) : []
// 是否有协办单位
let tf_helpunitreply
if (slaveUnitIds.length > 0) {
tf_helpunitreply = "HAS_HELP_UNIT"
} else {
tf_helpunitreply = "NO_HELP_UNIT"
}
const loading = createLoading('提交中')
this.$axios.post("/platform/proposal/committeeFiling/merge", {
data: JSON.stringify({
...this.formData,
proposalIds: this.selection.map(v => v.id),
submitType: val,
tf_masterUnitName: this.formData.tf_masterUnitId ? this.underTakeOptions.find(v => v.id === this.formData.tf_masterUnitId)?.name : null,
tf_slaveUnitNames: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
tf_helpunitreply: tf_helpunitreply
const loading = createLoading('提交中')
this.$axios.post("/platform/proposal/committeeFiling/merge", {
data: JSON.stringify({
...this.formData,
tf_masterUnitIds: masterUnitIds,
tf_slaveUnitIds: slaveUnitIds,
proposalIds: this.selection.map(v => v.id),
submitType: val,
// 兼容旧流程仍按单个主办单位字段取值的场景,这里保留第一个主办单位ID和名称。
tf_masterUnitId: masterUnitIds.length ? masterUnitIds[0] : "",
tf_masterUnitName: masterUnitIds.length ? this.underTakeOptions.find(v => v.id === masterUnitIds[0])?.name : "",
tf_masterUnitNames: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_masterUnitNameStr: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
tf_slaveUnitNames: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
tf_helpunitreply: tf_helpunitreply
})
}).then((res) => {
if (res.code === 0) {
this.$emit('close')
this.$message.success(res.msg)
this.doSearch()
}
}).finally(() => {
loading.close()
})
})
}).then((res) => {
if (res.code === 0) {
this.$emit('close')
this.$message.success(res.msg)
this.doSearch()
}
}).finally(() => {
loading.close()
})
}
})
}
}
@@ -103,7 +103,7 @@ layout("/layouts/platform.html"){
<el-form :model="formData" ref="formRef" label-width="120px" :rules="formRules" label-suffix="">
<el-form-item label="立案结果" prop="tf_caseFilingResult"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small">
<el-radio-group v-model="formData.tf_caseFilingResult" size="small" @change="handleCaseFilingResultChange">
<el-radio v-for="item in dict.type.PROPOSAL_CASE_FILING_RESULT" :label="item.code"
border>{{item.label}}
</el-radio>
@@ -119,12 +119,13 @@ layout("/layouts/platform.html"){
</el-radio-group>
</el-form-item>
<el-form-item
label="主办单位"
:label="formData.tf_caseFilingResult === 'SUGGESTION' ? '承办单位' : '主办单位'"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:'必填',trigger:['change','blur']}]"
prop="tf_masterUnitId"
:rules="[{required:['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult),message:formData.tf_caseFilingResult === 'SUGGESTION' ? '请选择承办单位' : '请选择主办单位',trigger:['change','blur']}]"
prop="tf_masterUnitIds"
>
<el-select v-model="formData.tf_masterUnitId" filterable clearable style="width: 100%">
<el-select v-model="formData.tf_masterUnitIds" filterable clearable multiple
style="width: 100%">
<el-option
v-for="item in underTakeOptions"
:label="item.name"
@@ -135,7 +136,7 @@ layout("/layouts/platform.html"){
</el-select>
</el-form-item>
<el-form-item label="协办单位"
v-if="['CONFIRM_FILING','SUGGESTION'].includes(formData.tf_caseFilingResult)"
v-if="formData.tf_caseFilingResult === 'CONFIRM_FILING'"
prop="tf_slaveUnitIds"
>
<el-select v-model="formData.tf_slaveUnitIds" filterable clearable multiple
@@ -145,7 +146,7 @@ layout("/layouts/platform.html"){
:label="item.name"
:value="item.id"
:key="item.id"
:disabled="item.id===formData.tf_masterUnitId"
:disabled="formData && formData.tf_masterUnitIds.includes(item.id)"
></el-option>
</el-select>
</el-form-item>
@@ -198,7 +199,7 @@ layout("/layouts/platform.html"){
approval: false
},
formData: {
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
},
showApprovalForm: false,
@@ -208,9 +209,55 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* “作为建议”场景下只保留承办单位,协办单位和立案类型都要及时清空,
* 避免旧表单值跟着一起提交到流程里。
*/
handleCaseFilingResultChange(caseFilingResult) {
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_caseFilingType", "")
}
if (caseFilingResult === "SUGGESTION") {
this.$set(this.formData, "tf_slaveUnitIds", [])
return
}
if (caseFilingResult !== "CONFIRM_FILING") {
this.$set(this.formData, "tf_masterUnitIds", [])
this.$set(this.formData, "tf_slaveUnitIds", [])
}
},
doUpData(){
this.$.axios.post(loc()+"/doUpData")
},
// 兼容流程变量返回数组、JSON 字符串、逗号分隔字符串三种情况,统一转成下拉框需要的数组。
normalizeUnitIds(unitIds) {
if (!unitIds) {
return []
}
if (Array.isArray(unitIds)) {
return unitIds
}
if (typeof unitIds === "string") {
var value = unitIds.trim()
if (!value) {
return []
}
if (value.indexOf("[") === 0) {
try {
var parsedValue = JSON.parse(value)
return Array.isArray(parsedValue) ? parsedValue : []
} catch (e) {
return []
}
}
return value.split(",").filter(function(item) {
return item && item.trim()
}).map(function(item) {
return item.trim()
})
}
return []
},
openView(row) {
this.$refs.guava.edit(() => {
this.showApprovalForm = false
@@ -218,11 +265,16 @@ layout("/layouts/platform.html"){
})
},
doneTasks(val) {
const data = val[val.length - 1]
if (!val || !val.length) {
return
}
// 当前页面需要回显上一环节“提案委员会立案”保存的主办/协办单位或承办单位。
var data = val[val.length - 1]
this.$set(this.formData, "tf_caseFilingResult", data.ext.tf_caseFilingResult)
this.$set(this.formData, "tf_caseFilingType", data.ext.tf_caseFilingType)
this.$set(this.formData, "tf_masterUnitId", data.ext.tf_masterUnitId)
this.$set(this.formData, "tf_slaveUnitIds", data.ext.tf_slaveUnitIds)
this.$set(this.formData, "tf_masterUnitIds", this.normalizeUnitIds(data.ext.tf_masterUnitIds))
this.$set(this.formData, "tf_slaveUnitIds", this.normalizeUnitIds(data.ext.tf_slaveUnitIds))
this.handleCaseFilingResultChange(this.formData.tf_caseFilingResult)
},
openAudit(row) {
this.$refs.guava.edit(() => {
@@ -231,7 +283,7 @@ layout("/layouts/platform.html"){
proposalId: row.id,
processTaskId: row.taskId,
taskName: row.curTaskName,
tf_masterUnitId: null,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
}
this.$refs.proposalInfoRef.onOpen(row)
@@ -246,9 +298,12 @@ layout("/layouts/platform.html"){
cancelButtonText: "取消",
type: "warning"
}).then(() => {
// “作为建议”统一按承办单位处理,提交时不再携带协办单位数据。
const masterUnitIds = this.formData.tf_masterUnitIds || []
const slaveUnitIds = this.formData.tf_caseFilingResult === "CONFIRM_FILING" ? (this.formData.tf_slaveUnitIds || []) : []
// 是否有协办单位
let tf_helpunitreply;
if (this.formData.tf_slaveUnitIds && this.formData.tf_slaveUnitIds.length > 0) {
if (slaveUnitIds.length > 0) {
tf_helpunitreply = 'HAS_HELP_UNIT'
} else {
tf_helpunitreply = 'NO_HELP_UNIT'
@@ -258,10 +313,16 @@ layout("/layouts/platform.html"){
this.$axios.post("/platform/proposal/committeeFilingUnit/executeTask", {
data: JSON.stringify({
...this.formData,
tf_masterUnitIds: masterUnitIds,
tf_slaveUnitIds: slaveUnitIds,
submitType: val,
tf_masterUnitName: this.formData.tf_masterUnitId ? this.underTakeOptions.find(v => v.id === this.formData.tf_masterUnitId)?.name : null,
tf_slaveUnitNames: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: this.formData.tf_slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
// 兼容旧流程仍按单个主办单位字段取值的场景,这里保留第一个主办单位ID和名称。
tf_masterUnitId: masterUnitIds.length ? masterUnitIds[0] : "",
tf_masterUnitName: masterUnitIds.length ? this.underTakeOptions.find(v => v.id === masterUnitIds[0])?.name : "",
tf_masterUnitNames: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_masterUnitNameStr: masterUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
tf_slaveUnitNames: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name),
tf_slaveUnitNameStr: slaveUnitIds.map(v => this.underTakeOptions.find(v2 => v2.id === v)?.name).join(','),
tf_helpunitreply: tf_helpunitreply
})
}).then((res) => {
@@ -285,12 +346,12 @@ layout("/layouts/platform.html"){
return
}
this.$refs.guava.public(() => {
this.$refs.mergeRef.onOpen(selection, {
processTaskIds: selection.map(v => v.taskId),
taskName: selection[0].curTaskName,
tf_masterUnitId: null,
tf_slaveUnitIds: []
})
this.$refs.mergeRef.onOpen(selection, {
processTaskIds: selection.map(v => v.taskId),
taskName: selection[0].curTaskName,
tf_masterUnitIds: [],
tf_slaveUnitIds: []
})
})
},
@@ -72,9 +72,9 @@ layout("/layouts/platform.html"){
<el-tag v-if="row.merge" size="small"></el-tag>
<el-tag v-else type="warning" size="small"></el-tag>
</template>
<template v-else-if="column.prop === 'underTakeIsMaster'" scope="{row}">
<el-tag v-if="row.underTakeIsMaster" size="small">主办</el-tag>
<el-tag v-else type="warning" size="small">协办</el-tag>
<template v-else-if="column.prop === 'undertakeUnits'" scope="{row}">
<div v-if="getUndertakeDisplay(row)" class="text-left">{{ getUndertakeDisplay(row) }}</div>
<span v-else>暂无</span>
</template>
<template v-else-if="column.prop === 'instanceState'" scope="{row}">
<enum-tag :value="row.instanceState" name="ProcessInstanceStateEnum" label_key="message"
@@ -134,6 +134,7 @@ layout("/layouts/platform.html"){
{label: "提案编号", prop: "code"},
{label: "提案名称", prop: "name", width: "200px"},
{label: "提案类别", prop: "typeName"},
{label: "承办单位", prop: "undertakeUnits", width: "260px"},
{label: "是否并案", prop: "merge"},
{label: "当前节点", prop: "curTaskName"},
{label: "审核人", prop: "auditUser"},
@@ -149,6 +150,34 @@ layout("/layouts/platform.html"){
}
},
methods: {
/**
* 校领导审批列表需要按立案结果切换承办单位展示口径:
* 确定立案显示主办/协办,作为建议只显示承办单位。
*/
getUndertakeDisplay(row) {
var masterUnitNames = this.formatUnitNames(row.masterUnitName)
var slaveUnitNames = this.formatUnitNames(row.slaveUnitNames)
if (row.caseFilingResult === "SUGGESTION") {
return masterUnitNames || slaveUnitNames
}
if (row.caseFilingResult === "CONFIRM_FILING") {
return [masterUnitNames ? "主办:" + masterUnitNames : "", slaveUnitNames ? "协办:" + slaveUnitNames : ""].filter(function(item) {
return item
}).join("")
}
return ""
},
formatUnitNames(unitNames) {
if (!unitNames) {
return ""
}
if (Array.isArray(unitNames)) {
return unitNames.filter(function(item) {
return item
}).join("")
}
return unitNames
},
openView(row) {
this.$refs.guava.edit(() => {
this.showApprovalForm = false
@@ -137,11 +137,15 @@ layout("/layouts/platform.html"){
{{row.transferUserName}}
</template>
</el-table-column>
<el-table-column label="操作" fixed="right" min-width="250px">
<el-table-column label="操作" fixed="right" min-width="320px">
<template slot-scope="{row}">
<el-button @click="openView(row)" size="mini" type="primary">查看</el-button>
<el-button v-if="row.taskState === 10" @click="openAudit(row)" size="mini" type="primary">答复
</el-button>
<!--历史答复内容只允许超级管理员修改,且只在已审核数据中开放入口。-->
<el-button v-if="pageForm.approval && row.taskState === 20 && $auth.hasRole('SYSADMIN')"
@click="openReplyEdit(row)" size="mini" type="warning">编辑答复
</el-button>
<el-button v-if="row.canRevoke" @click="onRevoke(row)" size="mini" type="danger">撤回
</el-button>
<!--承办单位领导、超级管理员才能转办-->
@@ -197,7 +201,7 @@ layout("/layouts/platform.html"){
</el-form>
<el-row type="flex" justify="end">
<el-button @click="$refs.guava.index()" size="small">取消</el-button>
<el-button @click="handleTaskAction(6)" size="small" type="info">退回到发起人</el-button>
<!-- <el-button @click="handleTaskAction(6)" size="small" type="info">退回到发起人</el-button>-->
<el-button @click="handleTaskAction(1)" size="small" type="primary">提交</el-button>
</el-row>
</div>
@@ -247,6 +251,25 @@ layout("/layouts/platform.html"){
</el-row>
</el-dialog>
<el-dialog title="编辑答复内容" :visible.sync="showReplyEditDialog" width="900px" append-to-body>
<el-form ref="replyEditFormRef" :model="replyEditForm" label-width="80px">
<el-form-item label="提案编号">
<el-input :value="replyEditForm.code" disabled></el-input>
</el-form-item>
<el-form-item label="提案名称">
<el-input :value="replyEditForm.name" disabled></el-input>
</el-form-item>
<el-form-item label="答复内容" prop="tf_opinion"
:rules="[{required:true,message:'必填',trigger:['change','blur']}]">
<text-editor v-model="replyEditForm.tf_opinion"></text-editor>
</el-form-item>
</el-form>
<el-row type="flex" justify="end">
<el-button @click="showReplyEditDialog = false" size="small">取消</el-button>
<el-button @click="handleReplyEdit" size="small" type="primary">保存</el-button>
</el-row>
</el-dialog>
</div>
<script nonce="${cspNonce!}">
@@ -288,6 +311,10 @@ layout("/layouts/platform.html"){
showTransferDialog: false,
transferForm: {},
transferUserOptions: [],
// 超级管理员编辑历史答复内容
showReplyEditDialog: false,
replyEditForm: {},
}
},
methods: {
@@ -299,7 +326,7 @@ layout("/layouts/platform.html"){
},
async openAudit(row) {
this.loadCandidates(row.taskId)
try{
await this.$confirm("是否已与提案代表进行充分沟通?", "提示", {
confirmButtonText: "是",
@@ -325,6 +352,55 @@ layout("/layouts/platform.html"){
})
},
// 超级管理员编辑已答复任务的答复内容,仅回显和提交 tf_opinion 字段。
openReplyEdit(row) {
const loading = createLoading('加载中')
this.$axios.post("/platform/proposal/unitReply/getReplyOpinion", {taskId: row.taskId}).then((res) => {
if (res.code === 0) {
this.replyEditForm = {
taskId: row.taskId,
code: row.code,
name: row.name,
tf_opinion: res.data ? res.data.tf_opinion : ""
}
this.showReplyEditDialog = true
this.$nextTick(() => {
if (this.$refs.replyEditFormRef) {
this.$refs.replyEditFormRef.clearValidate()
}
})
}
}).finally(() => {
loading.close()
})
},
// 历史答复编辑只保存答复内容,不修改落实情况、附件等其他字段。
handleReplyEdit() {
this.$refs.replyEditFormRef.validate((valid) => {
if (!valid) return
this.$confirm("您确定要保存答复内容吗?", "提示", {
confirmButtonText: "确定",
cancelButtonText: "取消",
type: "warning"
}).then(() => {
const loading = createLoading('保存中')
this.$axios.post("/platform/proposal/unitReply/updateReplyOpinion", {
taskId: this.replyEditForm.taskId,
opinion: this.replyEditForm.tf_opinion
}).then((res) => {
if (res.code === 0) {
this.$message.success(res.msg)
this.showReplyEditDialog = false
this.doSearch()
}
}).finally(() => {
loading.close()
})
})
})
},
handleTaskAction(val) {
if(val === 6) {
this.handleTaskConfirm(val)
@@ -335,7 +411,7 @@ layout("/layouts/platform.html"){
})
}
},
handleTaskConfirm(val) {
this.$confirm("您确定要提交吗?", "提示", {
confirmButtonText: "确定",
@@ -343,10 +419,10 @@ layout("/layouts/platform.html"){
type: "warning"
}).then(() => {
const loading = createLoading('提交中')
delete this.formData.underTakeIsMaster
delete this.formData.underTakeName
this.$axios.post("/platform/proposal/unitReply/executeTask", {
data: JSON.stringify({
...this.formData,
@@ -20,9 +20,9 @@ const PROPOSAL_INFO = {
<van-cell title="提案类别">
{{viewData.typeName}}
</van-cell>
<van-cell title="建议承办单位">
<!--<van-cell title="建议承办单位">
{{viewData.suggestUnits}}
</van-cell>
</van-cell>-->
<van-cell title="立案结果">
<dict-tag :options="dict.type.PROPOSAL_CASE_FILING_RESULT"
:value="viewData.caseFilingResult"></dict-tag>
@@ -123,7 +123,7 @@ const PROPOSAL_INFO = {
<!--提案委员会立案-->
<van-cell-group :title="task.displayName"
v-else-if="task.taskName === 'committee'">
v-else-if="task.taskName === 'committee'||task.taskName === 'committeeFilingUnit'">
<van-cell title="办理用户">{{ task.taskFormData.userName }}({{task.taskFormData.loginName}})
</van-cell>
<van-cell title="办理时间">{{ task.finishTime }}</van-cell>
@@ -140,12 +140,20 @@ const PROPOSAL_INFO = {
</template>
</div>
</van-cell>
<van-cell title="主办单位">{{ task.ext.tf_masterUnitName }}</van-cell>
<van-cell title="办单位">{{ task?.ext?.tf_slaveUnitNameStr }}</van-cell>
<template v-if="['CONFIRM_FILING','SUGGESTION'].includes(task.ext.tf_caseFilingResult)">
<van-cell v-if="task.ext.tf_caseFilingResult === 'SUGGESTION'" title="办单位">{{ task?.ext?.tf_masterUnitNameStr || task?.ext?.tf_slaveUnitNameStr }}</van-cell>
<template v-else>
<van-cell title="主办单位">{{ task?.ext?.tf_masterUnitNameStr }}</van-cell>
<van-cell title="协办单位">{{ task?.ext?.tf_slaveUnitNameStr }}</van-cell>
</template>
</template>
<van-cell title="办理意见" v-if="task.taskFormData.tf_opinion" class="direction-column-cell">
<div v-html="task.taskFormData.tf_opinion"></div>
</van-cell>
</van-cell-group>
<van-cell-group :title="task.displayName" v-else>
<van-cell title="办理单位" v-if="['master_reply','slave_reply'].includes(task.taskName)">
<van-cell title="办理单位" v-if="['opinion_unit_reply','unit_reply','two_unit_reply','master_reply','slave_reply'].includes(task.taskName)">
{{task.ext.underTakeName}}
</van-cell>
@@ -151,7 +151,7 @@ layout("/layouts/platform_h5.html"){
delete formData.taskName
this.$axios.post("/flow/common/executeTask", {
this.$axios.post("/platform/proposal/schoolLeaderApproval/executeTask", {
data: JSON.stringify(formData)
}).then((res) => {
if (res.code === 0) {
@@ -177,7 +177,7 @@ const todo = {
onView(task) {
const {taskId, taskKey, instanceId, businessNo, formKey, h5FormKey} = task;
if (!h5FormKey) {
this.$toast("当前流程没有配置地址");
this.$toast("当前流程暂不支持手机端审核,请前往PC端页面审核!");
return;
}
this.$pjaxReplace(h5FormKey + "?taskId=" + taskId + "bizId=" + businessNo + "taskKey=" + taskKey+ "&tab=" + this.activeTab)