zgty/zt-base
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1. 新增工序信息管理、工艺信息管理、组织工艺工序信息管理功能

Browse Source
This commit is contained in:
chenbowen
2025-11-12 15:23:12 +08:00
parent 33bea2cad0
commit 75382dfbeb
26 changed files with 839 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomation/vo/ProcessingInfomationPageReqVO.java
View File

@@ -23,7 +23,7 @@ public class ProcessingInfomationPageReqVO extends PageParam {
private String name;
@Schema(description = "工艺类型值")
private Long typeValue;
private String typeValue;
@Schema(description = "状态值-工艺状态")
private String statusValue;

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomation/vo/ProcessingInfomationRespVO.java
View File

@@ -30,7 +30,7 @@ public class ProcessingInfomationRespVO {
@Schema(description = "工艺类型值")
@ExcelProperty("工艺类型值")
private Long typeValue;
private String typeValue;
@Schema(description = "状态值-工艺状态", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("状态值-工艺状态")

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomation/vo/ProcessingInfomationSaveReqVO.java
View File

@@ -26,7 +26,7 @@ public class ProcessingInfomationSaveReqVO {
private String name;
@Schema(description = "工艺类型值")
private Long typeValue;
private String typeValue;
@Schema(description = "状态值-工艺状态", requiredMode = Schema.RequiredMode.REQUIRED)
@NotEmpty(message = "状态值-工艺状态不能为空")

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomation/vo/ProcessingInfomationTreeRespVO.java
View File

@@ -23,7 +23,7 @@ public class ProcessingInfomationTreeRespVO {
private String name;
@Schema(description = "工艺类型值")
private Long typeValue;
private String typeValue;
@Schema(description = "状态值-工艺状态")
private String statusValue;

19
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/ProcessingInfomationOperationController.java
View File

@@ -9,8 +9,7 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import jakarta.validation.constraints.*;
import jakarta.validation.*;
import jakarta.validation.Valid;
import jakarta.servlet.http.*;
import java.util.*;
import java.io.IOException;
@@ -19,7 +18,6 @@ import com.zt.plat.framework.common.pojo.vo.BatchDeleteReqVO;
import com.zt.plat.framework.common.pojo.PageParam;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.framework.common.pojo.CommonResult;
import com.zt.plat.framework.common.util.object.BeanUtils;
import static com.zt.plat.framework.common.pojo.CommonResult.success;
import com.zt.plat.framework.excel.core.util.ExcelUtils;
@@ -28,7 +26,6 @@ import com.zt.plat.framework.apilog.core.annotation.ApiAccessLog;
import static com.zt.plat.framework.apilog.core.enums.OperateTypeEnum.*;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.*;
import com.zt.plat.module.base.dal.dataobject.processinginfomationoperation.ProcessingInfomationOperationDO;
import com.zt.plat.module.base.service.processinginfomationoperation.ProcessingInfomationOperationService;
@Tag(name = "管理后台 - 工艺工序")
@@ -44,7 +41,7 @@ public class ProcessingInfomationOperationController {
@PostMapping("/create")
@Operation(summary = "创建工艺工序")
@PreAuthorize("@ss.hasPermission('base:processing-infomation-operation:create')")
public CommonResult<ProcessingInfomationOperationRespVO> createProcessingInfomationOperation(@Valid @RequestBody ProcessingInfomationOperationSaveReqVO createReqVO) {
public CommonResult<ProcessingInfomationOperationDetailRespVO> createProcessingInfomationOperation(@Valid @RequestBody ProcessingInfomationOperationSaveReqVO createReqVO) {
return success(processingInfomationOperationService.createProcessingInfomationOperation(createReqVO));
}
@@ -78,9 +75,8 @@ public class ProcessingInfomationOperationController {
@Operation(summary = "获得工艺工序")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('base:processing-infomation-operation:query')")
public CommonResult<ProcessingInfomationOperationRespVO> getProcessingInfomationOperation(@RequestParam("id") Long id) {
ProcessingInfomationOperationDO processingInfomationOperation = processingInfomationOperationService.getProcessingInfomationOperation(id);
return success(BeanUtils.toBean(processingInfomationOperation, ProcessingInfomationOperationRespVO.class));
public CommonResult<ProcessingInfomationOperationDetailRespVO> getProcessingInfomationOperation(@RequestParam("id") Long id) {
return success(processingInfomationOperationService.getProcessingInfomationOperation(id));
}
@GetMapping("/page")
@@ -91,6 +87,13 @@ public class ProcessingInfomationOperationController {
return success(pageResult);
}
@GetMapping("/organization/page")
@Operation(summary = "获得组织工艺工序分页")
@PreAuthorize("@ss.hasPermission('base:processing-infomation-operation:query')")
public CommonResult<PageResult<ProcessingInfomationOperationOrganizationRespVO>> getOrganizationOperationPage(@Valid ProcessingInfomationOperationOrganizationPageReqVO pageReqVO) {
return success(processingInfomationOperationService.getOrganizationOperationPage(pageReqVO));
}
@GetMapping("/export-excel")
@Operation(summary = "导出工艺工序 Excel")
@PreAuthorize("@ss.hasPermission('base:processing-infomation-operation:export')")

20
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationDetailRespVO.java Normal file
View File

@@ -0,0 +1,20 @@
package com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Collections;
import java.util.List;
/**
* 工艺工序详情 Response VO
*/
@Data
@EqualsAndHashCode(callSuper = true)
public class ProcessingInfomationOperationDetailRespVO extends ProcessingInfomationOperationRespVO {
@Schema(description = "工艺工序关联的物料信息")
private List<ProcessingInfomationOperationMaterialRespVO> materials = Collections.emptyList();
}

54
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationMaterialRespVO.java Normal file
View File

@@ -0,0 +1,54 @@
package com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
import java.util.Collections;
import java.util.List;
/**
* 工艺工序物料 Response VO（包含扩展信息）
*/
@Data
public class ProcessingInfomationOperationMaterialRespVO {
@Schema(description = "主键ID", example = "10086")
private Long id;
@Schema(description = "工艺工序ID", example = "20001")
private Long processingOperationId;
@Schema(description = "物料ID", example = "30001")
private Long materialId;
@Schema(description = "物料编码")
private String materialCode;
@Schema(description = "物料名称")
private String materialName;
@Schema(description = "物料类型值", example = "input")
private String typeValue;
@Schema(description = "备注")
private String remark;
@Schema(description = "关联组织ID列表")
private List<Long> departmentIds = Collections.emptyList();
@Schema(description = "关联组织信息")
private List<ProcessingInfomationOperationMaterialDeptRespVO> departments = Collections.emptyList();
@Schema(description = "创建时间")
private LocalDateTime createTime;
@Data
public static class ProcessingInfomationOperationMaterialDeptRespVO {
@Schema(description = "组织ID", example = "50001")
private Long id;
@Schema(description = "组织名称")
private String name;
}
}

32
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationMaterialSaveReqVO.java Normal file
View File

@@ -0,0 +1,32 @@
package com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.Data;
import java.util.List;
/**
* 工艺工序物料保存 Request VO
*/
@Data
public class ProcessingInfomationOperationMaterialSaveReqVO {
@Schema(description = "主键ID", example = "10086")
private Long id;
@Schema(description = "物料ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "20001")
@NotNull(message = "物料不能为空")
private Long materialId;
@Schema(description = "物料类型", requiredMode = Schema.RequiredMode.REQUIRED, example = "input")
@NotEmpty(message = "物料类型不能为空")
private String typeValue;
@Schema(description = "备注")
private String remark;
@Schema(description = "组织ID集合")
private List<Long> departmentIds;
}

33
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationOrganizationPageReqVO.java Normal file
View File

@@ -0,0 +1,33 @@
package com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo;
import com.zt.plat.framework.common.pojo.PageParam;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static com.zt.plat.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
/**
* 组织工艺工序分页 Request VO
*/
@Data
public class ProcessingInfomationOperationOrganizationPageReqVO extends PageParam {
@Schema(description = "组织ID", example = "1001")
private Long deptId;
@Schema(description = "工艺ID", example = "2001")
private Long processingId;
@Schema(description = "工序ID", example = "3001")
private Long operationId;
@Schema(description = "是否关键工序")
private Integer isKey;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

52
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationOrganizationRespVO.java Normal file
View File

@@ -0,0 +1,52 @@
package com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import java.time.LocalDateTime;
/**
* 组织工艺工序 Response VO
*/
@Data
public class ProcessingInfomationOperationOrganizationRespVO {
@Schema(description = "工艺工序关联ID")
private Long id;
@Schema(description = "组织ID")
private Long deptId;
@Schema(description = "组织名称")
private String deptName;
@Schema(description = "工艺ID")
private Long processingId;
@Schema(description = "工艺编码")
private String processingCode;
@Schema(description = "工艺名称")
private String processingName;
@Schema(description = "工序ID")
private Long operationId;
@Schema(description = "工序编码")
private String operationCode;
@Schema(description = "工序名称")
private String operationName;
@Schema(description = "工序是否关键")
private Integer isKey;
@Schema(description = "工艺状态")
private String processingStatus;
@Schema(description = "备注")
private String remark;
@Schema(description = "创建时间")
private LocalDateTime createTime;
}

3
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationPageReqVO.java
View File

@@ -22,6 +22,9 @@ public class ProcessingInfomationOperationPageReqVO extends PageParam {
@Schema(description = "工艺ID", example = "5773")
private Long processingId;
@Schema(description = "工序ID", example = "3001")
private Long operationId;
@Schema(description = "是否关键工序")
private Integer isKey;

16
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationRespVO.java
View File

@@ -44,6 +44,22 @@ public class ProcessingInfomationOperationRespVO {
@ExcelProperty("工艺ID")
private Long processingId;
@Schema(description = "工序ID", example = "3001")
@ExcelProperty("工序ID")
private Long operationId;
@Schema(description = "工序编码")
@ExcelProperty("工序编码")
private String operationCode;
@Schema(description = "工序名称")
@ExcelProperty("工序名称")
private String operationName;
@Schema(description = "工序类型值")
@ExcelProperty("工序类型值")
private String operationTypeValue;
@Schema(description = "是否关键工序")
@ExcelProperty("是否关键工序")
private Integer isKey;

9
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processinginfomationoperation/vo/ProcessingInfomationOperationSaveReqVO.java
View File

@@ -21,6 +21,12 @@ public class ProcessingInfomationOperationSaveReqVO {
@Schema(description = "工艺ID", example = "5773")
private Long processingId;
@Schema(description = "工序ID", example = "3001")
private Long operationId;
@Schema(description = "工序类型值")
private String operationTypeValue;
@Schema(description = "是否关键工序")
private Integer isKey;
@@ -28,4 +34,7 @@ public class ProcessingInfomationOperationSaveReqVO {
@NotEmpty(message = "备注不能为空")
private String remark;
@Schema(description = "关联物料配置")
private List<ProcessingInfomationOperationMaterialSaveReqVO> materials;
}

5
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processingoperation/ProcessingOperationController.java
View File

@@ -107,8 +107,9 @@ public class ProcessingOperationController {
@GetMapping("/simple-list")
@Operation(summary = "获得工序简单列表")
@PreAuthorize("@ss.hasPermission('base:processing-operation:query')")
public CommonResult<List<ProcessingOperationSimpleRespVO>> getProcessingOperationSimpleList() {
List<ProcessingOperationDO> list = processingOperationService.getProcessingOperationList();
public CommonResult<List<ProcessingOperationSimpleRespVO>> getProcessingOperationSimpleList(
@RequestParam(value = "typeValue", required = false) String typeValue) {
List<ProcessingOperationDO> list = processingOperationService.getProcessingOperationListByType(typeValue);
return success(BeanUtils.toBean(list, ProcessingOperationSimpleRespVO.class));
}

3
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/controller/admin/processingoperation/vo/ProcessingOperationSimpleRespVO.java
View File

@@ -16,4 +16,7 @@ public class ProcessingOperationSimpleRespVO {
@Schema(description = "工序名称", example = "熔铸")
private String name;
@Schema(description = "工序类型值", example = "10")
private String typeValue;
}

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dao/processinginfomationoperation/ProcessingInfomationOperationMapper.java
View File

@@ -22,6 +22,7 @@ public interface ProcessingInfomationOperationMapper extends BaseMapperX<Process
.eqIfPresent(ProcessingInfomationOperationDO::getPreviousOperationId, reqVO.getPreviousOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getNextOperationId, reqVO.getNextOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getProcessingId, reqVO.getProcessingId())
.eqIfPresent(ProcessingInfomationOperationDO::getOperationId, reqVO.getOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getIsKey, reqVO.getIsKey())
.eqIfPresent(ProcessingInfomationOperationDO::getRemark, reqVO.getRemark())
.betweenIfPresent(ProcessingInfomationOperationDO::getCreateTime, reqVO.getCreateTime())
@@ -33,6 +34,7 @@ public interface ProcessingInfomationOperationMapper extends BaseMapperX<Process
.eqIfPresent(ProcessingInfomationOperationDO::getPreviousOperationId, reqVO.getPreviousOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getNextOperationId, reqVO.getNextOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getProcessingId, reqVO.getProcessingId())
.eqIfPresent(ProcessingInfomationOperationDO::getOperationId, reqVO.getOperationId())
.eqIfPresent(ProcessingInfomationOperationDO::getIsKey, reqVO.getIsKey())
.eqIfPresent(ProcessingInfomationOperationDO::getRemark, reqVO.getRemark())
.betweenIfPresent(ProcessingInfomationOperationDO::getCreateTime, reqVO.getCreateTime())

7
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dao/processingoperation/ProcessingOperationMapper.java
View File

@@ -28,4 +28,11 @@ public interface ProcessingOperationMapper extends BaseMapperX<ProcessingOperati
.orderByDesc(ProcessingOperationDO::getId));
}
default List<ProcessingOperationDO> selectSimpleList(String typeValue) {
return selectList(new LambdaQueryWrapperX<ProcessingOperationDO>()
.eqIfPresent(ProcessingOperationDO::getTypeValue, typeValue)
.orderByAsc(ProcessingOperationDO::getSort)
.orderByAsc(ProcessingOperationDO::getId));
}
}

29
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dao/processingoperationmaterial/ProcessingOperationMaterialMapper.java
View File

@@ -5,6 +5,7 @@ import java.util.*;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.zt.plat.framework.mybatis.core.mapper.BaseMapperX;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationOrganizationPageReqVO;
import com.zt.plat.module.base.dal.dataobject.processingoperationmaterial.ProcessingOperationMaterialDO;
import org.apache.ibatis.annotations.Mapper;
import com.zt.plat.module.base.controller.admin.processingoperationmaterial.vo.*;
@@ -26,4 +27,32 @@ public interface ProcessingOperationMaterialMapper extends BaseMapperX<Processin
.orderByDesc(ProcessingOperationMaterialDO::getId));
}
default void deleteByProcessingOperationId(Long processingOperationId) {
if (processingOperationId == null) {
return;
}
delete(new LambdaQueryWrapperX<ProcessingOperationMaterialDO>()
.eq(ProcessingOperationMaterialDO::getProcessingOperationId, processingOperationId));
}
default void deleteByProcessingOperationIds(Collection<Long> processingOperationIds) {
if (processingOperationIds == null || processingOperationIds.isEmpty()) {
return;
}
delete(new LambdaQueryWrapperX<ProcessingOperationMaterialDO>()
.in(ProcessingOperationMaterialDO::getProcessingOperationId, processingOperationIds));
}
default List<ProcessingOperationMaterialDO> selectListByProcessingOperationIds(Collection<Long> processingOperationIds) {
if (processingOperationIds == null || processingOperationIds.isEmpty()) {
return Collections.emptyList();
}
return selectList(new LambdaQueryWrapperX<ProcessingOperationMaterialDO>()
.in(ProcessingOperationMaterialDO::getProcessingOperationId, processingOperationIds));
}
default List<ProcessingOperationMaterialDO> selectOrganizationList(ProcessingInfomationOperationOrganizationPageReqVO reqVO) {
return selectList();
}
}

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dataobject/processinginfomation/ProcessingInfomationDO.java
View File

@@ -51,7 +51,7 @@ public class ProcessingInfomationDO extends BaseDO {
* 工艺类型值
*/
@TableField("TP_VAL")
private Long typeValue;
private String typeValue;
/**
* 状态值-工艺状态
*/

6
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dataobject/processinginfomationoperation/ProcessingInfomationOperationDO.java
View File

@@ -31,6 +31,12 @@ public class ProcessingInfomationOperationDO extends BaseDO {
*/
@TableId(type = IdType.ASSIGN_ID)
private Long id;
/**
* 工序ID
*/
@TableField("OPTN_ID")
private Long operationId;
/**
* 前序工序ID
*/

2
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/dal/dataobject/processingoperationmaterial/ProcessingOperationMaterialDO.java
View File

@@ -34,10 +34,12 @@ public class ProcessingOperationMaterialDO extends BaseDO {
/**
* 工艺工序ID
*/
@TableField("PROC_OPTN_ID")
private Long processingOperationId;
/**
* 物料ID
*/
@TableField("MTRL_ID")
private Long materialId;
/**
* 类型值-物料类型(产出/投入)

60
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/service/processinginfomation/ProcessingInfomationServiceImpl.java
View File

@@ -1,6 +1,7 @@
package com.zt.plat.module.base.service.processinginfomation;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
@@ -32,11 +33,52 @@ public class ProcessingInfomationServiceImpl implements ProcessingInfomationServ
@Resource
private ProcessingInfomationMapper processingInfomationMapper;
private String normalizeDictionaryValue(String value) {
if (StrUtil.isBlank(value)) {
return null;
}
String trimmed = value.trim();
int idx = trimmed.length();
while (idx > 0 && Character.isDigit(trimmed.charAt(idx - 1))) {
idx--;
}
if (idx == trimmed.length()) {
// no trailing digits
return trimmed;
}
String digits = trimmed.substring(idx);
String prefix = trimmed.substring(0, idx);
if (StrUtil.isEmpty(prefix) || isSafeDictionaryPrefix(prefix)) {
return digits;
}
return trimmed;
}
private void normalizeProcessingInfomation(ProcessingInfomationDO data) {
if (data == null) {
return;
}
data.setTypeValue(normalizeDictionaryValue(data.getTypeValue()));
data.setStatusValue(normalizeDictionaryValue(data.getStatusValue()));
}
private boolean isSafeDictionaryPrefix(String prefix) {
for (int i = 0; i < prefix.length(); i++) {
char ch = prefix.charAt(i);
if (!(Character.isLetter(ch) || ch == '_' || ch == '-' || ch == ':')) {
return false;
}
}
return true;
}
@Override
public ProcessingInfomationRespVO createProcessingInfomation(ProcessingInfomationSaveReqVO createReqVO) {
// 插入
ProcessingInfomationDO processingInfomation = BeanUtils.toBean(createReqVO, ProcessingInfomationDO.class);
normalizeProcessingInfomation(processingInfomation);
processingInfomationMapper.insert(processingInfomation);
normalizeProcessingInfomation(processingInfomation);
// 返回
return BeanUtils.toBean(processingInfomation, ProcessingInfomationRespVO.class);
}
@@ -47,6 +89,7 @@ public class ProcessingInfomationServiceImpl implements ProcessingInfomationServ
validateProcessingInfomationExists(updateReqVO.getId());
// 更新
ProcessingInfomationDO updateObj = BeanUtils.toBean(updateReqVO, ProcessingInfomationDO.class);
normalizeProcessingInfomation(updateObj);
processingInfomationMapper.updateById(updateObj);
}
@@ -81,17 +124,28 @@ public class ProcessingInfomationServiceImpl implements ProcessingInfomationServ
@Override
public ProcessingInfomationDO getProcessingInfomation(Long id) {
return processingInfomationMapper.selectById(id);
ProcessingInfomationDO data = processingInfomationMapper.selectById(id);
normalizeProcessingInfomation(data);
return data;
}
@Override
public PageResult<ProcessingInfomationDO> getProcessingInfomationPage(ProcessingInfomationPageReqVO pageReqVO) {
return processingInfomationMapper.selectPage(pageReqVO);
PageResult<ProcessingInfomationDO> pageResult = processingInfomationMapper.selectPage(pageReqVO);
List<ProcessingInfomationDO> records = pageResult.getList();
if (CollUtil.isNotEmpty(records)) {
records.forEach(this::normalizeProcessingInfomation);
}
return pageResult;
}
@Override
public List<ProcessingInfomationDO> getProcessingInfomationList() {
return processingInfomationMapper.selectList();
List<ProcessingInfomationDO> list = processingInfomationMapper.selectList();
if (CollUtil.isNotEmpty(list)) {
list.forEach(this::normalizeProcessingInfomation);
}
return list;
}
}

14
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/service/processinginfomationoperation/ProcessingInfomationOperationService.java
View File

@@ -1,7 +1,8 @@
package com.zt.plat.module.base.service.processinginfomationoperation;
import java.util.*;
import jakarta.validation.*;
import java.util.List;
import jakarta.validation.Valid;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.*;
import com.zt.plat.module.base.dal.dataobject.processinginfomationoperation.ProcessingInfomationOperationDO;
import com.zt.plat.framework.common.pojo.PageResult;
@@ -20,7 +21,7 @@ public interface ProcessingInfomationOperationService {
* @param createReqVO 创建信息
* @return 编号
*/
ProcessingInfomationOperationRespVO createProcessingInfomationOperation(@Valid ProcessingInfomationOperationSaveReqVO createReqVO);
ProcessingInfomationOperationDetailRespVO createProcessingInfomationOperation(@Valid ProcessingInfomationOperationSaveReqVO createReqVO);
/**
* 更新工艺工序
@@ -49,7 +50,7 @@ public interface ProcessingInfomationOperationService {
* @param id 编号
* @return 工艺工序
*/
ProcessingInfomationOperationDO getProcessingInfomationOperation(Long id);
ProcessingInfomationOperationDetailRespVO getProcessingInfomationOperation(Long id);
/**
* 获得工艺工序分页
@@ -75,4 +76,9 @@ public interface ProcessingInfomationOperationService {
*/
List<ProcessingInfomationOperationRespVO> getProcessingInfomationOperationDetailList(ProcessingInfomationOperationPageReqVO pageReqVO);
/**
* 获得组织工艺工序分页
*/
PageResult<ProcessingInfomationOperationOrganizationRespVO> getOrganizationOperationPage(ProcessingInfomationOperationOrganizationPageReqVO pageReqVO);
}

557
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/service/processinginfomationoperation/ProcessingInfomationOperationServiceImpl.java
View File

@@ -2,34 +2,55 @@ package com.zt.plat.module.base.service.processinginfomationoperation;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.annotation.Validated;
import java.util.*;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.*;
import com.zt.plat.module.base.dal.dataobject.processinginfomationoperation.ProcessingInfomationOperationDO;
import com.zt.plat.module.base.dal.dao.processingoperation.ProcessingOperationMapper;
import com.zt.plat.module.base.dal.dataobject.processingoperation.ProcessingOperationDO;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.framework.common.pojo.PageParam;
import com.zt.plat.framework.common.util.object.BeanUtils;
import com.zt.plat.framework.common.pojo.PageResult;
import com.zt.plat.framework.common.util.object.BeanUtils;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationDetailRespVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationMaterialRespVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationMaterialRespVO.ProcessingInfomationOperationMaterialDeptRespVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationMaterialSaveReqVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationOrganizationPageReqVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationOrganizationRespVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationPageReqVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationRespVO;
import com.zt.plat.module.base.controller.admin.processinginfomationoperation.vo.ProcessingInfomationOperationSaveReqVO;
import com.zt.plat.module.base.dal.dao.processinginfomation.ProcessingInfomationMapper;
import com.zt.plat.module.base.dal.dao.processinginfomationoperation.ProcessingInfomationOperationMapper;
import com.zt.plat.module.base.dal.dao.processingoperation.ProcessingOperationMapper;
import com.zt.plat.module.base.dal.dao.processingoperationmaterial.ProcessingOperationMaterialMapper;
import com.zt.plat.module.base.dal.dataobject.base.MaterialInfomationDO;
import com.zt.plat.module.base.dal.dataobject.processinginfomation.ProcessingInfomationDO;
import com.zt.plat.module.base.dal.dataobject.processinginfomationoperation.ProcessingInfomationOperationDO;
import com.zt.plat.module.base.dal.dataobject.processingoperation.ProcessingOperationDO;
import com.zt.plat.module.base.dal.dataobject.processingoperationmaterial.ProcessingOperationMaterialDO;
import com.zt.plat.module.base.dal.mysql.base.MaterialInfomationMapper;
import com.zt.plat.module.system.api.dept.DeptApi;
import com.zt.plat.module.system.api.dept.dto.DeptRespDTO;
import static com.zt.plat.framework.common.exception.util.ServiceExceptionUtil.exception;
import static com.zt.plat.framework.common.util.collection.CollectionUtils.convertList;
import static com.zt.plat.framework.common.util.collection.CollectionUtils.diffList;
import static com.zt.plat.module.base.enums.ErrorCodeConstants.*;
import static com.zt.plat.module.base.enums.ErrorCodeConstants.PROCESSING_INFOMATION_OPERATION_NOT_EXISTS;
/**
* 工艺工序 Service 实现类
*
* @author 后台管理-1
* Processing operation service implementation.
*/
@Service
@Validated
@@ -39,43 +60,52 @@ public class ProcessingInfomationOperationServiceImpl implements ProcessingInfom
private ProcessingInfomationOperationMapper processingInfomationOperationMapper;
@Resource
private ProcessingOperationMapper processingOperationMapper;
@Resource
private ProcessingOperationMaterialMapper processingOperationMaterialMapper;
@Resource
private ProcessingInfomationMapper processingInfomationMapper;
@Resource
private MaterialInfomationMapper materialInfomationMapper;
@Resource
private DeptApi deptApi;
@Override
public ProcessingInfomationOperationRespVO createProcessingInfomationOperation(ProcessingInfomationOperationSaveReqVO createReqVO) {
// 插入
ProcessingInfomationOperationDO processingInfomationOperation = BeanUtils.toBean(createReqVO, ProcessingInfomationOperationDO.class);
processingInfomationOperationMapper.insert(processingInfomationOperation);
// 返回
return BeanUtils.toBean(processingInfomationOperation, ProcessingInfomationOperationRespVO.class);
@Transactional(rollbackFor = Exception.class)
public ProcessingInfomationOperationDetailRespVO createProcessingInfomationOperation(ProcessingInfomationOperationSaveReqVO createReqVO) {
ProcessingInfomationOperationDO relation = BeanUtils.toBean(createReqVO, ProcessingInfomationOperationDO.class);
processingInfomationOperationMapper.insert(relation);
saveOperationMaterials(relation.getId(), createReqVO.getMaterials());
return getProcessingInfomationOperation(relation.getId());
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateProcessingInfomationOperation(ProcessingInfomationOperationSaveReqVO updateReqVO) {
// 校验存在
validateProcessingInfomationOperationExists(updateReqVO.getId());
// 更新
ProcessingInfomationOperationDO updateObj = BeanUtils.toBean(updateReqVO, ProcessingInfomationOperationDO.class);
processingInfomationOperationMapper.updateById(updateObj);
saveOperationMaterials(updateReqVO.getId(), updateReqVO.getMaterials());
}
@Override
public void deleteProcessingInfomationOperation(Long id) {
// 校验存在
validateProcessingInfomationOperationExists(id);
// 删除
processingInfomationOperationMapper.deleteById(id);
processingOperationMaterialMapper.deleteByProcessingOperationId(id);
}
@Override
public void deleteProcessingInfomationOperationListByIds(List<Long> ids) {
// 校验存在
public void deleteProcessingInfomationOperationListByIds(List<Long> ids) {
validateProcessingInfomationOperationExists(ids);
// 删除
processingInfomationOperationMapper.deleteByIds(ids);
}
processingInfomationOperationMapper.deleteBatchIds(ids);
processingOperationMaterialMapper.deleteByProcessingOperationIds(ids);
}
private void validateProcessingInfomationOperationExists(List<Long> ids) {
List<ProcessingInfomationOperationDO> list = processingInfomationOperationMapper.selectByIds(ids);
if (CollUtil.isEmpty(ids)) {
throw exception(PROCESSING_INFOMATION_OPERATION_NOT_EXISTS);
}
List<ProcessingInfomationOperationDO> list = processingInfomationOperationMapper.selectBatchIds(ids);
if (CollUtil.isEmpty(list) || list.size() != ids.size()) {
throw exception(PROCESSING_INFOMATION_OPERATION_NOT_EXISTS);
}
@@ -88,8 +118,17 @@ public class ProcessingInfomationOperationServiceImpl implements ProcessingInfom
}
@Override
public ProcessingInfomationOperationDO getProcessingInfomationOperation(Long id) {
return processingInfomationOperationMapper.selectById(id);
public ProcessingInfomationOperationDetailRespVO getProcessingInfomationOperation(Long id) {
ProcessingInfomationOperationDO relation = processingInfomationOperationMapper.selectById(id);
if (relation == null) {
return null;
}
Map<Long, ProcessingOperationDO> operationMap = loadOperationMap(Collections.singletonList(relation));
Map<Long, List<ProcessingInfomationOperationMaterialRespVO>> materialMap = buildMaterialDetailMap(Collections.singletonList(relation.getId()));
ProcessingInfomationOperationDetailRespVO detail = BeanUtils.toBean(relation, ProcessingInfomationOperationDetailRespVO.class);
fillOperationInfo(relation, detail, operationMap);
detail.setMaterials(materialMap.getOrDefault(relation.getId(), Collections.emptyList()));
return detail;
}
@Override
@@ -100,22 +139,7 @@ public class ProcessingInfomationOperationServiceImpl implements ProcessingInfom
@Override
public PageResult<ProcessingInfomationOperationRespVO> getProcessingInfomationOperationDetailPage(ProcessingInfomationOperationPageReqVO pageReqVO) {
List<ProcessingInfomationOperationRespVO> detailList = buildDetailList(pageReqVO);
int total = detailList.size();
if (total == 0) {
return new PageResult<>(Collections.emptyList(), 0L);
}
Integer pageSize = pageReqVO.getPageSize();
if (pageSize != null && pageSize <= 0) {
return new PageResult<>(detailList, (long) total);
}
int pageNo = pageReqVO.getPageNo() == null ? 1 : pageReqVO.getPageNo();
int size = (pageSize == null || pageSize <= 0) ? total : pageSize;
int fromIndex = Math.max((pageNo - 1) * size, 0);
if (fromIndex >= total) {
return new PageResult<>(Collections.emptyList(), (long) total);
}
int toIndex = Math.min(fromIndex + size, total);
return new PageResult<>(detailList.subList(fromIndex, toIndex), (long) total);
return paginate(detailList, pageReqVO.getPageNo(), pageReqVO.getPageSize());
}
@Override
@@ -123,60 +147,417 @@ public class ProcessingInfomationOperationServiceImpl implements ProcessingInfom
return buildDetailList(pageReqVO);
}
@Override
public PageResult<ProcessingInfomationOperationOrganizationRespVO> getOrganizationOperationPage(ProcessingInfomationOperationOrganizationPageReqVO pageReqVO) {
List<ProcessingOperationMaterialDO> materialRecords = processingOperationMaterialMapper.selectOrganizationList(pageReqVO);
if (CollUtil.isEmpty(materialRecords)) {
return new PageResult<>(Collections.emptyList(), 0L);
}
Long deptFilter = pageReqVO.getDeptId();
List<ProcessingOperationMaterialDO> filteredMaterials = materialRecords.stream()
.filter(Objects::nonNull)
.filter(item -> {
if (deptFilter == null) {
return true;
}
List<Long> deptIds = parseDepartmentIds(item.getDepartmentIds());
return CollUtil.isNotEmpty(deptIds) && deptIds.contains(deptFilter);
})
.collect(Collectors.toList());
if (CollUtil.isEmpty(filteredMaterials)) {
return new PageResult<>(Collections.emptyList(), 0L);
}
Set<Long> relationIds = filteredMaterials.stream()
.map(ProcessingOperationMaterialDO::getProcessingOperationId)
.filter(Objects::nonNull)
.collect(Collectors.toCollection(LinkedHashSet::new));
if (CollUtil.isEmpty(relationIds)) {
return new PageResult<>(Collections.emptyList(), 0L);
}
List<ProcessingInfomationOperationDO> relations = processingInfomationOperationMapper.selectBatchIds(relationIds);
if (CollUtil.isEmpty(relations)) {
return new PageResult<>(Collections.emptyList(), 0L);
}
Map<Long, ProcessingInfomationOperationDO> relationMap = relations.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(ProcessingInfomationOperationDO::getId, Function.identity(), (v1, v2) -> v1, LinkedHashMap::new));
Map<Long, ProcessingOperationDO> operationMap = loadOperationMap(relations);
Map<Long, ProcessingInfomationDO> processingMap = loadProcessingMap(relations);
Map<Long, List<ProcessingInfomationOperationMaterialRespVO>> materialDetailMap = buildMaterialDetailMap(relationIds);
List<ProcessingInfomationOperationOrganizationRespVO> dataList = new ArrayList<>();
LocalDateTime[] createTimeRange = pageReqVO.getCreateTime();
for (ProcessingInfomationOperationDO relation : relationMap.values()) {
if (pageReqVO.getIsKey() != null && !Objects.equals(relation.getIsKey(), pageReqVO.getIsKey())) {
continue;
}
if (pageReqVO.getProcessingId() != null && !Objects.equals(relation.getProcessingId(), pageReqVO.getProcessingId())) {
continue;
}
if (createTimeRange != null && createTimeRange.length == 2 && createTimeRange[0] != null && createTimeRange[1] != null && relation.getCreateTime() != null) {
if (relation.getCreateTime().isBefore(createTimeRange[0]) || relation.getCreateTime().isAfter(createTimeRange[1])) {
continue;
}
}
Long displayOperationId = resolveDisplayOperationId(relation);
if (pageReqVO.getOperationId() != null && !Objects.equals(displayOperationId, pageReqVO.getOperationId())) {
continue;
}
List<ProcessingInfomationOperationMaterialRespVO> materials = materialDetailMap.getOrDefault(relation.getId(), Collections.emptyList());
if (CollUtil.isEmpty(materials)) {
continue;
}
Map<Long, String> deptNameMap = new LinkedHashMap<>();
for (ProcessingInfomationOperationMaterialRespVO material : materials) {
List<Long> deptIds = material.getDepartmentIds();
if (CollUtil.isEmpty(deptIds)) {
continue;
}
for (Long deptId : deptIds) {
if (deptId == null) {
continue;
}
deptNameMap.putIfAbsent(deptId, resolveDeptName(material, deptId));
}
}
if (deptNameMap.isEmpty()) {
continue;
}
if (deptFilter != null && !deptNameMap.containsKey(deptFilter)) {
continue;
}
Stream<Long> deptStream = deptFilter != null ? Stream.of(deptFilter) : deptNameMap.keySet().stream();
deptStream.forEach(deptId -> {
ProcessingInfomationOperationOrganizationRespVO resp = buildOrganizationResp(
deptId,
deptNameMap.get(deptId),
relation,
processingMap,
operationMap,
displayOperationId
);
dataList.add(resp);
});
}
return paginate(dataList, pageReqVO.getPageNo(), pageReqVO.getPageSize());
}
private String resolveDeptName(ProcessingInfomationOperationMaterialRespVO material, Long deptId) {
if (deptId == null) {
return null;
}
List<ProcessingInfomationOperationMaterialDeptRespVO> departments = material.getDepartments();
if (CollUtil.isEmpty(departments)) {
return null;
}
return departments.stream()
.filter(item -> Objects.equals(item.getId(), deptId))
.map(ProcessingInfomationOperationMaterialDeptRespVO::getName)
.findFirst()
.orElse(null);
}
private ProcessingInfomationOperationOrganizationRespVO buildOrganizationResp(Long deptId,
String deptName,
ProcessingInfomationOperationDO relation,
Map<Long, ProcessingInfomationDO> processingMap,
Map<Long, ProcessingOperationDO> operationMap,
Long displayOperationId) {
ProcessingInfomationOperationOrganizationRespVO resp = new ProcessingInfomationOperationOrganizationRespVO();
resp.setId(relation.getId());
resp.setDeptId(deptId);
resp.setDeptName(deptName);
resp.setRemark(relation.getRemark());
resp.setCreateTime(relation.getCreateTime());
resp.setIsKey(relation.getIsKey());
ProcessingInfomationDO processing = processingMap.get(relation.getProcessingId());
if (processing != null) {
resp.setProcessingId(processing.getId());
resp.setProcessingCode(processing.getCode());
resp.setProcessingName(processing.getName());
resp.setProcessingStatus(processing.getStatusValue());
}
resp.setOperationId(displayOperationId);
ProcessingOperationDO operation = operationMap.get(displayOperationId);
if (operation != null) {
resp.setOperationCode(operation.getCode());
resp.setOperationName(operation.getName());
}
return resp;
}
private Long resolveDisplayOperationId(ProcessingInfomationOperationDO relation) {
if (relation.getOperationId() != null) {
return relation.getOperationId();
}
if (relation.getNextOperationId() != null) {
return relation.getNextOperationId();
}
return relation.getPreviousOperationId();
}
private List<ProcessingInfomationOperationRespVO> buildDetailList(ProcessingInfomationOperationPageReqVO pageReqVO) {
List<ProcessingInfomationOperationDO> relations = processingInfomationOperationMapper.selectList(pageReqVO);
if (CollUtil.isEmpty(relations)) {
return Collections.emptyList();
}
Set<Long> operationIds = relations.stream()
.flatMap(item -> Stream.of(item.getPreviousOperationId(), item.getNextOperationId()))
.filter(Objects::nonNull)
.collect(Collectors.toSet());
Map<Long, ProcessingOperationDO> operationMap;
if (operationIds.isEmpty()) {
operationMap = Collections.emptyMap();
} else {
List<ProcessingOperationDO> operations = processingOperationMapper.selectBatchIds(operationIds);
if (CollUtil.isEmpty(operations)) {
operationMap = Collections.emptyMap();
} else {
operationMap = operations.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(ProcessingOperationDO::getId, Function.identity(), (v1, v2) -> v1));
}
}
Map<Long, ProcessingOperationDO> operationMap = loadOperationMap(relations);
List<ProcessingInfomationOperationRespVO> detailList = relations.stream()
.map(item -> convertToResp(item, operationMap))
.map(item -> {
ProcessingInfomationOperationRespVO resp = BeanUtils.toBean(item, ProcessingInfomationOperationRespVO.class);
fillOperationInfo(item, resp, operationMap);
return resp;
})
.collect(Collectors.toList());
String nextCode = pageReqVO.getNextOperationCode();
if (StrUtil.isNotBlank(nextCode)) {
detailList = detailList.stream()
.filter(item -> StrUtil.containsIgnoreCase(item.getNextOperationCode(), nextCode))
.collect(Collectors.toList());
}
String nextName = pageReqVO.getNextOperationName();
if (StrUtil.isNotBlank(nextName)) {
detailList = detailList.stream()
.filter(item -> StrUtil.containsIgnoreCase(item.getNextOperationName(), nextName))
.collect(Collectors.toList());
}
applyOperationFilters(detailList, pageReqVO);
return detailList;
}
private ProcessingInfomationOperationRespVO convertToResp(ProcessingInfomationOperationDO relation,
Map<Long, ProcessingOperationDO> operationMap) {
ProcessingInfomationOperationRespVO resp = BeanUtils.toBean(relation, ProcessingInfomationOperationRespVO.class);
private void applyOperationFilters(List<ProcessingInfomationOperationRespVO> list, ProcessingInfomationOperationPageReqVO pageReqVO) {
if (StrUtil.isNotBlank(pageReqVO.getNextOperationCode())) {
list.removeIf(item -> !StrUtil.containsIgnoreCase(StrUtil.blankToDefault(item.getNextOperationCode(), ""), pageReqVO.getNextOperationCode()));
}
if (StrUtil.isNotBlank(pageReqVO.getNextOperationName())) {
list.removeIf(item -> !StrUtil.containsIgnoreCase(StrUtil.blankToDefault(item.getNextOperationName(), ""), pageReqVO.getNextOperationName()));
}
}
private Map<Long, ProcessingOperationDO> loadOperationMap(Collection<ProcessingInfomationOperationDO> relations) {
if (CollUtil.isEmpty(relations)) {
return Collections.emptyMap();
}
Set<Long> operationIds = relations.stream()
.flatMap(item -> Stream.of(item.getOperationId(), item.getPreviousOperationId(), item.getNextOperationId()))
.filter(Objects::nonNull)
.collect(Collectors.toSet());
if (CollUtil.isEmpty(operationIds)) {
return Collections.emptyMap();
}
List<ProcessingOperationDO> operations = processingOperationMapper.selectBatchIds(operationIds);
if (CollUtil.isEmpty(operations)) {
return Collections.emptyMap();
}
return operations.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(ProcessingOperationDO::getId, Function.identity(), (v1, v2) -> v1));
}
private Map<Long, ProcessingInfomationDO> loadProcessingMap(Collection<ProcessingInfomationOperationDO> relations) {
Set<Long> processingIds = relations.stream()
.map(ProcessingInfomationOperationDO::getProcessingId)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
if (CollUtil.isEmpty(processingIds)) {
return Collections.emptyMap();
}
List<ProcessingInfomationDO> list = processingInfomationMapper.selectBatchIds(processingIds);
if (CollUtil.isEmpty(list)) {
return Collections.emptyMap();
}
return list.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(ProcessingInfomationDO::getId, Function.identity(), (v1, v2) -> v1));
}
private void fillOperationInfo(ProcessingInfomationOperationDO relation,
ProcessingInfomationOperationRespVO target,
Map<Long, ProcessingOperationDO> operationMap) {
ProcessingOperationDO current = operationMap.get(relation.getOperationId());
String operationType = null;
if (current != null) {
target.setOperationCode(current.getCode());
target.setOperationName(current.getName());
operationType = normalizeOperationTypeValue(current.getTypeValue());
}
ProcessingOperationDO previous = operationMap.get(relation.getPreviousOperationId());
if (previous != null) {
resp.setPreviousOperationCode(previous.getCode());
resp.setPreviousOperationName(previous.getName());
target.setPreviousOperationCode(previous.getCode());
target.setPreviousOperationName(previous.getName());
if (operationType == null) {
operationType = normalizeOperationTypeValue(previous.getTypeValue());
}
}
ProcessingOperationDO next = operationMap.get(relation.getNextOperationId());
if (next != null) {
resp.setNextOperationCode(next.getCode());
resp.setNextOperationName(next.getName());
target.setNextOperationCode(next.getCode());
target.setNextOperationName(next.getName());
if (operationType == null) {
operationType = normalizeOperationTypeValue(next.getTypeValue());
}
}
target.setOperationTypeValue(operationType);
}
private String normalizeOperationTypeValue(String typeValue) {
if (StrUtil.isBlank(typeValue)) {
return null;
}
return StrUtil.trim(typeValue);
}
private void saveOperationMaterials(Long relationId, List<ProcessingInfomationOperationMaterialSaveReqVO> materials) {
processingOperationMaterialMapper.deleteByProcessingOperationId(relationId);
if (CollUtil.isEmpty(materials)) {
return;
}
List<ProcessingOperationMaterialDO> entities = new ArrayList<>();
for (ProcessingInfomationOperationMaterialSaveReqVO item : materials) {
if (item == null || item.getMaterialId() == null) {
continue;
}
ProcessingOperationMaterialDO entity = new ProcessingOperationMaterialDO();
entity.setProcessingOperationId(relationId);
entity.setMaterialId(item.getMaterialId());
entity.setTypeValue(item.getTypeValue());
entity.setRemark(item.getRemark());
entity.setDepartmentIds(formatDepartmentIds(item.getDepartmentIds()));
entities.add(entity);
}
if (CollUtil.isNotEmpty(entities)) {
processingOperationMaterialMapper.insertBatch(entities);
}
}
private Map<Long, List<ProcessingInfomationOperationMaterialRespVO>> buildMaterialDetailMap(Collection<Long> relationIds) {
if (CollUtil.isEmpty(relationIds)) {
return Collections.emptyMap();
}
List<ProcessingOperationMaterialDO> materialList = processingOperationMaterialMapper.selectListByProcessingOperationIds(relationIds);
if (CollUtil.isEmpty(materialList)) {
return Collections.emptyMap();
}
Set<Long> materialIds = materialList.stream()
.map(ProcessingOperationMaterialDO::getMaterialId)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
Map<Long, MaterialInfomationDO> materialMap = Collections.emptyMap();
if (CollUtil.isNotEmpty(materialIds)) {
List<MaterialInfomationDO> materials = materialInfomationMapper.selectBatchIds(materialIds);
if (CollUtil.isNotEmpty(materials)) {
materialMap = materials.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(MaterialInfomationDO::getId, Function.identity(), (v1, v2) -> v1));
}
}
Set<Long> deptIds = materialList.stream()
.flatMap(item -> parseDepartmentIds(item.getDepartmentIds()).stream())
.collect(Collectors.toSet());
Map<Long, DeptRespDTO> deptMap = loadDeptMap(deptIds);
Map<Long, List<ProcessingInfomationOperationMaterialRespVO>> result = new LinkedHashMap<>();
for (ProcessingOperationMaterialDO item : materialList) {
ProcessingInfomationOperationMaterialRespVO resp = buildMaterialResp(item, materialMap, deptMap);
result.computeIfAbsent(item.getProcessingOperationId(), key -> new ArrayList<>()).add(resp);
}
return result;
}
private Map<Long, DeptRespDTO> loadDeptMap(Set<Long> deptIds) {
if (CollUtil.isEmpty(deptIds)) {
return Collections.emptyMap();
}
try {
List<DeptRespDTO> deptList = deptApi.getDeptList(deptIds).getCheckedData();
if (CollUtil.isEmpty(deptList)) {
return Collections.emptyMap();
}
return deptList.stream()
.filter(Objects::nonNull)
.collect(Collectors.toMap(DeptRespDTO::getId, Function.identity(), (v1, v2) -> v1));
} catch (Exception ex) {
return Collections.emptyMap();
}
}
private ProcessingInfomationOperationMaterialRespVO buildMaterialResp(ProcessingOperationMaterialDO materialDO,
Map<Long, MaterialInfomationDO> materialMap,
Map<Long, DeptRespDTO> deptMap) {
ProcessingInfomationOperationMaterialRespVO resp = new ProcessingInfomationOperationMaterialRespVO();
resp.setId(materialDO.getId());
resp.setProcessingOperationId(materialDO.getProcessingOperationId());
resp.setMaterialId(materialDO.getMaterialId());
resp.setTypeValue(materialDO.getTypeValue());
resp.setRemark(materialDO.getRemark());
resp.setCreateTime(materialDO.getCreateTime());
MaterialInfomationDO material = materialMap.get(materialDO.getMaterialId());
if (material != null) {
resp.setMaterialCode(material.getCode());
resp.setMaterialName(material.getName());
}
List<Long> deptIds = parseDepartmentIds(materialDO.getDepartmentIds());
resp.setDepartmentIds(new ArrayList<>(deptIds));
if (CollUtil.isNotEmpty(deptIds)) {
List<ProcessingInfomationOperationMaterialDeptRespVO> deptInfos = deptIds.stream()
.map(id -> {
ProcessingInfomationOperationMaterialDeptRespVO deptResp = new ProcessingInfomationOperationMaterialDeptRespVO();
deptResp.setId(id);
DeptRespDTO dept = deptMap.get(id);
if (dept != null) {
deptResp.setName(dept.getName());
}
return deptResp;
})
.collect(Collectors.toList());
resp.setDepartments(deptInfos);
} else {
resp.setDepartments(Collections.emptyList());
}
return resp;
}
}
private List<Long> parseDepartmentIds(String raw) {
if (StrUtil.isBlank(raw)) {
return Collections.emptyList();
}
return Arrays.stream(raw.split(","))
.map(String::trim)
.filter(StrUtil::isNotEmpty)
.map(id -> {
try {
return Long.parseLong(id);
} catch (NumberFormatException ex) {
return null;
}
})
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
}
private String formatDepartmentIds(List<Long> deptIds) {
if (CollUtil.isEmpty(deptIds)) {
return null;
}
List<Long> normalized = deptIds.stream()
.filter(Objects::nonNull)
.distinct()
.collect(Collectors.toList());
if (CollUtil.isEmpty(normalized)) {
return null;
}
return CollUtil.join(normalized, ",");
}
private <T> PageResult<T> paginate(List<T> list, Integer pageNo, Integer pageSize) {
if (CollUtil.isEmpty(list)) {
return new PageResult<>(Collections.emptyList(), 0L);
}
int current = pageNo == null || pageNo <= 0 ? 1 : pageNo;
int size = pageSize == null || pageSize <= 0 ? list.size() : pageSize;
int fromIndex = Math.min((current - 1) * size, list.size());
int toIndex = Math.min(fromIndex + size, list.size());
List<T> pageList = list.subList(fromIndex, toIndex);
return new PageResult<>(pageList, (long) list.size());
}
}

8
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/service/processingoperation/ProcessingOperationService.java
View File

@@ -66,4 +66,12 @@ public interface ProcessingOperationService {
*/
List<ProcessingOperationDO> getProcessingOperationList();
/**
* 按类型获得工序列表
*
* @param typeValue 工序类型值，可为空
* @return 工序列表
*/
List<ProcessingOperationDO> getProcessingOperationListByType(String typeValue);
}

9
zt-module-base/zt-module-base-server/src/main/java/com/zt/plat/module/base/service/processingoperation/ProcessingOperationServiceImpl.java
View File

@@ -1,6 +1,7 @@
package com.zt.plat.module.base.service.processingoperation;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;
import org.springframework.validation.annotation.Validated;
@@ -91,7 +92,13 @@ public class ProcessingOperationServiceImpl implements ProcessingOperationServic
@Override
public List<ProcessingOperationDO> getProcessingOperationList() {
return processingOperationMapper.selectList();
return processingOperationMapper.selectSimpleList(null);
}
@Override
public List<ProcessingOperationDO> getProcessingOperationListByType(String typeValue) {
String normalized = StrUtil.isBlank(typeValue) ? null : StrUtil.trim(typeValue);
return processingOperationMapper.selectSimpleList(normalized);
}
}