Skip to content

Y
yanxuan-qc-change-system
Commit a15a46eb by 王志超
Options

feat: 重构变更工单创建流程，使用新的流程

parent 96e00330
Pipeline #85710 passed with stages
in 1 minute 31 seconds
Showing with 341 additions and 119 deletions
yanxuan-qc-change-system-biz/src/main/java/com/netease/mail/yanxuan/change/biz/biz/ChangeFlowBiz.java
......@@ -10,23 +10,13 @@ import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.UUID;
import java.util.*;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import com.netease.mail.yanxuan.change.dal.meta.model.vo.*;
import com.netease.mail.yanxuan.change.integration.rpc.RpcResultException;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.usermodel.Workbook;
......@@ -172,34 +162,70 @@ public class ChangeFlowBiz {
String uid = RequestLocalBean.getUid();
String name = RequestLocalBean.getName();
log.info("[create] createReq={}, uid:{}, name:{}", JSON.toJSONString(changeFlowCreateReq), uid, name);
// 校验变更主体
checkSubject(changeFlowCreateReq);
Long parentChangeClassId = changeFlowCreateReq.getParentChangeClassId();
Long sonChangeClassId = changeFlowCreateReq.getSonChangeClassId();
String changeItems = changeFlowCreateReq.getChangeItems();
List<Long> itemIds = null;
if (StringUtils.isNotBlank(changeItems)) {
List<ItemVO> itemVOS = JSON.parseArray(changeItems, ItemVO.class);
itemIds = itemVOS.stream().map(ItemVO::getItemId).collect(Collectors.toList());
// 校验变更主体类型
ChangeSubjectEnum subjectEnum = ChangeSubjectEnum.getByType(changeFlowCreateReq.getChangeSubject());
Assert.notNull(subjectEnum, "变更主体类型不能为空或不存在");
// 根据变更类型分别处理
switch (subjectEnum) {
case PRODUCT:
return createProductChangeFlow(changeFlowCreateReq, uid, name);
case SUPPLIER:
return createSupplierChangeFlow(changeFlowCreateReq, uid, name);
case OTHER:
return createOtherChangeFlow(changeFlowCreateReq, uid, name);
default:
throw ExceptionFactory.createBiz(ResponseCode.CHANGE_SUBJECT_ERROR, "不支持的变更主体类型");
}
// 工单负责人
String changeCommander = null;
if (!CreateSourceEnum.TONG_ZHOU.getType().equals(changeFlowCreateReq.getCreateSource())) {
changeCommander = uid;
} else {
// 获取工单负责人
GoodsResponseRpc goodsResponseRpc = null;
try {
goodsResponseRpc = interiorChangeConfigService
.queryCommanderInfo(ChangeCommanderPO.builder().parentChangeClassId(parentChangeClassId)
.sonChangeClassId(sonChangeClassId).changeSupplierId(changeFlowCreateReq.getChangeSupplier())
.goodsInfos(itemIds).flowCreator(uid).createSource(changeFlowCreateReq.getCreateSource())
.supplier(changeFlowCreateReq.getSupplier()).build(), changeFlowCreateReq.getChangeCommander());
changeCommander = goodsResponseRpc.getEmail();
} catch (Exception e) {
log.error("[op:queryCommanderInfo] error, goodsResponseRpc:{}, e:{}", JSON.toJSONString(goodsResponseRpc), e);
}
/**
* 创建商品变更工单
*/
private String createProductChangeFlow(ChangeFlowCreateReq changeFlowCreateReq, String uid, String name) {
// 商品变更：校验商品不能为空
Assert.isTrue(StringUtils.isNotBlank(changeFlowCreateReq.getChangeItems()), "变更商品不可为空");
// 解析商品ID列表
List<Long> itemIds = parseItemIds(changeFlowCreateReq.getChangeItems());
// 执行公共创建流程（内部已处理邮件逻辑）
return executeCommonCreateFlow(changeFlowCreateReq, uid, name, itemIds);
}
/**
* 创建供应商变更工单
*/
private String createSupplierChangeFlow(ChangeFlowCreateReq changeFlowCreateReq, String uid, String name) {
Assert.isTrue(StringUtils.isNotBlank(changeFlowCreateReq.getChangeSupplier()), "变更供应商不可为空");
// 执行公共创建流程（内部已处理邮件逻辑）
return executeCommonCreateFlow(changeFlowCreateReq, uid, name, null);
}
/**
* 创建其他变更工单
*/
private String createOtherChangeFlow(ChangeFlowCreateReq changeFlowCreateReq, String uid, String name) {
// 执行公共创建流程（内部已处理邮件逻辑）
return executeCommonCreateFlow(changeFlowCreateReq, uid, name, null);
}
/**
* 解析商品ID列表
*/
private List<Long> parseItemIds(String changeItems) {
List<ItemVO> itemVOS = JSON.parseArray(changeItems, ItemVO.class);
return itemVOS.stream().map(ItemVO::getItemId).collect(Collectors.toList());
}
/**
* 执行公共的创建流程逻辑
*/
private String executeCommonCreateFlow(ChangeFlowCreateReq changeFlowCreateReq, String uid, String name,
List<Long> itemIds) {
Long parentChangeClassId = changeFlowCreateReq.getParentChangeClassId();
Long sonChangeClassId = changeFlowCreateReq.getSonChangeClassId();
// 获取工单负责人
String changeCommander = getChangeCommander(changeFlowCreateReq, uid, parentChangeClassId, sonChangeClassId, itemIds);
Assert.notNull(changeCommander, "未查询到负责人信息");
// 检验是否需要资料
ChangeConfig changeConfig = changeConfigService.getSonChange(sonChangeClassId);
......@@ -221,44 +247,17 @@ public class ChangeFlowBiz {
}
Assert.isTrue(changeFlowCreateReq.getChangeConfirmResultTime() >= tomorrowSpecificTime, "时间不可晚于下次执行时间");
}
Map<String, Object> content = new HashMap<>(10);
content.put("createUserName", uid);
content.put("createUser", uid);
content.put("createTime", System.currentTimeMillis());
content.put("updateTime", System.currentTimeMillis());
content.put(CommonConstants.FLOW_OPERATION_KEY, FlowOperationTypeEnum.PASS.getValue());
// 变更类型， 一级变更类型>二级变更类型
ChangeConfigPo changeConfigPo = changeConfigService.queryInfoPo(parentChangeClassId, sonChangeClassId);
StringBuilder changeType = new StringBuilder();
try {
changeType.append(changeConfigPo.getChangeTypes().get(0).getTypeName());
changeType.append(changeConfigPo.getChangeTypes().get(1).getTypeName());
} catch (Exception e) {
log.error("queryInfoPo error:{}", JSON.toJSONString(changeConfigPo));
}
// 构建工单内容
Map<String, Object> content = buildFlowContent(uid);
// 构建变更类型
StringBuilder changeType = buildChangeType(changeFlowCreateReq);
// 变更工单命名：变更主体+变更类型+变更商品（SPU+商品名称）/变更供应商（供应商ID+供应商名称）
String subject = ChangeSubjectEnum.getDescByType(changeFlowCreateReq.getChangeSubject());
String flowName = subject + changeType;
// 商品变更
if (ChangeSubjectEnum.PRODUCT.getType().equals(changeFlowCreateReq.getChangeSubject())) {
// 批量查询spu信息
List<SpuTO> spuTOS = itemService.batchQuerySpuInfo(BatchQuerySpuInfoParam.builder().ids(itemIds)
.commonProps(new ArrayList<>()).spuProps(new ArrayList<>()).build());
log.debug("[createAndSubmit] uid:{}, spuTOS:{}", uid, JSON.toJSONString(spuTOS));
String spuList = spuTOS.stream().map(spu -> "(" + spu.getId() + spu.getName() + ")")
.collect(Collectors.joining(","));
flowName += spuList;
}
if (ChangeSubjectEnum.SUPPLIER.getType().equals(changeFlowCreateReq.getChangeSubject())) {
List<SupplierSimpleRsp> supplierSimple = supplierService
.getSupplierName(changeFlowCreateReq.getChangeSupplier());
if (CollectionUtils.isNotEmpty(supplierSimple)) {
SupplierSimpleRsp supplier = supplierSimple.get(0);
flowName += supplier.getSupplierId() + supplier.getSupplierName();
}
}
// 组装工单创建数据
FlowCreateReqDTO flowCreateReqDTO = buildFlowCreateReqDTO(ChangeFlowEnum.CHANGE_FLOW_START.getTopoId(), uid,
flowName += buildFlowNameBySubject(changeFlowCreateReq);
// 组装topo工单创建数据
FlowCreateReqDTO flowCreateReqDTO = buildFlowCreateReqDTO(ChangeFlowEnum.NEW_CHANGE_FLOW_START.getTopoId(), uid,
JSON.toJSONString(content), FlowxOperationEnum.CREATE.getName(), name, flowName);
// 创建工单
String flowId = flowService.createFlow(flowCreateReqDTO);
......@@ -268,66 +267,149 @@ public class ChangeFlowBiz {
// 保存工单数据
ChangeRecord changeRecord = buildChangeRecord(flowId, nodeId, changeFlowCreateReq, changeCommander, uid);
changeFlowService.saveRecord(changeRecord);
// 保存变更行动方案记录
List<ChangeExecRecord> changeExecRecords = buildChangeExecRecord(changeRecord.getId(), changeExecProject);
changeExecRecords.forEach(exec -> changeFlowExecService.saveRecord(exec));
// 保存变更行动方案记录,新增流程绑定
List<ChangeExecRecord> changeExecRecords = new ArrayList<>();
for (ChangeExecConfigReq changeExecConfigReq : changeExecProject) {
// 构建子流程工单内容（包含主流程信息）
Map<String, Object> subFlowContent = buildFlowContent(uid);
subFlowContent.put("changeRecordId", changeRecord.getId());
subFlowContent.put("mainFlowId", flowId);
// 构建子流程工单名称：主流程名称 + 行动项内容（截取前50字符）
String subFlowName = flowName + "-" + changeExecConfigReq.getChangeExecProject();
if (subFlowName.length() > 100) {
subFlowName = subFlowName.substring(0, 100) + "...";
}
FlowCreateReqDTO subFlowCreateReqDTO = buildFlowCreateReqDTO(ChangeFlowEnum.CHANGE_SUB_FLOW.getTopoId(), uid,
JSON.toJSONString(subFlowContent), FlowxOperationEnum.CREATE.getName(), name, subFlowName);
String subFlowId = flowService.createFlow(subFlowCreateReqDTO);
// 查询工单详情
FlowDataDTO subFlowDataDTO = flowService.flowDetail(subFlowId);
// 获取流程节点ID
String subNodeId = subFlowDataDTO.getFlowMeta().getCurrNodeDataList().get(0).getNodeId();
log.info("[createSubFlowTopo] changeRecordId:{}, subFlowId:{}, nodeId:{}",
changeRecord.getId(), subFlowId, subNodeId);
// 构建执行记录
ChangeExecRecord execRecord = buildChangeExecRecord(changeRecord.getId(), changeExecConfigReq, subFlowId, subNodeId);
// 入库
changeFlowExecService.saveRecord(execRecord);
changeExecRecords.add(execRecord);
}
// 保存附件
saveChangeFiles(changeRecord.getId(), changeFlowCreateReq);
// 完成流程创建（提交节点、发送邮件）
finalizeFlowCreation(flowId, flowDataDTO, changeRecord, changeExecRecords, changeCommander, changeType, content, uid, changeFlowCreateReq);
return flowId;
}
/**
* 保存变更文件
*/
private void saveChangeFiles(Long changeRecordId, ChangeFlowCreateReq changeFlowCreateReq) {
List<ChangeFile> allFiles = new ArrayList<>();
// 变更前后图片/视频，非必填
List<ChangeFlowFile> changeFiles = changeFlowCreateReq.getChangeFiles();
if (CollectionUtils.isNotEmpty(changeFiles)) {
allFiles.addAll(buildChangeFileRecord(changeRecord.getId(), changeFiles, FileTypeEnum.CHANGE.getType()));
allFiles.addAll(buildChangeFileRecord(changeRecordId, changeFiles, FileTypeEnum.CHANGE.getType()));
}
// 保存附件，根据配置看是否必传
List<ChangeFlowFile> uploadFiles = changeFlowCreateReq.getUploadFiles();
if (CollectionUtils.isNotEmpty(uploadFiles)) {
allFiles.addAll(buildChangeFileRecord(changeRecord.getId(), uploadFiles, FileTypeEnum.UPLOAD.getType()));
allFiles.addAll(buildChangeFileRecord(changeRecordId, uploadFiles, FileTypeEnum.UPLOAD.getType()));
}
if (CollectionUtils.isNotEmpty(allFiles)) {
allFiles.forEach(file -> changeFileService.saveRecord(file));
}
// 如果发起人=变更负责人，直接提交到执行节点，发送邮件
}
/**
* 完成流程创建（提交节点、发送邮件）
*
* @param flowId 工单ID
* @param flowDataDTO 工单详情
* @param changeRecord 变更记录
* @param changeExecRecords 执行记录列表
* @param changeCommander 变更负责人
* @param changeType 变更类型
* @param content 工单内容
* @param uid 创建人
* @param changeFlowCreateReq 创建请求
*/
private void finalizeFlowCreation(String flowId, FlowDataDTO flowDataDTO, ChangeRecord changeRecord,
List<ChangeExecRecord> changeExecRecords, String changeCommander,
StringBuilder changeType, Map<String, Object> content, String uid,
ChangeFlowCreateReq changeFlowCreateReq) {
// 如果发起人=变更负责人，直接提交到执行节点并发送邮件
if (changeCommander.equals(uid)) {
log.debug("[createAndSubmit] changeCommander:{}, uid:{}", changeCommander, uid);
submitToExecutionNode(flowId, flowDataDTO, uid, content, changeRecord);
buildAndSendEmail.buildAndSendEmailCreate(changeRecord, changeExecRecords, changeType, changeCommander, changeFlowCreateReq);
} else {
// 如果发起人≠变更负责人，只发送邮件（不提交节点）
sendCreateFlowEmail(changeRecord, changeCommander, changeType, changeFlowCreateReq);
}
}
/**
* 提交到执行节点
*/
private void submitToExecutionNode(String flowId, FlowDataDTO flowDataDTO, String uid, Map<String, Object> content, ChangeRecord changeRecord) {
log.debug("[submitToExecutionNode] flowId:{}, uid:{}", flowId, uid);
String nextNodeId = flowService.submitFlow(flowId, flowDataDTO, uid,
ChangeFlowEnum.CHANGE_FLOW_SUBMIT.getTopoId(), JSON.toJSONString(content), true,
FlowxOperationEnum.SUBMIT.getName(), "提交工单",changeRecord.getCreateTime());
ChangeFlowEnum.NEW_CHANGE_FLOW_START.getTopoId(), JSON.toJSONString(content), true,
FlowxOperationEnum.SUBMIT.getName(), "提交工单", changeRecord.getCreateTime());
if (null == nextNodeId) {
throw ExceptionFactory.createBiz(ResponseCode.SUBMIT_FLOW_ERROR, "首次提交节点失败");
}
// 更新节点id
changeRecord.setFlowNode(ChangeFlowEnum.CHANGE_FLOW_EXE.getNodeId());
changeRecord.setFlowNode(ChangeFlowEnum.NEW_CHANGE_FLOW_CONFIRM_EXEC_PLAN.getNodeId());
changeRecord.setState(ChangeStatusEnum.IN.getStatus());
changeRecord.setUpdateTime(DateUtils.getCurrentTime());
changeFlowService.updateRecord(changeRecord);
buildAndSendEmail.buildAndSendEmailCreate(changeRecord, changeExecRecords, changeType, changeCommander, changeFlowCreateReq);
return flowId;
}
/**
* 发送创建流程邮件
*
* @param changeRecord 变更记录
* @param changeCommander 变更负责人
* @param changeType 变更类型
* @param changeFlowCreateReq 创建请求
*/
private void sendCreateFlowEmail(ChangeRecord changeRecord, String changeCommander, StringBuilder changeType, ChangeFlowCreateReq changeFlowCreateReq) {
String uid = RequestLocalBean.getUid();
// 如果发起人=变更负责人，已经在 executeCommonCreateFlow 中发送了邮件
if (changeCommander.equals(uid)) {
return;
}
// 如果发起人≠变更负责人，停留在变更申请提交节点，发送邮件
HashMap<String, Object> param = new HashMap<>();
param.put("changeId", changeRecord.getFlowId());
param.put("changeSubject", ChangeSubjectEnum.getChangeSubjectEnum(changeRecord.getChangeSubject()).getDesc());
param.put("changeType", changeType.toString());
param.put("flowUrl", changeRecord.getFlowId());
String subjectParam = changeRecord.getFlowId().toString();
// 发起变更,收件人：变更负责人
List<String> receiver = Collections.singletonList(changeCommander);
List<String> ccList = getDepartmentInfo(receiver);
// 发起变更，抄送：变更负责人上一级主管、变更管理QM（cuiyixian@corp.netease.com）
// 发起变更，抄送：变更负责人上一级主管、变更管理QM
ccList.add(appConfig.getChangeManageQM());
qcSendEmail(receiver, ccList, subjectParam, EmailTemplateEnum.YX_QC_CHANGE_RELEASE_FLOW, param);
// 如果是供应商，再次发送供应商邮件
// 如果是同舟端，发送供应商邮件
if (changeFlowCreateReq.getCreateSource().equals(CreateSourceEnum.TONG_ZHOU.getType())) {
sendSupplierEmail.sendSupplierEmail(changeRecord.getCreateSupplier(), subjectParam,
EmailTemplateEnum.YX_QC_CHANGE_RELEASE_FLOW, param);
}
// 如果是其他端发起但是是供应商变更，再次发送供应商邮件
if (!changeFlowCreateReq.getCreateSource().equals(CreateSourceEnum.TONG_ZHOU.getType())
&& ChangeSubjectEnum.SUPPLIER.getType().equals(changeRecord.getChangeSubject())) {
} else if (ChangeSubjectEnum.SUPPLIER.getType().equals(changeRecord.getChangeSubject())) {
// 如果是其他端发起但是是供应商变更，发送供应商邮件
sendSupplierEmail.sendSupplierEmail(changeRecord.getChangeSupplier(), subjectParam,
EmailTemplateEnum.YX_QC_CHANGE_RELEASE_FLOW, param);
}
return flowId;
}
public List<String> getDepartmentInfo(List<String> receiver) {
......@@ -388,41 +470,74 @@ public class ChangeFlowBiz {
}).collect(Collectors.toList());
}
private List<ChangeExecRecord> buildChangeExecRecord(Long changeRecordId,
List<ChangeExecConfigReq> changeExecProject) {
return changeExecProject.stream().map(c -> {
/**
* 构建单个执行记录
*
* @param changeRecordId 主流程记录ID
* @param changeExecConfigReq 行动项配置
* @return 执行记录
*/
private ChangeExecRecord buildChangeExecRecord(Long changeRecordId, ChangeExecConfigReq changeExecConfigReq) {
ChangeExecRecord changeExecRecord = new ChangeExecRecord();
changeExecRecord.setChangeRecordId(changeRecordId);
changeExecRecord.setChangeExecDepartment(c.getChangeExecDepartment());
changeExecRecord.setChangeExecUserType(c.getChangeExecUserType());
changeExecRecord.setChangeExecUser(c.getChangeExecUser());
changeExecRecord.setChangeExecUserEmail(c.getChangeExecUserEmail());
changeExecRecord.setChangeRiskDesc(c.getChangeRiskDesc());
changeExecRecord.setChangeExecProject(c.getChangeExecProject());
changeExecRecord.setChangeChecking(c.getChangeChecking());
changeExecRecord.setChangeExecFinishTime(c.getChangeExecFinishTime());
changeExecRecord.setChangeExecFinishDesc(c.getChangeExecFinishDesc());
changeExecRecord.setChangeExecDepartment(changeExecConfigReq.getChangeExecDepartment());
changeExecRecord.setChangeExecUserType(changeExecConfigReq.getChangeExecUserType());
changeExecRecord.setChangeExecUser(changeExecConfigReq.getChangeExecUser());
changeExecRecord.setChangeExecUserEmail(changeExecConfigReq.getChangeExecUserEmail());
changeExecRecord.setChangeRiskDesc(changeExecConfigReq.getChangeRiskDesc());
changeExecRecord.setChangeExecProject(changeExecConfigReq.getChangeExecProject());
changeExecRecord.setChangeChecking(changeExecConfigReq.getChangeChecking());
changeExecRecord.setChangeExecFinishTime(changeExecConfigReq.getChangeExecFinishTime());
changeExecRecord.setChangeExecFinishDesc(changeExecConfigReq.getChangeExecFinishDesc());
changeExecRecord.setCreateTime(DateUtils.getCurrentTime());
changeExecRecord.setUpdateTime(DateUtils.getCurrentTime());
return changeExecRecord;
}).collect(Collectors.toList());
}
private void checkSubject(ChangeFlowCreateReq changeFlowCreateReq) {
ChangeSubjectEnum type = ChangeSubjectEnum.getByType(changeFlowCreateReq.getChangeSubject());
Assert.notNull(type, "变更主体不存在");
switch (type) {
case PRODUCT:
Assert.isTrue(StringUtils.isNotBlank(changeFlowCreateReq.getChangeItems()), " 变更商品不可为空");
break;
case SUPPLIER:
Assert.isTrue(StringUtils.isNotBlank(changeFlowCreateReq.getChangeSupplier()), " 变更供应商不可为空");
break;
case OTHER:
break;
default:
throw ExceptionFactory.createBiz(ResponseCode.CHANGE_SUBJECT_ERROR, "变更主体类型错误");
/**
* 构建执行记录（包含子流程信息）
*
* @param changeRecordId 主流程记录ID
* @param changeExecConfigReq 执行配置请求
* @param subFlowId 子流程ID
* @param subNodeId 子流程节点ID
* @return 执行记录
*/
private ChangeExecRecord buildChangeExecRecord(Long changeRecordId, ChangeExecConfigReq changeExecConfigReq, String subFlowId, String subNodeId) {
ChangeExecRecord changeExecRecord = buildChangeExecRecord(changeRecordId, changeExecConfigReq);
changeExecRecord.setSubFlowId(Long.parseLong(subFlowId));
changeExecRecord.setSubFlowNode(subNodeId);
return changeExecRecord;
}
/**
* 批量构建执行记录
*
* @param changeRecordId 主流程记录ID
* @param changeExecProject 行动项配置列表
* @return 执行记录列表
*/
private List<ChangeExecRecord> buildChangeExecRecordList(Long changeRecordId,
List<ChangeExecConfigReq> changeExecProject) {
return changeExecProject.stream()
.map(c -> buildChangeExecRecord(changeRecordId, c))
.collect(Collectors.toList());
}
/**
* 构建工单内容
*
* @param uid 创建人
* @return 工单内容
*/
private Map<String, Object> buildFlowContent(String uid) {
Map<String, Object> content = new HashMap<>(10);
content.put("createUserName", uid);
content.put("createUser", uid);
content.put("createTime", System.currentTimeMillis());
content.put("updateTime", System.currentTimeMillis());
content.put(CommonConstants.FLOW_OPERATION_KEY, FlowOperationTypeEnum.PASS.getValue());
return content;
}
private FlowCreateReqDTO buildFlowCreateReqDTO(String topoId, String uid, String content, String operateResult,
......@@ -438,6 +553,7 @@ public class ChangeFlowBiz {
return flowCreateReqDTO;
}
private ChangeRecord buildChangeRecord(String flowId, String nodeId, ChangeFlowCreateReq changeFlowCreateReq,
String changeCommander, String uid) {
ChangeRecord changeRecord = new ChangeRecord();
......@@ -556,7 +672,7 @@ public class ChangeFlowBiz {
Integer changeExecCount = changeFlowExecService.deleteByChangeRecordId(changeRecord.getId());
log.debug("[CHANGE_FLOW_SUBMIT] delete id:{}, changeExecCount:{}", changeRecord.getId(), changeExecCount);
// 保存变更行动方案记录
List<ChangeExecRecord> changeExecRecords = buildChangeExecRecord(changeRecord.getId(),
List<ChangeExecRecord> changeExecRecords = buildChangeExecRecordList(changeRecord.getId(),
changeFlowSubmitReq.getChangeExecProjectList());
changeExecRecords.forEach(exec -> changeFlowExecService.saveRecord(exec));
// 更新附件，覆盖操作，先删除，后插入
......@@ -1362,4 +1478,100 @@ public class ChangeFlowBiz {
}
changeFlowService.updateRecord(changeRecord);
}
/**
* 获取工单负责人
*
* @param changeFlowCreateReq 创建请求
* @param uid 当前用户ID
* @param parentChangeClassId 一级变更类型ID
* @param sonChangeClassId 二级变更类型ID
* @param itemIds 商品ID列表
* @return 工单负责人邮箱
*/
private String getChangeCommander(ChangeFlowCreateReq changeFlowCreateReq, String uid,
Long parentChangeClassId, Long sonChangeClassId, List<Long> itemIds) {
// 非同舟端：负责人=发起人
if (!CreateSourceEnum.TONG_ZHOU.getType().equals(changeFlowCreateReq.getCreateSource())) {
return uid;
}
// 同舟端：通过RPC查询负责人信息
GoodsResponseRpc goodsResponseRpc = null;
try {
goodsResponseRpc = interiorChangeConfigService
.queryCommanderInfo(ChangeCommanderPO.builder()
.parentChangeClassId(parentChangeClassId)
.sonChangeClassId(sonChangeClassId)
.changeSupplierId(changeFlowCreateReq.getChangeSupplier())
.goodsInfos(itemIds)
.flowCreator(uid)
.createSource(changeFlowCreateReq.getCreateSource())
.supplier(changeFlowCreateReq.getSupplier())
.build(),
changeFlowCreateReq.getChangeCommander());
return goodsResponseRpc != null ? goodsResponseRpc.getEmail() : null;
} catch (Exception e) {
log.error("[getChangeCommander] queryCommanderInfo error, goodsResponseRpc:{}, e:{}",
JSON.toJSONString(goodsResponseRpc), e);
return null;
}
}
/**
* 构建变更类型
*
* @param changeFlowCreateReq 创建请求
* @return 变更类型
*/
private StringBuilder buildChangeType(ChangeFlowCreateReq changeFlowCreateReq) {
Long parentChangeClassId = changeFlowCreateReq.getParentChangeClassId();
Long sonChangeClassId = changeFlowCreateReq.getSonChangeClassId();
// 变更类型， 一级变更类型>二级变更类型
ChangeConfigPo changeConfigPo = changeConfigService.queryInfoPo(parentChangeClassId, sonChangeClassId);
StringBuilder changeType = new StringBuilder();
if (changeConfigPo != null && changeConfigPo.getChangeTypes() != null && changeConfigPo.getChangeTypes().size() >= 2) {
try {
changeType.append(changeConfigPo.getChangeTypes().get(0).getTypeName());
changeType.append(changeConfigPo.getChangeTypes().get(1).getTypeName());
} catch (Exception e) {
log.error("queryInfoPo error:{}", JSON.toJSONString(changeConfigPo), e);
}
}
return changeType;
}
/**
* 根据变更主体类型构建工单名称后缀（辅助方法，由 buildFlowName 调用）
*
* @param changeFlowCreateReq 创建请求
* @return 工单名称后缀
*/
private String buildFlowNameBySubject(ChangeFlowCreateReq changeFlowCreateReq) {
ChangeSubjectEnum subjectEnum = ChangeSubjectEnum.getByType(changeFlowCreateReq.getChangeSubject());
switch (Objects.requireNonNull(subjectEnum)) {
case PRODUCT:
// 商品变更：解析商品ID列表，查询SPU信息，拼接商品ID和名称
List<Long> itemIds = parseItemIds(changeFlowCreateReq.getChangeItems());
List<SpuTO> spuTOS = itemService.batchQuerySpuInfo(BatchQuerySpuInfoParam.builder().ids(itemIds)
.commonProps(new ArrayList<>()).spuProps(new ArrayList<>()).build());
log.debug("[buildFlowNameBySubject] spuTOS:{}", JSON.toJSONString(spuTOS));
return spuTOS.stream().map(spu -> "(" + spu.getId() + spu.getName() + ")")
.collect(Collectors.joining(","));
case SUPPLIER:
// 供应商变更：查询供应商信息，拼接供应商ID和名称
List<SupplierSimpleRsp> supplierSimple = supplierService.getSupplierName(changeFlowCreateReq.getChangeSupplier());
if (CollectionUtils.isNotEmpty(supplierSimple)) {
SupplierSimpleRsp supplier = supplierSimple.get(0);
return supplier.getSupplierId() + supplier.getSupplierName();
}
return "";
case OTHER:
default:
return "";
}
}
}
yanxuan-qc-change-system-dal/src/main/java/com/netease/mail/yanxuan/change/dal/entity/ChangeExecRecord.java
......@@ -84,6 +84,16 @@ public class ChangeExecRecord {
private String changeExecFinishDesc;
/**
* 子流程工单ID
*/
private Long subFlowId;
/**
* 子流程当前节点
*/
private String subFlowNode;
/**
* 创建时间
*/
private Long createTime;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment