diff --git a/klp-admin/pom.xml b/klp-admin/pom.xml index 4c1e44a44..be50e50d3 100644 --- a/klp-admin/pom.xml +++ b/klp-admin/pom.xml @@ -134,6 +134,12 @@ klp-flow + + + com.klp + klp-pt + + org.springframework.boot spring-boot-starter-test diff --git a/klp-generator/src/main/java/com/klp/generator/service/GenTableServiceImpl.java b/klp-generator/src/main/java/com/klp/generator/service/GenTableServiceImpl.java index 1b87c10c2..b5dc768ab 100644 --- a/klp-generator/src/main/java/com/klp/generator/service/GenTableServiceImpl.java +++ b/klp-generator/src/main/java/com/klp/generator/service/GenTableServiceImpl.java @@ -97,7 +97,7 @@ public class GenTableServiceImpl implements IGenTableService { wrapper.like(StringUtils.isNotBlank(genTable.getTableName()), "lower(table_name)", StringUtils.lowerCase(genTable.getTableName())) .like(StringUtils.isNotBlank(genTable.getTableComment()), "lower(table_comment)", StringUtils.lowerCase(genTable.getTableComment())) .between(params.get("beginTime") != null && params.get("endTime") != null, - "create_time", params.get("beginTime"), params.get("endTime")); + "create_time", params.get("beginTime"), params.get("endTime")).orderByDesc("create_time"); return wrapper; } diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProcessQualityGateController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProcessQualityGateController.java new file mode 100644 index 000000000..550801917 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProcessQualityGateController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProcessQualityGateVo; +import com.klp.pt.domain.bo.PtProcessQualityGateBo; +import com.klp.pt.service.IPtProcessQualityGateService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 工艺各工序质检关口 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/processQualityGate") +public class PtProcessQualityGateController extends BaseController { + + private final IPtProcessQualityGateService iPtProcessQualityGateService; + + /** + * 查询工艺各工序质检关口列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProcessQualityGateBo bo, PageQuery pageQuery) { + return iPtProcessQualityGateService.queryPageList(bo, pageQuery); + } + + /** + * 导出工艺各工序质检关口列表 + */ + @Log(title = "工艺各工序质检关口", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProcessQualityGateBo bo, HttpServletResponse response) { + List list = iPtProcessQualityGateService.queryList(bo); + ExcelUtil.exportExcel(list, "工艺各工序质检关口", PtProcessQualityGateVo.class, response); + } + + /** + * 获取工艺各工序质检关口详细信息 + * + * @param gateId 主键 + */ + @GetMapping("/{gateId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long gateId) { + return R.ok(iPtProcessQualityGateService.queryById(gateId)); + } + + /** + * 新增工艺各工序质检关口 + */ + @Log(title = "工艺各工序质检关口", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProcessQualityGateBo bo) { + return toAjax(iPtProcessQualityGateService.insertByBo(bo)); + } + + /** + * 修改工艺各工序质检关口 + */ + @Log(title = "工艺各工序质检关口", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProcessQualityGateBo bo) { + return toAjax(iPtProcessQualityGateService.updateByBo(bo)); + } + + /** + * 删除工艺各工序质检关口 + * + * @param gateIds 主键串 + */ + @Log(title = "工艺各工序质检关口", businessType = BusinessType.DELETE) + @DeleteMapping("/{gateIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] gateIds) { + return toAjax(iPtProcessQualityGateService.deleteWithValidByIds(Arrays.asList(gateIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProcessStepParamController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProcessStepParamController.java new file mode 100644 index 000000000..bf83dbab6 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProcessStepParamController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProcessStepParamVo; +import com.klp.pt.domain.bo.PtProcessStepParamBo; +import com.klp.pt.service.IPtProcessStepParamService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 工艺工序控制参数明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/processStepParam") +public class PtProcessStepParamController extends BaseController { + + private final IPtProcessStepParamService iPtProcessStepParamService; + + /** + * 查询工艺工序控制参数明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProcessStepParamBo bo, PageQuery pageQuery) { + return iPtProcessStepParamService.queryPageList(bo, pageQuery); + } + + /** + * 导出工艺工序控制参数明细列表 + */ + @Log(title = "工艺工序控制参数明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProcessStepParamBo bo, HttpServletResponse response) { + List list = iPtProcessStepParamService.queryList(bo); + ExcelUtil.exportExcel(list, "工艺工序控制参数明细", PtProcessStepParamVo.class, response); + } + + /** + * 获取工艺工序控制参数明细详细信息 + * + * @param paramId 主键 + */ + @GetMapping("/{paramId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long paramId) { + return R.ok(iPtProcessStepParamService.queryById(paramId)); + } + + /** + * 新增工艺工序控制参数明细 + */ + @Log(title = "工艺工序控制参数明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProcessStepParamBo bo) { + return toAjax(iPtProcessStepParamService.insertByBo(bo)); + } + + /** + * 修改工艺工序控制参数明细 + */ + @Log(title = "工艺工序控制参数明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProcessStepParamBo bo) { + return toAjax(iPtProcessStepParamService.updateByBo(bo)); + } + + /** + * 删除工艺工序控制参数明细 + * + * @param paramIds 主键串 + */ + @Log(title = "工艺工序控制参数明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{paramIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] paramIds) { + return toAjax(iPtProcessStepParamService.deleteWithValidByIds(Arrays.asList(paramIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProcesseController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProcesseController.java new file mode 100644 index 000000000..0f4b48520 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProcesseController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProcesseVo; +import com.klp.pt.domain.bo.PtProcesseBo; +import com.klp.pt.service.IPtProcesseService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 生产工艺路线主 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/processe") +public class PtProcesseController extends BaseController { + + private final IPtProcesseService iPtProcesseService; + + /** + * 查询生产工艺路线主列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProcesseBo bo, PageQuery pageQuery) { + return iPtProcesseService.queryPageList(bo, pageQuery); + } + + /** + * 导出生产工艺路线主列表 + */ + @Log(title = "生产工艺路线主", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProcesseBo bo, HttpServletResponse response) { + List list = iPtProcesseService.queryList(bo); + ExcelUtil.exportExcel(list, "生产工艺路线主", PtProcesseVo.class, response); + } + + /** + * 获取生产工艺路线主详细信息 + * + * @param processId 主键 + */ + @GetMapping("/{processId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long processId) { + return R.ok(iPtProcesseService.queryById(processId)); + } + + /** + * 新增生产工艺路线主 + */ + @Log(title = "生产工艺路线主", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProcesseBo bo) { + return toAjax(iPtProcesseService.insertByBo(bo)); + } + + /** + * 修改生产工艺路线主 + */ + @Log(title = "生产工艺路线主", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProcesseBo bo) { + return toAjax(iPtProcesseService.updateByBo(bo)); + } + + /** + * 删除生产工艺路线主 + * + * @param processIds 主键串 + */ + @Log(title = "生产工艺路线主", businessType = BusinessType.DELETE) + @DeleteMapping("/{processIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] processIds) { + return toAjax(iPtProcesseService.deleteWithValidByIds(Arrays.asList(processIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductApplicationController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductApplicationController.java new file mode 100644 index 000000000..5851c21b4 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductApplicationController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductApplicationVo; +import com.klp.pt.domain.bo.PtProductApplicationBo; +import com.klp.pt.service.IPtProductApplicationService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品应用领域明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productApplication") +public class PtProductApplicationController extends BaseController { + + private final IPtProductApplicationService iPtProductApplicationService; + + /** + * 查询产品应用领域明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductApplicationBo bo, PageQuery pageQuery) { + return iPtProductApplicationService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品应用领域明细列表 + */ + @Log(title = "产品应用领域明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductApplicationBo bo, HttpServletResponse response) { + List list = iPtProductApplicationService.queryList(bo); + ExcelUtil.exportExcel(list, "产品应用领域明细", PtProductApplicationVo.class, response); + } + + /** + * 获取产品应用领域明细详细信息 + * + * @param applicationId 主键 + */ + @GetMapping("/{applicationId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long applicationId) { + return R.ok(iPtProductApplicationService.queryById(applicationId)); + } + + /** + * 新增产品应用领域明细 + */ + @Log(title = "产品应用领域明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductApplicationBo bo) { + return toAjax(iPtProductApplicationService.insertByBo(bo)); + } + + /** + * 修改产品应用领域明细 + */ + @Log(title = "产品应用领域明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductApplicationBo bo) { + return toAjax(iPtProductApplicationService.updateByBo(bo)); + } + + /** + * 删除产品应用领域明细 + * + * @param applicationIds 主键串 + */ + @Log(title = "产品应用领域明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{applicationIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] applicationIds) { + return toAjax(iPtProductApplicationService.deleteWithValidByIds(Arrays.asList(applicationIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductChemicalCompositionController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductChemicalCompositionController.java new file mode 100644 index 000000000..7c0ea3c65 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductChemicalCompositionController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductChemicalCompositionVo; +import com.klp.pt.domain.bo.PtProductChemicalCompositionBo; +import com.klp.pt.service.IPtProductChemicalCompositionService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品化学成分明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productChemicalComposition") +public class PtProductChemicalCompositionController extends BaseController { + + private final IPtProductChemicalCompositionService iPtProductChemicalCompositionService; + + /** + * 查询产品化学成分明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductChemicalCompositionBo bo, PageQuery pageQuery) { + return iPtProductChemicalCompositionService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品化学成分明细列表 + */ + @Log(title = "产品化学成分明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductChemicalCompositionBo bo, HttpServletResponse response) { + List list = iPtProductChemicalCompositionService.queryList(bo); + ExcelUtil.exportExcel(list, "产品化学成分明细", PtProductChemicalCompositionVo.class, response); + } + + /** + * 获取产品化学成分明细详细信息 + * + * @param compositionId 主键 + */ + @GetMapping("/{compositionId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long compositionId) { + return R.ok(iPtProductChemicalCompositionService.queryById(compositionId)); + } + + /** + * 新增产品化学成分明细 + */ + @Log(title = "产品化学成分明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductChemicalCompositionBo bo) { + return toAjax(iPtProductChemicalCompositionService.insertByBo(bo)); + } + + /** + * 修改产品化学成分明细 + */ + @Log(title = "产品化学成分明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductChemicalCompositionBo bo) { + return toAjax(iPtProductChemicalCompositionService.updateByBo(bo)); + } + + /** + * 删除产品化学成分明细 + * + * @param compositionIds 主键串 + */ + @Log(title = "产品化学成分明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{compositionIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] compositionIds) { + return toAjax(iPtProductChemicalCompositionService.deleteWithValidByIds(Arrays.asList(compositionIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductCoatingSpecController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductCoatingSpecController.java new file mode 100644 index 000000000..aa8be06b9 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductCoatingSpecController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductCoatingSpecVo; +import com.klp.pt.domain.bo.PtProductCoatingSpecBo; +import com.klp.pt.service.IPtProductCoatingSpecService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 镀锌/镀铬镀层规范明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productCoatingSpec") +public class PtProductCoatingSpecController extends BaseController { + + private final IPtProductCoatingSpecService iPtProductCoatingSpecService; + + /** + * 查询镀锌/镀铬镀层规范明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductCoatingSpecBo bo, PageQuery pageQuery) { + return iPtProductCoatingSpecService.queryPageList(bo, pageQuery); + } + + /** + * 导出镀锌/镀铬镀层规范明细列表 + */ + @Log(title = "镀锌/镀铬镀层规范明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductCoatingSpecBo bo, HttpServletResponse response) { + List list = iPtProductCoatingSpecService.queryList(bo); + ExcelUtil.exportExcel(list, "镀锌/镀铬镀层规范明细", PtProductCoatingSpecVo.class, response); + } + + /** + * 获取镀锌/镀铬镀层规范明细详细信息 + * + * @param coatingId 主键 + */ + @GetMapping("/{coatingId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long coatingId) { + return R.ok(iPtProductCoatingSpecService.queryById(coatingId)); + } + + /** + * 新增镀锌/镀铬镀层规范明细 + */ + @Log(title = "镀锌/镀铬镀层规范明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductCoatingSpecBo bo) { + return toAjax(iPtProductCoatingSpecService.insertByBo(bo)); + } + + /** + * 修改镀锌/镀铬镀层规范明细 + */ + @Log(title = "镀锌/镀铬镀层规范明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductCoatingSpecBo bo) { + return toAjax(iPtProductCoatingSpecService.updateByBo(bo)); + } + + /** + * 删除镀锌/镀铬镀层规范明细 + * + * @param coatingIds 主键串 + */ + @Log(title = "镀锌/镀铬镀层规范明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{coatingIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] coatingIds) { + return toAjax(iPtProductCoatingSpecService.deleteWithValidByIds(Arrays.asList(coatingIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductDimensionController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductDimensionController.java new file mode 100644 index 000000000..86d332085 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductDimensionController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductDimensionVo; +import com.klp.pt.domain.bo.PtProductDimensionBo; +import com.klp.pt.service.IPtProductDimensionService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品规格尺寸范围明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productDimension") +public class PtProductDimensionController extends BaseController { + + private final IPtProductDimensionService iPtProductDimensionService; + + /** + * 查询产品规格尺寸范围明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductDimensionBo bo, PageQuery pageQuery) { + return iPtProductDimensionService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品规格尺寸范围明细列表 + */ + @Log(title = "产品规格尺寸范围明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductDimensionBo bo, HttpServletResponse response) { + List list = iPtProductDimensionService.queryList(bo); + ExcelUtil.exportExcel(list, "产品规格尺寸范围明细", PtProductDimensionVo.class, response); + } + + /** + * 获取产品规格尺寸范围明细详细信息 + * + * @param dimensionId 主键 + */ + @GetMapping("/{dimensionId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long dimensionId) { + return R.ok(iPtProductDimensionService.queryById(dimensionId)); + } + + /** + * 新增产品规格尺寸范围明细 + */ + @Log(title = "产品规格尺寸范围明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductDimensionBo bo) { + return toAjax(iPtProductDimensionService.insertByBo(bo)); + } + + /** + * 修改产品规格尺寸范围明细 + */ + @Log(title = "产品规格尺寸范围明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductDimensionBo bo) { + return toAjax(iPtProductDimensionService.updateByBo(bo)); + } + + /** + * 删除产品规格尺寸范围明细 + * + * @param dimensionIds 主键串 + */ + @Log(title = "产品规格尺寸范围明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{dimensionIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] dimensionIds) { + return toAjax(iPtProductDimensionService.deleteWithValidByIds(Arrays.asList(dimensionIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductPhysicalPropertyController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductPhysicalPropertyController.java new file mode 100644 index 000000000..55cb3faed --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductPhysicalPropertyController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductPhysicalPropertyVo; +import com.klp.pt.domain.bo.PtProductPhysicalPropertyBo; +import com.klp.pt.service.IPtProductPhysicalPropertyService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品力学物理性能明细 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productPhysicalProperty") +public class PtProductPhysicalPropertyController extends BaseController { + + private final IPtProductPhysicalPropertyService iPtProductPhysicalPropertyService; + + /** + * 查询产品力学物理性能明细列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductPhysicalPropertyBo bo, PageQuery pageQuery) { + return iPtProductPhysicalPropertyService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品力学物理性能明细列表 + */ + @Log(title = "产品力学物理性能明细", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductPhysicalPropertyBo bo, HttpServletResponse response) { + List list = iPtProductPhysicalPropertyService.queryList(bo); + ExcelUtil.exportExcel(list, "产品力学物理性能明细", PtProductPhysicalPropertyVo.class, response); + } + + /** + * 获取产品力学物理性能明细详细信息 + * + * @param propertyId 主键 + */ + @GetMapping("/{propertyId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long propertyId) { + return R.ok(iPtProductPhysicalPropertyService.queryById(propertyId)); + } + + /** + * 新增产品力学物理性能明细 + */ + @Log(title = "产品力学物理性能明细", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductPhysicalPropertyBo bo) { + return toAjax(iPtProductPhysicalPropertyService.insertByBo(bo)); + } + + /** + * 修改产品力学物理性能明细 + */ + @Log(title = "产品力学物理性能明细", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductPhysicalPropertyBo bo) { + return toAjax(iPtProductPhysicalPropertyService.updateByBo(bo)); + } + + /** + * 删除产品力学物理性能明细 + * + * @param propertyIds 主键串 + */ + @Log(title = "产品力学物理性能明细", businessType = BusinessType.DELETE) + @DeleteMapping("/{propertyIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] propertyIds) { + return toAjax(iPtProductPhysicalPropertyService.deleteWithValidByIds(Arrays.asList(propertyIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductProcessRouteController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductProcessRouteController.java new file mode 100644 index 000000000..9e922c8b4 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductProcessRouteController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductProcessRouteVo; +import com.klp.pt.domain.bo.PtProductProcessRouteBo; +import com.klp.pt.service.IPtProductProcessRouteService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品标准绑定生产工艺中间 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productProcessRoute") +public class PtProductProcessRouteController extends BaseController { + + private final IPtProductProcessRouteService iPtProductProcessRouteService; + + /** + * 查询产品标准绑定生产工艺中间列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductProcessRouteBo bo, PageQuery pageQuery) { + return iPtProductProcessRouteService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品标准绑定生产工艺中间列表 + */ + @Log(title = "产品标准绑定生产工艺中间", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductProcessRouteBo bo, HttpServletResponse response) { + List list = iPtProductProcessRouteService.queryList(bo); + ExcelUtil.exportExcel(list, "产品标准绑定生产工艺中间", PtProductProcessRouteVo.class, response); + } + + /** + * 获取产品标准绑定生产工艺中间详细信息 + * + * @param routeId 主键 + */ + @GetMapping("/{routeId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long routeId) { + return R.ok(iPtProductProcessRouteService.queryById(routeId)); + } + + /** + * 新增产品标准绑定生产工艺中间 + */ + @Log(title = "产品标准绑定生产工艺中间", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductProcessRouteBo bo) { + return toAjax(iPtProductProcessRouteService.insertByBo(bo)); + } + + /** + * 修改产品标准绑定生产工艺中间 + */ + @Log(title = "产品标准绑定生产工艺中间", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductProcessRouteBo bo) { + return toAjax(iPtProductProcessRouteService.updateByBo(bo)); + } + + /** + * 删除产品标准绑定生产工艺中间 + * + * @param routeIds 主键串 + */ + @Log(title = "产品标准绑定生产工艺中间", businessType = BusinessType.DELETE) + @DeleteMapping("/{routeIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] routeIds) { + return toAjax(iPtProductProcessRouteService.deleteWithValidByIds(Arrays.asList(routeIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductRefStandardController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductRefStandardController.java new file mode 100644 index 000000000..fc0970d2b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductRefStandardController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductRefStandardVo; +import com.klp.pt.domain.bo.PtProductRefStandardBo; +import com.klp.pt.service.IPtProductRefStandardService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品引用外部标准 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productRefStandard") +public class PtProductRefStandardController extends BaseController { + + private final IPtProductRefStandardService iPtProductRefStandardService; + + /** + * 查询产品引用外部标准列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductRefStandardBo bo, PageQuery pageQuery) { + return iPtProductRefStandardService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品引用外部标准列表 + */ + @Log(title = "产品引用外部标准", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductRefStandardBo bo, HttpServletResponse response) { + List list = iPtProductRefStandardService.queryList(bo); + ExcelUtil.exportExcel(list, "产品引用外部标准", PtProductRefStandardVo.class, response); + } + + /** + * 获取产品引用外部标准详细信息 + * + * @param refId 主键 + */ + @GetMapping("/{refId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long refId) { + return R.ok(iPtProductRefStandardService.queryById(refId)); + } + + /** + * 新增产品引用外部标准 + */ + @Log(title = "产品引用外部标准", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductRefStandardBo bo) { + return toAjax(iPtProductRefStandardService.insertByBo(bo)); + } + + /** + * 修改产品引用外部标准 + */ + @Log(title = "产品引用外部标准", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductRefStandardBo bo) { + return toAjax(iPtProductRefStandardService.updateByBo(bo)); + } + + /** + * 删除产品引用外部标准 + * + * @param refIds 主键串 + */ + @Log(title = "产品引用外部标准", businessType = BusinessType.DELETE) + @DeleteMapping("/{refIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] refIds) { + return toAjax(iPtProductRefStandardService.deleteWithValidByIds(Arrays.asList(refIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/controller/PtProductStandardController.java b/klp-pt/src/main/java/com/klp/pt/controller/PtProductStandardController.java new file mode 100644 index 000000000..e1edaaf11 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/controller/PtProductStandardController.java @@ -0,0 +1,99 @@ +package com.klp.pt.controller; + +import java.util.List; +import java.util.Arrays; + +import lombok.RequiredArgsConstructor; +import javax.servlet.http.HttpServletResponse; +import javax.validation.constraints.*; +import org.springframework.web.bind.annotation.*; +import org.springframework.validation.annotation.Validated; +import com.klp.common.annotation.RepeatSubmit; +import com.klp.common.annotation.Log; +import com.klp.common.core.controller.BaseController; +import com.klp.common.core.domain.PageQuery; +import com.klp.common.core.domain.R; +import com.klp.common.core.validate.AddGroup; +import com.klp.common.core.validate.EditGroup; +import com.klp.common.enums.BusinessType; +import com.klp.common.utils.poi.ExcelUtil; +import com.klp.pt.domain.vo.PtProductStandardVo; +import com.klp.pt.domain.bo.PtProductStandardBo; +import com.klp.pt.service.IPtProductStandardService; +import com.klp.common.core.page.TableDataInfo; + +/** + * 产品标准主 + * + * @author klp + * @date 2026-07-02 + */ +@Validated +@RequiredArgsConstructor +@RestController +@RequestMapping("/pt/productStandard") +public class PtProductStandardController extends BaseController { + + private final IPtProductStandardService iPtProductStandardService; + + /** + * 查询产品标准主列表 + */ + @GetMapping("/list") + public TableDataInfo list(PtProductStandardBo bo, PageQuery pageQuery) { + return iPtProductStandardService.queryPageList(bo, pageQuery); + } + + /** + * 导出产品标准主列表 + */ + @Log(title = "产品标准主", businessType = BusinessType.EXPORT) + @PostMapping("/export") + public void export(PtProductStandardBo bo, HttpServletResponse response) { + List list = iPtProductStandardService.queryList(bo); + ExcelUtil.exportExcel(list, "产品标准主", PtProductStandardVo.class, response); + } + + /** + * 获取产品标准主详细信息 + * + * @param standardId 主键 + */ + @GetMapping("/{standardId}") + public R getInfo(@NotNull(message = "主键不能为空") + @PathVariable Long standardId) { + return R.ok(iPtProductStandardService.queryById(standardId)); + } + + /** + * 新增产品标准主 + */ + @Log(title = "产品标准主", businessType = BusinessType.INSERT) + @RepeatSubmit() + @PostMapping() + public R add(@Validated(AddGroup.class) @RequestBody PtProductStandardBo bo) { + return toAjax(iPtProductStandardService.insertByBo(bo)); + } + + /** + * 修改产品标准主 + */ + @Log(title = "产品标准主", businessType = BusinessType.UPDATE) + @RepeatSubmit() + @PutMapping() + public R edit(@Validated(EditGroup.class) @RequestBody PtProductStandardBo bo) { + return toAjax(iPtProductStandardService.updateByBo(bo)); + } + + /** + * 删除产品标准主 + * + * @param standardIds 主键串 + */ + @Log(title = "产品标准主", businessType = BusinessType.DELETE) + @DeleteMapping("/{standardIds}") + public R remove(@NotEmpty(message = "主键不能为空") + @PathVariable Long[] standardIds) { + return toAjax(iPtProductStandardService.deleteWithValidByIds(Arrays.asList(standardIds), true)); + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProcessQualityGate.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProcessQualityGate.java new file mode 100644 index 000000000..c6ead7034 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProcessQualityGate.java @@ -0,0 +1,90 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 工艺各工序质检关口对象 pt_process_quality_gate + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_process_quality_gate") +public class PtProcessQualityGate extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "gate_id") + private Long gateId; + /** + * 关联工艺ID + */ + private Long processId; + /** + * 对应工序序号 + */ + private Long stepOrder; + /** + * 质检关口名称 + */ + private String gateName; + /** + * 在线/离线/破坏性检测 + */ + private String gateType; + /** + * 检测项目 + */ + private String inspectionItem; + /** + * 仪器/检测方法 + */ + private String measurementMethod; + /** + * 检测频率每卷/每小时 + */ + private String frequency; + /** + * + */ + private BigDecimal specMin; + /** + * + */ + private BigDecimal specMax; + /** + * + */ + private String unit; + /** + * 报警/降速/停机 + */ + private String reactionRule; + /** + * 1不合格停机关门 + */ + private Long isGateStop; + /** + * + */ + private Long sortOrder; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProcessStepParam.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProcessStepParam.java new file mode 100644 index 000000000..a82ce30e2 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProcessStepParam.java @@ -0,0 +1,94 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 工艺工序控制参数明细对象 pt_process_step_param + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_process_step_param") +public class PtProcessStepParam extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "param_id") + private Long paramId; + /** + * 关联工艺ID + */ + private Long processId; + /** + * 工序排序 + */ + private Long stepOrder; + /** + * 工序名称酸洗/冷轧/退火/镀锌 + */ + private String stepName; + /** + * 参数编码TEMP/SPEED/TENSION + */ + private String paramCode; + /** + * + */ + private String paramNameZh; + /** + * 温度/速度/压力/电流 + */ + private String paramCategory; + /** + * + */ + private BigDecimal minValue; + /** + * + */ + private BigDecimal maxValue; + /** + * + */ + private BigDecimal targetValue; + /** + * + */ + private String unit; + /** + * 1关键CCP控制点 + */ + private Long isCritical; + /** + * 报警下限 + */ + private BigDecimal alarmMin; + /** + * 报警上限 + */ + private BigDecimal alarmMax; + /** + * + */ + private Long sortOrder; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProcesse.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProcesse.java new file mode 100644 index 000000000..1c883db39 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProcesse.java @@ -0,0 +1,85 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 生产工艺路线主对象 pt_processe + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_processe") +public class PtProcesse extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * 工艺路线主键 + */ + @TableId(value = "process_id") + private Long processId; + /** + * 工艺编码唯一 + */ + private String processCode; + /** + * 工艺名称 + */ + private String processName; + /** + * 适配产品类型逗号分隔 + */ + private String adaptProductType; + /** + * 所属产线ID + */ + private Long lineId; + /** + * + */ + @Version + private BigDecimal version; + /** + * 1启用 0停用 + */ + private Long status; + /** + * + */ + private Date effectiveDate; + /** + * + */ + private Date expireDate; + /** + * 整体工艺流程描述 + */ + private String flowOverview; + /** + * 目标成材率% + */ + private BigDecimal targetYield; + /** + * 标准产能t/h + */ + private BigDecimal standardCapacity; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductApplication.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductApplication.java new file mode 100644 index 000000000..0fe812fb8 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductApplication.java @@ -0,0 +1,65 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + + +/** + * 产品应用领域明细对象 pt_product_application + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_application") +public class PtProductApplication extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "application_id") + private Long applicationId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * AUTOMOTIVE/APPLIANCE/CONSTRUCTION + */ + private String industrySector; + /** + * 汽车/家电/建筑 + */ + private String sectorNameZh; + /** + * 使用场景 + */ + private String applicationDesc; + /** + * 冲压/拉深/焊接 + */ + private String processingMethod; + /** + * 典型零件 + */ + private String typicalPart; + /** + * 室内/户外腐蚀环境 + */ + private String exposureCondition; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductChemicalComposition.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductChemicalComposition.java new file mode 100644 index 000000000..6b75cb4d8 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductChemicalComposition.java @@ -0,0 +1,74 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 产品化学成分明细对象 pt_product_chemical_composition + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_chemical_composition") +public class PtProductChemicalComposition extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "composition_id") + private Long compositionId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * 元素C/Mn/Si/P/S + */ + private String elementSymbol; + /** + * + */ + private String elementNameZh; + /** + * 最小质量分数% + */ + private BigDecimal minPercent; + /** + * 最大质量分数% + */ + private BigDecimal maxPercent; + /** + * 标称值 + */ + private BigDecimal nominalPercent; + /** + * 熔炼/成品分析 + */ + private String analysisType; + /** + * 0普通 1关键限制元素 + */ + private Long isKeyElement; + /** + * + */ + private Long sortOrder; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductCoatingSpec.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductCoatingSpec.java new file mode 100644 index 000000000..701f8e7f9 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductCoatingSpec.java @@ -0,0 +1,86 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 镀锌/镀铬镀层规范明细对象 pt_product_coating_spec + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_coating_spec") +public class PtProductCoatingSpec extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "coating_id") + private Long coatingId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * GI/GA/TFS + */ + private String coatingType; + /** + * Z120/Z275 + */ + private String coatingDesignation; + /** + * 双面镀层下限g/m² + */ + private BigDecimal coatingWeightMin; + /** + * + */ + private BigDecimal coatingWeightMax; + /** + * + */ + private BigDecimal coatingWeightTarget; + /** + * 单点镀层重量 + */ + private BigDecimal singleSpotMin; + /** + * 有无锌花 + */ + private String surfaceFinish; + /** + * 钝化/涂油 + */ + private String surfaceTreatment; + /** + * 弯曲试验0t/1t + */ + private String bendTestMandrel; + /** + * 白锈小时 + */ + private Long saltSprayHoursWhite; + /** + * 红锈小时 + */ + private Long saltSprayHoursRed; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductDimension.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductDimension.java new file mode 100644 index 000000000..0aae47222 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductDimension.java @@ -0,0 +1,74 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import lombok.Data; +import com.klp.common.core.domain.BaseEntity; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 产品规格尺寸范围明细对象 pt_product_dimension + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_dimension") +public class PtProductDimension extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "dimension_id") + private Long dimensionId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * 维度编码THICKNESS/WIDTH/INNER_DIAMETER/COIL_WEIGHT + */ + private String dimCode; + /** + * 维度名称 + */ + private String dimNameZh; + /** + * 最小值 + */ + private BigDecimal minValue; + /** + * 最大值 + */ + private BigDecimal maxValue; + /** + * 单位mm/t/kg + */ + private String unit; + /** + * 推荐规格逗号分隔 + */ + private String preferredValues; + /** + * 关联公差等级 + */ + private String toleranceGradeRef; + /** + * + */ + private Long sortOrder; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductPhysicalProperty.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductPhysicalProperty.java new file mode 100644 index 000000000..c5a3f8fbf --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductPhysicalProperty.java @@ -0,0 +1,94 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 产品力学物理性能明细对象 pt_product_physical_property + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_physical_property") +public class PtProductPhysicalProperty extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "property_id") + private Long propertyId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * 性能编码YS/TS/EL/HV/R_VALUE + */ + private String propertyCode; + /** + * + */ + private String propertyNameZh; + /** + * + */ + private BigDecimal minValue; + /** + * + */ + private BigDecimal maxValue; + /** + * + */ + private BigDecimal targetValue; + /** + * MPa / % / HV / μm + */ + private String unit; + /** + * 检测国标 + */ + private String testStandard; + /** + * 取样方向 + */ + private String testDirection; + /** + * 适用厚度下限 + */ + private BigDecimal applicableThickMin; + /** + * 适用厚度上限 + */ + private BigDecimal applicableThickMax; + /** + * 厚度分档说明 + */ + private String applicableThickDesc; + /** + * 1必检 0参考 + */ + private Long isMandatory; + /** + * + */ + private Long sortOrder; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductProcessRoute.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductProcessRoute.java new file mode 100644 index 000000000..246cd1b88 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductProcessRoute.java @@ -0,0 +1,66 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; + +/** + * 产品标准绑定生产工艺中间对象 pt_product_process_route + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_process_route") +public class PtProductProcessRoute extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "route_id") + private Long routeId; + /** + * 产品标准ID + */ + private Long standardId; + /** + * 工艺路线ID + */ + private Long processId; + /** + * 优先级越小越优先 + */ + private Long routeSequence; + /** + * 1该产品默认生产工艺 + */ + private Long isDefaultRoute; + /** + * 适用条件：厚度≤1.2mm + */ + private String applicabilityRule; + /** + * 预估成材率 + */ + private BigDecimal estimatedYield; + /** + * 成本相对指数 + */ + private Long costIndex; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductRefStandard.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductRefStandard.java new file mode 100644 index 000000000..dfbfcd140 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductRefStandard.java @@ -0,0 +1,57 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + + +/** + * 产品引用外部标准对象 pt_product_ref_standard + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_ref_standard") +public class PtProductRefStandard extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * + */ + @TableId(value = "ref_id") + private Long refId; + /** + * 关联产品标准ID + */ + private Long standardId; + /** + * GB/T 2518-2019 + */ + private String refStandardCode; + /** + * + */ + private String refStandardName; + /** + * GB/JIS/ASTM + */ + private String refOrganization; + /** + * 引用章节 + */ + private String refSection; + /** + * + */ + private String remark; + /** + * + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/PtProductStandard.java b/klp-pt/src/main/java/com/klp/pt/domain/PtProductStandard.java new file mode 100644 index 000000000..a9790441f --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/PtProductStandard.java @@ -0,0 +1,89 @@ +package com.klp.pt.domain; + +import com.baomidou.mybatisplus.annotation.*; +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 产品标准主对象 pt_product_standard + * + * @author klp + * @date 2026-07-02 + */ +@Data +@EqualsAndHashCode(callSuper = true) +@TableName("pt_product_standard") +public class PtProductStandard extends BaseEntity { + + private static final long serialVersionUID=1L; + + /** + * 产品标准主键ID + */ + @TableId(value = "standard_id") + private Long standardId; + /** + * 产品标准编码(唯一) + */ + private String standardCode; + /** + * 产品标准全称 + */ + private String standardName; + /** + * 产品类型:CRC冷硬/冷轧,GI热镀锌,GA合金化镀锌,TFS镀铬,FHC花纹钢 + */ + private String productType; + /** + * 钢种牌号 DC01/SPHC/Q235 + */ + private String steelGrade; + /** + * 等效牌号逗号分隔 + */ + private String steelGradeAlias; + /** + * 形态COIL钢卷/SHEET平板/STRIP窄带 + */ + private String productForm; + /** + * 产品分类ID(可扩展分类表) + */ + private Long categoryId; + /** + * 1草案 2生效 3废止 + */ + private Long status; + /** + * 生效日期 + */ + private Date effectiveDate; + /** + * 失效日期 + */ + private Date expireDate; + /** + * 版本号 + */ + @Version + private BigDecimal version; + /** + * 0否 1该牌号默认标准 + */ + private Long isDefault; + /** + * 备注 + */ + private String remark; + /** + * 0正常 1删除 + */ + @TableLogic + private Long delFlag; + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessQualityGateBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessQualityGateBo.java new file mode 100644 index 000000000..96a2a1fa9 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessQualityGateBo.java @@ -0,0 +1,97 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 工艺各工序质检关口业务对象 pt_process_quality_gate + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProcessQualityGateBo extends BaseEntity { + + /** + * + */ + private Long gateId; + + /** + * 关联工艺ID + */ + private Long processId; + + /** + * 对应工序序号 + */ + private Long stepOrder; + + /** + * 质检关口名称 + */ + private String gateName; + + /** + * 在线/离线/破坏性检测 + */ + private String gateType; + + /** + * 检测项目 + */ + private String inspectionItem; + + /** + * 仪器/检测方法 + */ + private String measurementMethod; + + /** + * 检测频率每卷/每小时 + */ + private String frequency; + + /** + * + */ + private BigDecimal specMin; + + /** + * + */ + private BigDecimal specMax; + + /** + * + */ + private String unit; + + /** + * 报警/降速/停机 + */ + private String reactionRule; + + /** + * 1不合格停机关门 + */ + private Long isGateStop; + + /** + * + */ + private Long sortOrder; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessStepParamBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessStepParamBo.java new file mode 100644 index 000000000..d605a455f --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcessStepParamBo.java @@ -0,0 +1,102 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 工艺工序控制参数明细业务对象 pt_process_step_param + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProcessStepParamBo extends BaseEntity { + + /** + * + */ + private Long paramId; + + /** + * 关联工艺ID + */ + private Long processId; + + /** + * 工序排序 + */ + private Long stepOrder; + + /** + * 工序名称酸洗/冷轧/退火/镀锌 + */ + private String stepName; + + /** + * 参数编码TEMP/SPEED/TENSION + */ + private String paramCode; + + /** + * + */ + private String paramNameZh; + + /** + * 温度/速度/压力/电流 + */ + private String paramCategory; + + /** + * + */ + private BigDecimal minValue; + + /** + * + */ + private BigDecimal maxValue; + + /** + * + */ + private BigDecimal targetValue; + + /** + * + */ + private String unit; + + /** + * 1关键CCP控制点 + */ + private Long isCritical; + + /** + * 报警下限 + */ + private BigDecimal alarmMin; + + /** + * 报警上限 + */ + private BigDecimal alarmMax; + + /** + * + */ + private Long sortOrder; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcesseBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcesseBo.java new file mode 100644 index 000000000..10f601c3f --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProcesseBo.java @@ -0,0 +1,84 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 生产工艺路线主业务对象 pt_processe + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProcesseBo extends BaseEntity { + + /** + * 工艺路线主键 + */ + private Long processId; + + /** + * 工艺编码唯一 + */ + private String processCode; + + /** + * 工艺名称 + */ + private String processName; + + /** + * 适配产品类型逗号分隔 + */ + private String adaptProductType; + + /** + * 所属产线ID + */ + private Long lineId; + + /** + * 1启用 0停用 + */ + private Long status; + + /** + * + */ + private Date effectiveDate; + + /** + * + */ + private Date expireDate; + + /** + * 整体工艺流程描述 + */ + private String flowOverview; + + /** + * 目标成材率% + */ + private BigDecimal targetYield; + + /** + * 标准产能t/h + */ + private BigDecimal standardCapacity; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductApplicationBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductApplicationBo.java new file mode 100644 index 000000000..2de15fb62 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductApplicationBo.java @@ -0,0 +1,66 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + + +/** + * 产品应用领域明细业务对象 pt_product_application + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductApplicationBo extends BaseEntity { + + /** + * + */ + private Long applicationId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * AUTOMOTIVE/APPLIANCE/CONSTRUCTION + */ + private String industrySector; + + /** + * 汽车/家电/建筑 + */ + private String sectorNameZh; + + /** + * 使用场景 + */ + private String applicationDesc; + + /** + * 冲压/拉深/焊接 + */ + private String processingMethod; + + /** + * 典型零件 + */ + private String typicalPart; + + /** + * 室内/户外腐蚀环境 + */ + private String exposureCondition; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductChemicalCompositionBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductChemicalCompositionBo.java new file mode 100644 index 000000000..95eefe7dd --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductChemicalCompositionBo.java @@ -0,0 +1,77 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 产品化学成分明细业务对象 pt_product_chemical_composition + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductChemicalCompositionBo extends BaseEntity { + + /** + * + */ + private Long compositionId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * 元素C/Mn/Si/P/S + */ + private String elementSymbol; + + /** + * + */ + private String elementNameZh; + + /** + * 最小质量分数% + */ + private BigDecimal minPercent; + + /** + * 最大质量分数% + */ + private BigDecimal maxPercent; + + /** + * 标称值 + */ + private BigDecimal nominalPercent; + + /** + * 熔炼/成品分析 + */ + private String analysisType; + + /** + * 0普通 1关键限制元素 + */ + private Long isKeyElement; + + /** + * + */ + private Long sortOrder; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductCoatingSpecBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductCoatingSpecBo.java new file mode 100644 index 000000000..7eb92b0e4 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductCoatingSpecBo.java @@ -0,0 +1,92 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 镀锌/镀铬镀层规范明细业务对象 pt_product_coating_spec + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductCoatingSpecBo extends BaseEntity { + + /** + * + */ + private Long coatingId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * GI/GA/TFS + */ + private String coatingType; + + /** + * Z120/Z275 + */ + private String coatingDesignation; + + /** + * 双面镀层下限g/m² + */ + private BigDecimal coatingWeightMin; + + /** + * + */ + private BigDecimal coatingWeightMax; + + /** + * + */ + private BigDecimal coatingWeightTarget; + + /** + * 单点镀层重量 + */ + private BigDecimal singleSpotMin; + + /** + * 有无锌花 + */ + private String surfaceFinish; + + /** + * 钝化/涂油 + */ + private String surfaceTreatment; + + /** + * 弯曲试验0t/1t + */ + private String bendTestMandrel; + + /** + * 白锈小时 + */ + private Long saltSprayHoursWhite; + + /** + * 红锈小时 + */ + private Long saltSprayHoursRed; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductDimensionBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductDimensionBo.java new file mode 100644 index 000000000..3927b49c0 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductDimensionBo.java @@ -0,0 +1,77 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 产品规格尺寸范围明细业务对象 pt_product_dimension + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductDimensionBo extends BaseEntity { + + /** + * + */ + private Long dimensionId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * 维度编码THICKNESS/WIDTH/INNER_DIAMETER/COIL_WEIGHT + */ + private String dimCode; + + /** + * 维度名称 + */ + private String dimNameZh; + + /** + * 最小值 + */ + private BigDecimal minValue; + + /** + * 最大值 + */ + private BigDecimal maxValue; + + /** + * 单位mm/t/kg + */ + private String unit; + + /** + * 推荐规格逗号分隔 + */ + private String preferredValues; + + /** + * 关联公差等级 + */ + private String toleranceGradeRef; + + /** + * + */ + private Long sortOrder; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductPhysicalPropertyBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductPhysicalPropertyBo.java new file mode 100644 index 000000000..130c947c4 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductPhysicalPropertyBo.java @@ -0,0 +1,102 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 产品力学物理性能明细业务对象 pt_product_physical_property + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductPhysicalPropertyBo extends BaseEntity { + + /** + * + */ + private Long propertyId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * 性能编码YS/TS/EL/HV/R_VALUE + */ + private String propertyCode; + + /** + * + */ + private String propertyNameZh; + + /** + * + */ + private BigDecimal minValue; + + /** + * + */ + private BigDecimal maxValue; + + /** + * + */ + private BigDecimal targetValue; + + /** + * MPa / % / HV / μm + */ + private String unit; + + /** + * 检测国标 + */ + private String testStandard; + + /** + * 取样方向 + */ + private String testDirection; + + /** + * 适用厚度下限 + */ + private BigDecimal applicableThickMin; + + /** + * 适用厚度上限 + */ + private BigDecimal applicableThickMax; + + /** + * 厚度分档说明 + */ + private String applicableThickDesc; + + /** + * 1必检 0参考 + */ + private Long isMandatory; + + /** + * + */ + private Long sortOrder; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductProcessRouteBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductProcessRouteBo.java new file mode 100644 index 000000000..bf67b640b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductProcessRouteBo.java @@ -0,0 +1,67 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; + +/** + * 产品标准绑定生产工艺中间业务对象 pt_product_process_route + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductProcessRouteBo extends BaseEntity { + + /** + * + */ + private Long routeId; + + /** + * 产品标准ID + */ + private Long standardId; + + /** + * 工艺路线ID + */ + private Long processId; + + /** + * 优先级越小越优先 + */ + private Long routeSequence; + + /** + * 1该产品默认生产工艺 + */ + private Long isDefaultRoute; + + /** + * 适用条件：厚度≤1.2mm + */ + private String applicabilityRule; + + /** + * 预估成材率 + */ + private BigDecimal estimatedYield; + + /** + * 成本相对指数 + */ + private Long costIndex; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductRefStandardBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductRefStandardBo.java new file mode 100644 index 000000000..eb44a39ae --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductRefStandardBo.java @@ -0,0 +1,56 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + + +/** + * 产品引用外部标准业务对象 pt_product_ref_standard + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductRefStandardBo extends BaseEntity { + + /** + * + */ + private Long refId; + + /** + * 关联产品标准ID + */ + private Long standardId; + + /** + * GB/T 2518-2019 + */ + private String refStandardCode; + + /** + * + */ + private String refStandardName; + + /** + * GB/JIS/ASTM + */ + private String refOrganization; + + /** + * 引用章节 + */ + private String refSection; + + /** + * + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductStandardBo.java b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductStandardBo.java new file mode 100644 index 000000000..9a9672e26 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/bo/PtProductStandardBo.java @@ -0,0 +1,89 @@ +package com.klp.pt.domain.bo; + +import com.klp.common.core.domain.BaseEntity; +import lombok.Data; +import lombok.EqualsAndHashCode; +import javax.validation.constraints.*; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; + +/** + * 产品标准主业务对象 pt_product_standard + * + * @author klp + * @date 2026-07-02 + */ + +@Data +@EqualsAndHashCode(callSuper = true) +public class PtProductStandardBo extends BaseEntity { + + /** + * 产品标准主键ID + */ + private Long standardId; + + /** + * 产品标准编码(唯一) + */ + private String standardCode; + + /** + * 产品标准全称 + */ + private String standardName; + + /** + * 产品类型:CRC冷硬/冷轧,GI热镀锌,GA合金化镀锌,TFS镀铬,FHC花纹钢 + */ + private String productType; + + /** + * 钢种牌号 DC01/SPHC/Q235 + */ + private String steelGrade; + + /** + * 等效牌号逗号分隔 + */ + private String steelGradeAlias; + + /** + * 形态COIL钢卷/SHEET平板/STRIP窄带 + */ + private String productForm; + + /** + * 产品分类ID(可扩展分类表) + */ + private Long categoryId; + + /** + * 1草案 2生效 3废止 + */ + private Long status; + + /** + * 生效日期 + */ + private Date effectiveDate; + + /** + * 失效日期 + */ + private Date expireDate; + + /** + * 0否 1该牌号默认标准 + */ + private Long isDefault; + + /** + * 备注 + */ + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessQualityGateVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessQualityGateVo.java new file mode 100644 index 000000000..c990a4635 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessQualityGateVo.java @@ -0,0 +1,114 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 工艺各工序质检关口视图对象 pt_process_quality_gate + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProcessQualityGateVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long gateId; + + /** + * 关联工艺ID + */ + @ExcelProperty(value = "关联工艺ID") + private Long processId; + + /** + * 对应工序序号 + */ + @ExcelProperty(value = "对应工序序号") + private Long stepOrder; + + /** + * 质检关口名称 + */ + @ExcelProperty(value = "质检关口名称") + private String gateName; + + /** + * 在线/离线/破坏性检测 + */ + @ExcelProperty(value = "在线/离线/破坏性检测") + private String gateType; + + /** + * 检测项目 + */ + @ExcelProperty(value = "检测项目") + private String inspectionItem; + + /** + * 仪器/检测方法 + */ + @ExcelProperty(value = "仪器/检测方法") + private String measurementMethod; + + /** + * 检测频率每卷/每小时 + */ + @ExcelProperty(value = "检测频率每卷/每小时") + private String frequency; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal specMin; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal specMax; + + /** + * + */ + @ExcelProperty(value = "") + private String unit; + + /** + * 报警/降速/停机 + */ + @ExcelProperty(value = "报警/降速/停机") + private String reactionRule; + + /** + * 1不合格停机关门 + */ + @ExcelProperty(value = "1不合格停机关门") + private Long isGateStop; + + /** + * + */ + @ExcelProperty(value = "") + private Long sortOrder; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessStepParamVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessStepParamVo.java new file mode 100644 index 000000000..3df6c003d --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcessStepParamVo.java @@ -0,0 +1,120 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 工艺工序控制参数明细视图对象 pt_process_step_param + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProcessStepParamVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long paramId; + + /** + * 关联工艺ID + */ + @ExcelProperty(value = "关联工艺ID") + private Long processId; + + /** + * 工序排序 + */ + @ExcelProperty(value = "工序排序") + private Long stepOrder; + + /** + * 工序名称酸洗/冷轧/退火/镀锌 + */ + @ExcelProperty(value = "工序名称酸洗/冷轧/退火/镀锌") + private String stepName; + + /** + * 参数编码TEMP/SPEED/TENSION + */ + @ExcelProperty(value = "参数编码TEMP/SPEED/TENSION") + private String paramCode; + + /** + * + */ + @ExcelProperty(value = "") + private String paramNameZh; + + /** + * 温度/速度/压力/电流 + */ + @ExcelProperty(value = "温度/速度/压力/电流") + private String paramCategory; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal minValue; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal maxValue; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal targetValue; + + /** + * + */ + @ExcelProperty(value = "") + private String unit; + + /** + * 1关键CCP控制点 + */ + @ExcelProperty(value = "1关键CCP控制点") + private Long isCritical; + + /** + * 报警下限 + */ + @ExcelProperty(value = "报警下限") + private BigDecimal alarmMin; + + /** + * 报警上限 + */ + @ExcelProperty(value = "报警上限") + private BigDecimal alarmMax; + + /** + * + */ + @ExcelProperty(value = "") + private Long sortOrder; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcesseVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcesseVo.java new file mode 100644 index 000000000..e1e0b1784 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProcesseVo.java @@ -0,0 +1,98 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 生产工艺路线主视图对象 pt_processe + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProcesseVo { + + private static final long serialVersionUID = 1L; + + /** + * 工艺路线主键 + */ + @ExcelProperty(value = "工艺路线主键") + private Long processId; + + /** + * 工艺编码唯一 + */ + @ExcelProperty(value = "工艺编码唯一") + private String processCode; + + /** + * 工艺名称 + */ + @ExcelProperty(value = "工艺名称") + private String processName; + + /** + * 适配产品类型逗号分隔 + */ + @ExcelProperty(value = "适配产品类型逗号分隔") + private String adaptProductType; + + /** + * 所属产线ID + */ + @ExcelProperty(value = "所属产线ID") + private Long lineId; + + /** + * 1启用 0停用 + */ + @ExcelProperty(value = "1启用 0停用") + private Long status; + + /** + * + */ + @ExcelProperty(value = "") + private Date effectiveDate; + + /** + * + */ + @ExcelProperty(value = "") + private Date expireDate; + + /** + * 整体工艺流程描述 + */ + @ExcelProperty(value = "整体工艺流程描述") + private String flowOverview; + + /** + * 目标成材率% + */ + @ExcelProperty(value = "目标成材率%") + private BigDecimal targetYield; + + /** + * 标准产能t/h + */ + @ExcelProperty(value = "标准产能t/h") + private BigDecimal standardCapacity; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductApplicationVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductApplicationVo.java new file mode 100644 index 000000000..99d584e95 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductApplicationVo.java @@ -0,0 +1,77 @@ +package com.klp.pt.domain.vo; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品应用领域明细视图对象 pt_product_application + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductApplicationVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long applicationId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * AUTOMOTIVE/APPLIANCE/CONSTRUCTION + */ + @ExcelProperty(value = "AUTOMOTIVE/APPLIANCE/CONSTRUCTION") + private String industrySector; + + /** + * 汽车/家电/建筑 + */ + @ExcelProperty(value = "汽车/家电/建筑") + private String sectorNameZh; + + /** + * 使用场景 + */ + @ExcelProperty(value = "使用场景") + private String applicationDesc; + + /** + * 冲压/拉深/焊接 + */ + @ExcelProperty(value = "冲压/拉深/焊接") + private String processingMethod; + + /** + * 典型零件 + */ + @ExcelProperty(value = "典型零件") + private String typicalPart; + + /** + * 室内/户外腐蚀环境 + */ + @ExcelProperty(value = "室内/户外腐蚀环境") + private String exposureCondition; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductChemicalCompositionVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductChemicalCompositionVo.java new file mode 100644 index 000000000..cdd92d61c --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductChemicalCompositionVo.java @@ -0,0 +1,90 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品化学成分明细视图对象 pt_product_chemical_composition + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductChemicalCompositionVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long compositionId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * 元素C/Mn/Si/P/S + */ + @ExcelProperty(value = "元素C/Mn/Si/P/S") + private String elementSymbol; + + /** + * + */ + @ExcelProperty(value = "") + private String elementNameZh; + + /** + * 最小质量分数% + */ + @ExcelProperty(value = "最小质量分数%") + private BigDecimal minPercent; + + /** + * 最大质量分数% + */ + @ExcelProperty(value = "最大质量分数%") + private BigDecimal maxPercent; + + /** + * 标称值 + */ + @ExcelProperty(value = "标称值") + private BigDecimal nominalPercent; + + /** + * 熔炼/成品分析 + */ + @ExcelProperty(value = "熔炼/成品分析") + private String analysisType; + + /** + * 0普通 1关键限制元素 + */ + @ExcelProperty(value = "0普通 1关键限制元素") + private Long isKeyElement; + + /** + * + */ + @ExcelProperty(value = "") + private Long sortOrder; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductCoatingSpecVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductCoatingSpecVo.java new file mode 100644 index 000000000..adaa8a20a --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductCoatingSpecVo.java @@ -0,0 +1,108 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 镀锌/镀铬镀层规范明细视图对象 pt_product_coating_spec + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductCoatingSpecVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long coatingId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * GI/GA/TFS + */ + @ExcelProperty(value = "GI/GA/TFS") + private String coatingType; + + /** + * Z120/Z275 + */ + @ExcelProperty(value = "Z120/Z275") + private String coatingDesignation; + + /** + * 双面镀层下限g/m² + */ + @ExcelProperty(value = "双面镀层下限g/m²") + private BigDecimal coatingWeightMin; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal coatingWeightMax; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal coatingWeightTarget; + + /** + * 单点镀层重量 + */ + @ExcelProperty(value = "单点镀层重量") + private BigDecimal singleSpotMin; + + /** + * 有无锌花 + */ + @ExcelProperty(value = "有无锌花") + private String surfaceFinish; + + /** + * 钝化/涂油 + */ + @ExcelProperty(value = "钝化/涂油") + private String surfaceTreatment; + + /** + * 弯曲试验0t/1t + */ + @ExcelProperty(value = "弯曲试验0t/1t") + private String bendTestMandrel; + + /** + * 白锈小时 + */ + @ExcelProperty(value = "白锈小时") + private Long saltSprayHoursWhite; + + /** + * 红锈小时 + */ + @ExcelProperty(value = "红锈小时") + private Long saltSprayHoursRed; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductDimensionVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductDimensionVo.java new file mode 100644 index 000000000..dc0a52be8 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductDimensionVo.java @@ -0,0 +1,90 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品规格尺寸范围明细视图对象 pt_product_dimension + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductDimensionVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long dimensionId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * 维度编码THICKNESS/WIDTH/INNER_DIAMETER/COIL_WEIGHT + */ + @ExcelProperty(value = "维度编码THICKNESS/WIDTH/INNER_DIAMETER/COIL_WEIGHT") + private String dimCode; + + /** + * 维度名称 + */ + @ExcelProperty(value = "维度名称") + private String dimNameZh; + + /** + * 最小值 + */ + @ExcelProperty(value = "最小值") + private BigDecimal minValue; + + /** + * 最大值 + */ + @ExcelProperty(value = "最大值") + private BigDecimal maxValue; + + /** + * 单位mm/t/kg + */ + @ExcelProperty(value = "单位mm/t/kg") + private String unit; + + /** + * 推荐规格逗号分隔 + */ + @ExcelProperty(value = "推荐规格逗号分隔") + private String preferredValues; + + /** + * 关联公差等级 + */ + @ExcelProperty(value = "关联公差等级") + private String toleranceGradeRef; + + /** + * + */ + @ExcelProperty(value = "") + private Long sortOrder; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductPhysicalPropertyVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductPhysicalPropertyVo.java new file mode 100644 index 000000000..a95373d20 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductPhysicalPropertyVo.java @@ -0,0 +1,120 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品力学物理性能明细视图对象 pt_product_physical_property + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductPhysicalPropertyVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long propertyId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * 性能编码YS/TS/EL/HV/R_VALUE + */ + @ExcelProperty(value = "性能编码YS/TS/EL/HV/R_VALUE") + private String propertyCode; + + /** + * + */ + @ExcelProperty(value = "") + private String propertyNameZh; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal minValue; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal maxValue; + + /** + * + */ + @ExcelProperty(value = "") + private BigDecimal targetValue; + + /** + * MPa / % / HV / μm + */ + @ExcelProperty(value = "MPa / % / HV / μm") + private String unit; + + /** + * 检测国标 + */ + @ExcelProperty(value = "检测国标") + private String testStandard; + + /** + * 取样方向 + */ + @ExcelProperty(value = "取样方向") + private String testDirection; + + /** + * 适用厚度下限 + */ + @ExcelProperty(value = "适用厚度下限") + private BigDecimal applicableThickMin; + + /** + * 适用厚度上限 + */ + @ExcelProperty(value = "适用厚度上限") + private BigDecimal applicableThickMax; + + /** + * 厚度分档说明 + */ + @ExcelProperty(value = "厚度分档说明") + private String applicableThickDesc; + + /** + * 1必检 0参考 + */ + @ExcelProperty(value = "1必检 0参考") + private Long isMandatory; + + /** + * + */ + @ExcelProperty(value = "") + private Long sortOrder; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductProcessRouteVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductProcessRouteVo.java new file mode 100644 index 000000000..f52f41f02 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductProcessRouteVo.java @@ -0,0 +1,78 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品标准绑定生产工艺中间视图对象 pt_product_process_route + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductProcessRouteVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long routeId; + + /** + * 产品标准ID + */ + @ExcelProperty(value = "产品标准ID") + private Long standardId; + + /** + * 工艺路线ID + */ + @ExcelProperty(value = "工艺路线ID") + private Long processId; + + /** + * 优先级越小越优先 + */ + @ExcelProperty(value = "优先级越小越优先") + private Long routeSequence; + + /** + * 1该产品默认生产工艺 + */ + @ExcelProperty(value = "1该产品默认生产工艺") + private Long isDefaultRoute; + + /** + * 适用条件：厚度≤1.2mm + */ + @ExcelProperty(value = "适用条件：厚度≤1.2mm") + private String applicabilityRule; + + /** + * 预估成材率 + */ + @ExcelProperty(value = "预估成材率") + private BigDecimal estimatedYield; + + /** + * 成本相对指数 + */ + @ExcelProperty(value = "成本相对指数") + private Long costIndex; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductRefStandardVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductRefStandardVo.java new file mode 100644 index 000000000..ebf61e2bb --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductRefStandardVo.java @@ -0,0 +1,65 @@ +package com.klp.pt.domain.vo; + +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品引用外部标准视图对象 pt_product_ref_standard + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductRefStandardVo { + + private static final long serialVersionUID = 1L; + + /** + * + */ + @ExcelProperty(value = "") + private Long refId; + + /** + * 关联产品标准ID + */ + @ExcelProperty(value = "关联产品标准ID") + private Long standardId; + + /** + * GB/T 2518-2019 + */ + @ExcelProperty(value = "GB/T 2518-2019") + private String refStandardCode; + + /** + * + */ + @ExcelProperty(value = "") + private String refStandardName; + + /** + * GB/JIS/ASTM + */ + @ExcelProperty(value = "GB/JIS/ASTM") + private String refOrganization; + + /** + * 引用章节 + */ + @ExcelProperty(value = "引用章节") + private String refSection; + + /** + * + */ + @ExcelProperty(value = "") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductStandardVo.java b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductStandardVo.java new file mode 100644 index 000000000..c7d553229 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/domain/vo/PtProductStandardVo.java @@ -0,0 +1,104 @@ +package com.klp.pt.domain.vo; + +import java.math.BigDecimal; +import java.util.Date; +import com.fasterxml.jackson.annotation.JsonFormat; +import com.alibaba.excel.annotation.ExcelIgnoreUnannotated; +import com.alibaba.excel.annotation.ExcelProperty; +import com.klp.common.annotation.ExcelDictFormat; +import com.klp.common.convert.ExcelDictConvert; +import lombok.Data; + + +/** + * 产品标准主视图对象 pt_product_standard + * + * @author klp + * @date 2026-07-02 + */ +@Data +@ExcelIgnoreUnannotated +public class PtProductStandardVo { + + private static final long serialVersionUID = 1L; + + /** + * 产品标准主键ID + */ + @ExcelProperty(value = "产品标准主键ID") + private Long standardId; + + /** + * 产品标准编码(唯一) + */ + @ExcelProperty(value = "产品标准编码(唯一)") + private String standardCode; + + /** + * 产品标准全称 + */ + @ExcelProperty(value = "产品标准全称") + private String standardName; + + /** + * 产品类型:CRC冷硬/冷轧,GI热镀锌,GA合金化镀锌,TFS镀铬,FHC花纹钢 + */ + @ExcelProperty(value = "产品类型:CRC冷硬/冷轧,GI热镀锌,GA合金化镀锌,TFS镀铬,FHC花纹钢") + private String productType; + + /** + * 钢种牌号 DC01/SPHC/Q235 + */ + @ExcelProperty(value = "钢种牌号 DC01/SPHC/Q235") + private String steelGrade; + + /** + * 等效牌号逗号分隔 + */ + @ExcelProperty(value = "等效牌号逗号分隔") + private String steelGradeAlias; + + /** + * 形态COIL钢卷/SHEET平板/STRIP窄带 + */ + @ExcelProperty(value = "形态COIL钢卷/SHEET平板/STRIP窄带") + private String productForm; + + /** + * 产品分类ID(可扩展分类表) + */ + @ExcelProperty(value = "产品分类ID(可扩展分类表)") + private Long categoryId; + + /** + * 1草案 2生效 3废止 + */ + @ExcelProperty(value = "1草案 2生效 3废止") + private Long status; + + /** + * 生效日期 + */ + @ExcelProperty(value = "生效日期") + private Date effectiveDate; + + /** + * 失效日期 + */ + @ExcelProperty(value = "失效日期") + private Date expireDate; + + /** + * 0否 1该牌号默认标准 + */ + @ExcelProperty(value = "0否 1该牌号默认标准") + private Long isDefault; + + /** + * 备注 + */ + @ExcelProperty(value = "备注") + private String remark; + + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessQualityGateMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessQualityGateMapper.java new file mode 100644 index 000000000..3d44ddac6 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessQualityGateMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProcessQualityGate; +import com.klp.pt.domain.vo.PtProcessQualityGateVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 工艺各工序质检关口Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProcessQualityGateMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessStepParamMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessStepParamMapper.java new file mode 100644 index 000000000..ee2cc13bb --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcessStepParamMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProcessStepParam; +import com.klp.pt.domain.vo.PtProcessStepParamVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 工艺工序控制参数明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProcessStepParamMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProcesseMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcesseMapper.java new file mode 100644 index 000000000..ec1fc0137 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProcesseMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProcesse; +import com.klp.pt.domain.vo.PtProcesseVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 生产工艺路线主Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProcesseMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductApplicationMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductApplicationMapper.java new file mode 100644 index 000000000..8c9b013ee --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductApplicationMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductApplication; +import com.klp.pt.domain.vo.PtProductApplicationVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品应用领域明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductApplicationMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductChemicalCompositionMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductChemicalCompositionMapper.java new file mode 100644 index 000000000..bb2f56ddf --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductChemicalCompositionMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductChemicalComposition; +import com.klp.pt.domain.vo.PtProductChemicalCompositionVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品化学成分明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductChemicalCompositionMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductCoatingSpecMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductCoatingSpecMapper.java new file mode 100644 index 000000000..11d6aa2b6 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductCoatingSpecMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductCoatingSpec; +import com.klp.pt.domain.vo.PtProductCoatingSpecVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 镀锌/镀铬镀层规范明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductCoatingSpecMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductDimensionMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductDimensionMapper.java new file mode 100644 index 000000000..04718547f --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductDimensionMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductDimension; +import com.klp.pt.domain.vo.PtProductDimensionVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品规格尺寸范围明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductDimensionMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductPhysicalPropertyMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductPhysicalPropertyMapper.java new file mode 100644 index 000000000..249212d85 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductPhysicalPropertyMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductPhysicalProperty; +import com.klp.pt.domain.vo.PtProductPhysicalPropertyVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品力学物理性能明细Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductPhysicalPropertyMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductProcessRouteMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductProcessRouteMapper.java new file mode 100644 index 000000000..bb4880394 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductProcessRouteMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductProcessRoute; +import com.klp.pt.domain.vo.PtProductProcessRouteVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品标准绑定生产工艺中间Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductProcessRouteMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductRefStandardMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductRefStandardMapper.java new file mode 100644 index 000000000..5b10a342d --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductRefStandardMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductRefStandard; +import com.klp.pt.domain.vo.PtProductRefStandardVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品引用外部标准Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductRefStandardMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/mapper/PtProductStandardMapper.java b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductStandardMapper.java new file mode 100644 index 000000000..eef871c50 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/mapper/PtProductStandardMapper.java @@ -0,0 +1,15 @@ +package com.klp.pt.mapper; + +import com.klp.pt.domain.PtProductStandard; +import com.klp.pt.domain.vo.PtProductStandardVo; +import com.klp.common.core.mapper.BaseMapperPlus; + +/** + * 产品标准主Mapper接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface PtProductStandardMapper extends BaseMapperPlus { + +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProcessQualityGateService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProcessQualityGateService.java new file mode 100644 index 000000000..d45e99fc3 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProcessQualityGateService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProcessQualityGate; +import com.klp.pt.domain.vo.PtProcessQualityGateVo; +import com.klp.pt.domain.bo.PtProcessQualityGateBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 工艺各工序质检关口Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProcessQualityGateService { + + /** + * 查询工艺各工序质检关口 + */ + PtProcessQualityGateVo queryById(Long gateId); + + /** + * 查询工艺各工序质检关口列表 + */ + TableDataInfo queryPageList(PtProcessQualityGateBo bo, PageQuery pageQuery); + + /** + * 查询工艺各工序质检关口列表 + */ + List queryList(PtProcessQualityGateBo bo); + + /** + * 新增工艺各工序质检关口 + */ + Boolean insertByBo(PtProcessQualityGateBo bo); + + /** + * 修改工艺各工序质检关口 + */ + Boolean updateByBo(PtProcessQualityGateBo bo); + + /** + * 校验并批量删除工艺各工序质检关口信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProcessStepParamService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProcessStepParamService.java new file mode 100644 index 000000000..38517d108 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProcessStepParamService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProcessStepParam; +import com.klp.pt.domain.vo.PtProcessStepParamVo; +import com.klp.pt.domain.bo.PtProcessStepParamBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 工艺工序控制参数明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProcessStepParamService { + + /** + * 查询工艺工序控制参数明细 + */ + PtProcessStepParamVo queryById(Long paramId); + + /** + * 查询工艺工序控制参数明细列表 + */ + TableDataInfo queryPageList(PtProcessStepParamBo bo, PageQuery pageQuery); + + /** + * 查询工艺工序控制参数明细列表 + */ + List queryList(PtProcessStepParamBo bo); + + /** + * 新增工艺工序控制参数明细 + */ + Boolean insertByBo(PtProcessStepParamBo bo); + + /** + * 修改工艺工序控制参数明细 + */ + Boolean updateByBo(PtProcessStepParamBo bo); + + /** + * 校验并批量删除工艺工序控制参数明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProcesseService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProcesseService.java new file mode 100644 index 000000000..cf7ae1287 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProcesseService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProcesse; +import com.klp.pt.domain.vo.PtProcesseVo; +import com.klp.pt.domain.bo.PtProcesseBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 生产工艺路线主Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProcesseService { + + /** + * 查询生产工艺路线主 + */ + PtProcesseVo queryById(Long processId); + + /** + * 查询生产工艺路线主列表 + */ + TableDataInfo queryPageList(PtProcesseBo bo, PageQuery pageQuery); + + /** + * 查询生产工艺路线主列表 + */ + List queryList(PtProcesseBo bo); + + /** + * 新增生产工艺路线主 + */ + Boolean insertByBo(PtProcesseBo bo); + + /** + * 修改生产工艺路线主 + */ + Boolean updateByBo(PtProcesseBo bo); + + /** + * 校验并批量删除生产工艺路线主信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductApplicationService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductApplicationService.java new file mode 100644 index 000000000..0c733d96b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductApplicationService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductApplication; +import com.klp.pt.domain.vo.PtProductApplicationVo; +import com.klp.pt.domain.bo.PtProductApplicationBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品应用领域明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductApplicationService { + + /** + * 查询产品应用领域明细 + */ + PtProductApplicationVo queryById(Long applicationId); + + /** + * 查询产品应用领域明细列表 + */ + TableDataInfo queryPageList(PtProductApplicationBo bo, PageQuery pageQuery); + + /** + * 查询产品应用领域明细列表 + */ + List queryList(PtProductApplicationBo bo); + + /** + * 新增产品应用领域明细 + */ + Boolean insertByBo(PtProductApplicationBo bo); + + /** + * 修改产品应用领域明细 + */ + Boolean updateByBo(PtProductApplicationBo bo); + + /** + * 校验并批量删除产品应用领域明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductChemicalCompositionService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductChemicalCompositionService.java new file mode 100644 index 000000000..8fe74dcca --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductChemicalCompositionService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductChemicalComposition; +import com.klp.pt.domain.vo.PtProductChemicalCompositionVo; +import com.klp.pt.domain.bo.PtProductChemicalCompositionBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品化学成分明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductChemicalCompositionService { + + /** + * 查询产品化学成分明细 + */ + PtProductChemicalCompositionVo queryById(Long compositionId); + + /** + * 查询产品化学成分明细列表 + */ + TableDataInfo queryPageList(PtProductChemicalCompositionBo bo, PageQuery pageQuery); + + /** + * 查询产品化学成分明细列表 + */ + List queryList(PtProductChemicalCompositionBo bo); + + /** + * 新增产品化学成分明细 + */ + Boolean insertByBo(PtProductChemicalCompositionBo bo); + + /** + * 修改产品化学成分明细 + */ + Boolean updateByBo(PtProductChemicalCompositionBo bo); + + /** + * 校验并批量删除产品化学成分明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductCoatingSpecService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductCoatingSpecService.java new file mode 100644 index 000000000..e71d87bf6 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductCoatingSpecService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductCoatingSpec; +import com.klp.pt.domain.vo.PtProductCoatingSpecVo; +import com.klp.pt.domain.bo.PtProductCoatingSpecBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 镀锌/镀铬镀层规范明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductCoatingSpecService { + + /** + * 查询镀锌/镀铬镀层规范明细 + */ + PtProductCoatingSpecVo queryById(Long coatingId); + + /** + * 查询镀锌/镀铬镀层规范明细列表 + */ + TableDataInfo queryPageList(PtProductCoatingSpecBo bo, PageQuery pageQuery); + + /** + * 查询镀锌/镀铬镀层规范明细列表 + */ + List queryList(PtProductCoatingSpecBo bo); + + /** + * 新增镀锌/镀铬镀层规范明细 + */ + Boolean insertByBo(PtProductCoatingSpecBo bo); + + /** + * 修改镀锌/镀铬镀层规范明细 + */ + Boolean updateByBo(PtProductCoatingSpecBo bo); + + /** + * 校验并批量删除镀锌/镀铬镀层规范明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductDimensionService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductDimensionService.java new file mode 100644 index 000000000..941643004 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductDimensionService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductDimension; +import com.klp.pt.domain.vo.PtProductDimensionVo; +import com.klp.pt.domain.bo.PtProductDimensionBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品规格尺寸范围明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductDimensionService { + + /** + * 查询产品规格尺寸范围明细 + */ + PtProductDimensionVo queryById(Long dimensionId); + + /** + * 查询产品规格尺寸范围明细列表 + */ + TableDataInfo queryPageList(PtProductDimensionBo bo, PageQuery pageQuery); + + /** + * 查询产品规格尺寸范围明细列表 + */ + List queryList(PtProductDimensionBo bo); + + /** + * 新增产品规格尺寸范围明细 + */ + Boolean insertByBo(PtProductDimensionBo bo); + + /** + * 修改产品规格尺寸范围明细 + */ + Boolean updateByBo(PtProductDimensionBo bo); + + /** + * 校验并批量删除产品规格尺寸范围明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductPhysicalPropertyService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductPhysicalPropertyService.java new file mode 100644 index 000000000..8e6c59281 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductPhysicalPropertyService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductPhysicalProperty; +import com.klp.pt.domain.vo.PtProductPhysicalPropertyVo; +import com.klp.pt.domain.bo.PtProductPhysicalPropertyBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品力学物理性能明细Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductPhysicalPropertyService { + + /** + * 查询产品力学物理性能明细 + */ + PtProductPhysicalPropertyVo queryById(Long propertyId); + + /** + * 查询产品力学物理性能明细列表 + */ + TableDataInfo queryPageList(PtProductPhysicalPropertyBo bo, PageQuery pageQuery); + + /** + * 查询产品力学物理性能明细列表 + */ + List queryList(PtProductPhysicalPropertyBo bo); + + /** + * 新增产品力学物理性能明细 + */ + Boolean insertByBo(PtProductPhysicalPropertyBo bo); + + /** + * 修改产品力学物理性能明细 + */ + Boolean updateByBo(PtProductPhysicalPropertyBo bo); + + /** + * 校验并批量删除产品力学物理性能明细信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductProcessRouteService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductProcessRouteService.java new file mode 100644 index 000000000..891cc4dc2 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductProcessRouteService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductProcessRoute; +import com.klp.pt.domain.vo.PtProductProcessRouteVo; +import com.klp.pt.domain.bo.PtProductProcessRouteBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品标准绑定生产工艺中间Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductProcessRouteService { + + /** + * 查询产品标准绑定生产工艺中间 + */ + PtProductProcessRouteVo queryById(Long routeId); + + /** + * 查询产品标准绑定生产工艺中间列表 + */ + TableDataInfo queryPageList(PtProductProcessRouteBo bo, PageQuery pageQuery); + + /** + * 查询产品标准绑定生产工艺中间列表 + */ + List queryList(PtProductProcessRouteBo bo); + + /** + * 新增产品标准绑定生产工艺中间 + */ + Boolean insertByBo(PtProductProcessRouteBo bo); + + /** + * 修改产品标准绑定生产工艺中间 + */ + Boolean updateByBo(PtProductProcessRouteBo bo); + + /** + * 校验并批量删除产品标准绑定生产工艺中间信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductRefStandardService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductRefStandardService.java new file mode 100644 index 000000000..0d260da2b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductRefStandardService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductRefStandard; +import com.klp.pt.domain.vo.PtProductRefStandardVo; +import com.klp.pt.domain.bo.PtProductRefStandardBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品引用外部标准Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductRefStandardService { + + /** + * 查询产品引用外部标准 + */ + PtProductRefStandardVo queryById(Long refId); + + /** + * 查询产品引用外部标准列表 + */ + TableDataInfo queryPageList(PtProductRefStandardBo bo, PageQuery pageQuery); + + /** + * 查询产品引用外部标准列表 + */ + List queryList(PtProductRefStandardBo bo); + + /** + * 新增产品引用外部标准 + */ + Boolean insertByBo(PtProductRefStandardBo bo); + + /** + * 修改产品引用外部标准 + */ + Boolean updateByBo(PtProductRefStandardBo bo); + + /** + * 校验并批量删除产品引用外部标准信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/IPtProductStandardService.java b/klp-pt/src/main/java/com/klp/pt/service/IPtProductStandardService.java new file mode 100644 index 000000000..19ca5ec30 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/IPtProductStandardService.java @@ -0,0 +1,49 @@ +package com.klp.pt.service; + +import com.klp.pt.domain.PtProductStandard; +import com.klp.pt.domain.vo.PtProductStandardVo; +import com.klp.pt.domain.bo.PtProductStandardBo; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; + +import java.util.Collection; +import java.util.List; + +/** + * 产品标准主Service接口 + * + * @author klp + * @date 2026-07-02 + */ +public interface IPtProductStandardService { + + /** + * 查询产品标准主 + */ + PtProductStandardVo queryById(Long standardId); + + /** + * 查询产品标准主列表 + */ + TableDataInfo queryPageList(PtProductStandardBo bo, PageQuery pageQuery); + + /** + * 查询产品标准主列表 + */ + List queryList(PtProductStandardBo bo); + + /** + * 新增产品标准主 + */ + Boolean insertByBo(PtProductStandardBo bo); + + /** + * 修改产品标准主 + */ + Boolean updateByBo(PtProductStandardBo bo); + + /** + * 校验并批量删除产品标准主信息 + */ + Boolean deleteWithValidByIds(Collection ids, Boolean isValid); +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessQualityGateServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessQualityGateServiceImpl.java new file mode 100644 index 000000000..f9d539354 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessQualityGateServiceImpl.java @@ -0,0 +1,121 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProcessQualityGateBo; +import com.klp.pt.domain.vo.PtProcessQualityGateVo; +import com.klp.pt.domain.PtProcessQualityGate; +import com.klp.pt.mapper.PtProcessQualityGateMapper; +import com.klp.pt.service.IPtProcessQualityGateService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 工艺各工序质检关口Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProcessQualityGateServiceImpl implements IPtProcessQualityGateService { + + private final PtProcessQualityGateMapper baseMapper; + + /** + * 查询工艺各工序质检关口 + */ + @Override + public PtProcessQualityGateVo queryById(Long gateId){ + return baseMapper.selectVoById(gateId); + } + + /** + * 查询工艺各工序质检关口列表 + */ + @Override + public TableDataInfo queryPageList(PtProcessQualityGateBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询工艺各工序质检关口列表 + */ + @Override + public List queryList(PtProcessQualityGateBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProcessQualityGateBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getProcessId() != null, PtProcessQualityGate::getProcessId, bo.getProcessId()); + lqw.eq(bo.getStepOrder() != null, PtProcessQualityGate::getStepOrder, bo.getStepOrder()); + lqw.like(StringUtils.isNotBlank(bo.getGateName()), PtProcessQualityGate::getGateName, bo.getGateName()); + lqw.eq(StringUtils.isNotBlank(bo.getGateType()), PtProcessQualityGate::getGateType, bo.getGateType()); + lqw.eq(StringUtils.isNotBlank(bo.getInspectionItem()), PtProcessQualityGate::getInspectionItem, bo.getInspectionItem()); + lqw.eq(StringUtils.isNotBlank(bo.getMeasurementMethod()), PtProcessQualityGate::getMeasurementMethod, bo.getMeasurementMethod()); + lqw.eq(StringUtils.isNotBlank(bo.getFrequency()), PtProcessQualityGate::getFrequency, bo.getFrequency()); + lqw.eq(bo.getSpecMin() != null, PtProcessQualityGate::getSpecMin, bo.getSpecMin()); + lqw.eq(bo.getSpecMax() != null, PtProcessQualityGate::getSpecMax, bo.getSpecMax()); + lqw.eq(StringUtils.isNotBlank(bo.getUnit()), PtProcessQualityGate::getUnit, bo.getUnit()); + lqw.eq(StringUtils.isNotBlank(bo.getReactionRule()), PtProcessQualityGate::getReactionRule, bo.getReactionRule()); + lqw.eq(bo.getIsGateStop() != null, PtProcessQualityGate::getIsGateStop, bo.getIsGateStop()); + lqw.eq(bo.getSortOrder() != null, PtProcessQualityGate::getSortOrder, bo.getSortOrder()); + return lqw; + } + + /** + * 新增工艺各工序质检关口 + */ + @Override + public Boolean insertByBo(PtProcessQualityGateBo bo) { + PtProcessQualityGate add = BeanUtil.toBean(bo, PtProcessQualityGate.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setGateId(add.getGateId()); + } + return flag; + } + + /** + * 修改工艺各工序质检关口 + */ + @Override + public Boolean updateByBo(PtProcessQualityGateBo bo) { + PtProcessQualityGate update = BeanUtil.toBean(bo, PtProcessQualityGate.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProcessQualityGate entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除工艺各工序质检关口 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessStepParamServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessStepParamServiceImpl.java new file mode 100644 index 000000000..9cb0f9e2d --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcessStepParamServiceImpl.java @@ -0,0 +1,122 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProcessStepParamBo; +import com.klp.pt.domain.vo.PtProcessStepParamVo; +import com.klp.pt.domain.PtProcessStepParam; +import com.klp.pt.mapper.PtProcessStepParamMapper; +import com.klp.pt.service.IPtProcessStepParamService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 工艺工序控制参数明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProcessStepParamServiceImpl implements IPtProcessStepParamService { + + private final PtProcessStepParamMapper baseMapper; + + /** + * 查询工艺工序控制参数明细 + */ + @Override + public PtProcessStepParamVo queryById(Long paramId){ + return baseMapper.selectVoById(paramId); + } + + /** + * 查询工艺工序控制参数明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProcessStepParamBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询工艺工序控制参数明细列表 + */ + @Override + public List queryList(PtProcessStepParamBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProcessStepParamBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getProcessId() != null, PtProcessStepParam::getProcessId, bo.getProcessId()); + lqw.eq(bo.getStepOrder() != null, PtProcessStepParam::getStepOrder, bo.getStepOrder()); + lqw.like(StringUtils.isNotBlank(bo.getStepName()), PtProcessStepParam::getStepName, bo.getStepName()); + lqw.eq(StringUtils.isNotBlank(bo.getParamCode()), PtProcessStepParam::getParamCode, bo.getParamCode()); + lqw.eq(StringUtils.isNotBlank(bo.getParamNameZh()), PtProcessStepParam::getParamNameZh, bo.getParamNameZh()); + lqw.eq(StringUtils.isNotBlank(bo.getParamCategory()), PtProcessStepParam::getParamCategory, bo.getParamCategory()); + lqw.eq(bo.getMinValue() != null, PtProcessStepParam::getMinValue, bo.getMinValue()); + lqw.eq(bo.getMaxValue() != null, PtProcessStepParam::getMaxValue, bo.getMaxValue()); + lqw.eq(bo.getTargetValue() != null, PtProcessStepParam::getTargetValue, bo.getTargetValue()); + lqw.eq(StringUtils.isNotBlank(bo.getUnit()), PtProcessStepParam::getUnit, bo.getUnit()); + lqw.eq(bo.getIsCritical() != null, PtProcessStepParam::getIsCritical, bo.getIsCritical()); + lqw.eq(bo.getAlarmMin() != null, PtProcessStepParam::getAlarmMin, bo.getAlarmMin()); + lqw.eq(bo.getAlarmMax() != null, PtProcessStepParam::getAlarmMax, bo.getAlarmMax()); + lqw.eq(bo.getSortOrder() != null, PtProcessStepParam::getSortOrder, bo.getSortOrder()); + return lqw; + } + + /** + * 新增工艺工序控制参数明细 + */ + @Override + public Boolean insertByBo(PtProcessStepParamBo bo) { + PtProcessStepParam add = BeanUtil.toBean(bo, PtProcessStepParam.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setParamId(add.getParamId()); + } + return flag; + } + + /** + * 修改工艺工序控制参数明细 + */ + @Override + public Boolean updateByBo(PtProcessStepParamBo bo) { + PtProcessStepParam update = BeanUtil.toBean(bo, PtProcessStepParam.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProcessStepParam entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除工艺工序控制参数明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcesseServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcesseServiceImpl.java new file mode 100644 index 000000000..323400bcd --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProcesseServiceImpl.java @@ -0,0 +1,118 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProcesseBo; +import com.klp.pt.domain.vo.PtProcesseVo; +import com.klp.pt.domain.PtProcesse; +import com.klp.pt.mapper.PtProcesseMapper; +import com.klp.pt.service.IPtProcesseService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 生产工艺路线主Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProcesseServiceImpl implements IPtProcesseService { + + private final PtProcesseMapper baseMapper; + + /** + * 查询生产工艺路线主 + */ + @Override + public PtProcesseVo queryById(Long processId){ + return baseMapper.selectVoById(processId); + } + + /** + * 查询生产工艺路线主列表 + */ + @Override + public TableDataInfo queryPageList(PtProcesseBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询生产工艺路线主列表 + */ + @Override + public List queryList(PtProcesseBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProcesseBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(StringUtils.isNotBlank(bo.getProcessCode()), PtProcesse::getProcessCode, bo.getProcessCode()); + lqw.like(StringUtils.isNotBlank(bo.getProcessName()), PtProcesse::getProcessName, bo.getProcessName()); + lqw.eq(StringUtils.isNotBlank(bo.getAdaptProductType()), PtProcesse::getAdaptProductType, bo.getAdaptProductType()); + lqw.eq(bo.getLineId() != null, PtProcesse::getLineId, bo.getLineId()); + lqw.eq(bo.getStatus() != null, PtProcesse::getStatus, bo.getStatus()); + lqw.eq(bo.getEffectiveDate() != null, PtProcesse::getEffectiveDate, bo.getEffectiveDate()); + lqw.eq(bo.getExpireDate() != null, PtProcesse::getExpireDate, bo.getExpireDate()); + lqw.eq(StringUtils.isNotBlank(bo.getFlowOverview()), PtProcesse::getFlowOverview, bo.getFlowOverview()); + lqw.eq(bo.getTargetYield() != null, PtProcesse::getTargetYield, bo.getTargetYield()); + lqw.eq(bo.getStandardCapacity() != null, PtProcesse::getStandardCapacity, bo.getStandardCapacity()); + return lqw; + } + + /** + * 新增生产工艺路线主 + */ + @Override + public Boolean insertByBo(PtProcesseBo bo) { + PtProcesse add = BeanUtil.toBean(bo, PtProcesse.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setProcessId(add.getProcessId()); + } + return flag; + } + + /** + * 修改生产工艺路线主 + */ + @Override + public Boolean updateByBo(PtProcesseBo bo) { + PtProcesse update = BeanUtil.toBean(bo, PtProcesse.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProcesse entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除生产工艺路线主 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductApplicationServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductApplicationServiceImpl.java new file mode 100644 index 000000000..b919f4c04 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductApplicationServiceImpl.java @@ -0,0 +1,115 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductApplicationBo; +import com.klp.pt.domain.vo.PtProductApplicationVo; +import com.klp.pt.domain.PtProductApplication; +import com.klp.pt.mapper.PtProductApplicationMapper; +import com.klp.pt.service.IPtProductApplicationService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品应用领域明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductApplicationServiceImpl implements IPtProductApplicationService { + + private final PtProductApplicationMapper baseMapper; + + /** + * 查询产品应用领域明细 + */ + @Override + public PtProductApplicationVo queryById(Long applicationId){ + return baseMapper.selectVoById(applicationId); + } + + /** + * 查询产品应用领域明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProductApplicationBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品应用领域明细列表 + */ + @Override + public List queryList(PtProductApplicationBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductApplicationBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductApplication::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getIndustrySector()), PtProductApplication::getIndustrySector, bo.getIndustrySector()); + lqw.eq(StringUtils.isNotBlank(bo.getSectorNameZh()), PtProductApplication::getSectorNameZh, bo.getSectorNameZh()); + lqw.eq(StringUtils.isNotBlank(bo.getApplicationDesc()), PtProductApplication::getApplicationDesc, bo.getApplicationDesc()); + lqw.eq(StringUtils.isNotBlank(bo.getProcessingMethod()), PtProductApplication::getProcessingMethod, bo.getProcessingMethod()); + lqw.eq(StringUtils.isNotBlank(bo.getTypicalPart()), PtProductApplication::getTypicalPart, bo.getTypicalPart()); + lqw.eq(StringUtils.isNotBlank(bo.getExposureCondition()), PtProductApplication::getExposureCondition, bo.getExposureCondition()); + return lqw; + } + + /** + * 新增产品应用领域明细 + */ + @Override + public Boolean insertByBo(PtProductApplicationBo bo) { + PtProductApplication add = BeanUtil.toBean(bo, PtProductApplication.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setApplicationId(add.getApplicationId()); + } + return flag; + } + + /** + * 修改产品应用领域明细 + */ + @Override + public Boolean updateByBo(PtProductApplicationBo bo) { + PtProductApplication update = BeanUtil.toBean(bo, PtProductApplication.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductApplication entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品应用领域明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductChemicalCompositionServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductChemicalCompositionServiceImpl.java new file mode 100644 index 000000000..5ea547a1b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductChemicalCompositionServiceImpl.java @@ -0,0 +1,117 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductChemicalCompositionBo; +import com.klp.pt.domain.vo.PtProductChemicalCompositionVo; +import com.klp.pt.domain.PtProductChemicalComposition; +import com.klp.pt.mapper.PtProductChemicalCompositionMapper; +import com.klp.pt.service.IPtProductChemicalCompositionService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品化学成分明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductChemicalCompositionServiceImpl implements IPtProductChemicalCompositionService { + + private final PtProductChemicalCompositionMapper baseMapper; + + /** + * 查询产品化学成分明细 + */ + @Override + public PtProductChemicalCompositionVo queryById(Long compositionId){ + return baseMapper.selectVoById(compositionId); + } + + /** + * 查询产品化学成分明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProductChemicalCompositionBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品化学成分明细列表 + */ + @Override + public List queryList(PtProductChemicalCompositionBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductChemicalCompositionBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductChemicalComposition::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getElementSymbol()), PtProductChemicalComposition::getElementSymbol, bo.getElementSymbol()); + lqw.eq(StringUtils.isNotBlank(bo.getElementNameZh()), PtProductChemicalComposition::getElementNameZh, bo.getElementNameZh()); + lqw.eq(bo.getMinPercent() != null, PtProductChemicalComposition::getMinPercent, bo.getMinPercent()); + lqw.eq(bo.getMaxPercent() != null, PtProductChemicalComposition::getMaxPercent, bo.getMaxPercent()); + lqw.eq(bo.getNominalPercent() != null, PtProductChemicalComposition::getNominalPercent, bo.getNominalPercent()); + lqw.eq(StringUtils.isNotBlank(bo.getAnalysisType()), PtProductChemicalComposition::getAnalysisType, bo.getAnalysisType()); + lqw.eq(bo.getIsKeyElement() != null, PtProductChemicalComposition::getIsKeyElement, bo.getIsKeyElement()); + lqw.eq(bo.getSortOrder() != null, PtProductChemicalComposition::getSortOrder, bo.getSortOrder()); + return lqw; + } + + /** + * 新增产品化学成分明细 + */ + @Override + public Boolean insertByBo(PtProductChemicalCompositionBo bo) { + PtProductChemicalComposition add = BeanUtil.toBean(bo, PtProductChemicalComposition.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setCompositionId(add.getCompositionId()); + } + return flag; + } + + /** + * 修改产品化学成分明细 + */ + @Override + public Boolean updateByBo(PtProductChemicalCompositionBo bo) { + PtProductChemicalComposition update = BeanUtil.toBean(bo, PtProductChemicalComposition.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductChemicalComposition entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品化学成分明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductCoatingSpecServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductCoatingSpecServiceImpl.java new file mode 100644 index 000000000..c293b0079 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductCoatingSpecServiceImpl.java @@ -0,0 +1,120 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductCoatingSpecBo; +import com.klp.pt.domain.vo.PtProductCoatingSpecVo; +import com.klp.pt.domain.PtProductCoatingSpec; +import com.klp.pt.mapper.PtProductCoatingSpecMapper; +import com.klp.pt.service.IPtProductCoatingSpecService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 镀锌/镀铬镀层规范明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductCoatingSpecServiceImpl implements IPtProductCoatingSpecService { + + private final PtProductCoatingSpecMapper baseMapper; + + /** + * 查询镀锌/镀铬镀层规范明细 + */ + @Override + public PtProductCoatingSpecVo queryById(Long coatingId){ + return baseMapper.selectVoById(coatingId); + } + + /** + * 查询镀锌/镀铬镀层规范明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProductCoatingSpecBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询镀锌/镀铬镀层规范明细列表 + */ + @Override + public List queryList(PtProductCoatingSpecBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductCoatingSpecBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductCoatingSpec::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getCoatingType()), PtProductCoatingSpec::getCoatingType, bo.getCoatingType()); + lqw.eq(StringUtils.isNotBlank(bo.getCoatingDesignation()), PtProductCoatingSpec::getCoatingDesignation, bo.getCoatingDesignation()); + lqw.eq(bo.getCoatingWeightMin() != null, PtProductCoatingSpec::getCoatingWeightMin, bo.getCoatingWeightMin()); + lqw.eq(bo.getCoatingWeightMax() != null, PtProductCoatingSpec::getCoatingWeightMax, bo.getCoatingWeightMax()); + lqw.eq(bo.getCoatingWeightTarget() != null, PtProductCoatingSpec::getCoatingWeightTarget, bo.getCoatingWeightTarget()); + lqw.eq(bo.getSingleSpotMin() != null, PtProductCoatingSpec::getSingleSpotMin, bo.getSingleSpotMin()); + lqw.eq(StringUtils.isNotBlank(bo.getSurfaceFinish()), PtProductCoatingSpec::getSurfaceFinish, bo.getSurfaceFinish()); + lqw.eq(StringUtils.isNotBlank(bo.getSurfaceTreatment()), PtProductCoatingSpec::getSurfaceTreatment, bo.getSurfaceTreatment()); + lqw.eq(StringUtils.isNotBlank(bo.getBendTestMandrel()), PtProductCoatingSpec::getBendTestMandrel, bo.getBendTestMandrel()); + lqw.eq(bo.getSaltSprayHoursWhite() != null, PtProductCoatingSpec::getSaltSprayHoursWhite, bo.getSaltSprayHoursWhite()); + lqw.eq(bo.getSaltSprayHoursRed() != null, PtProductCoatingSpec::getSaltSprayHoursRed, bo.getSaltSprayHoursRed()); + return lqw; + } + + /** + * 新增镀锌/镀铬镀层规范明细 + */ + @Override + public Boolean insertByBo(PtProductCoatingSpecBo bo) { + PtProductCoatingSpec add = BeanUtil.toBean(bo, PtProductCoatingSpec.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setCoatingId(add.getCoatingId()); + } + return flag; + } + + /** + * 修改镀锌/镀铬镀层规范明细 + */ + @Override + public Boolean updateByBo(PtProductCoatingSpecBo bo) { + PtProductCoatingSpec update = BeanUtil.toBean(bo, PtProductCoatingSpec.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductCoatingSpec entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除镀锌/镀铬镀层规范明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductDimensionServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductDimensionServiceImpl.java new file mode 100644 index 000000000..ef584a20a --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductDimensionServiceImpl.java @@ -0,0 +1,117 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductDimensionBo; +import com.klp.pt.domain.vo.PtProductDimensionVo; +import com.klp.pt.domain.PtProductDimension; +import com.klp.pt.mapper.PtProductDimensionMapper; +import com.klp.pt.service.IPtProductDimensionService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品规格尺寸范围明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductDimensionServiceImpl implements IPtProductDimensionService { + + private final PtProductDimensionMapper baseMapper; + + /** + * 查询产品规格尺寸范围明细 + */ + @Override + public PtProductDimensionVo queryById(Long dimensionId){ + return baseMapper.selectVoById(dimensionId); + } + + /** + * 查询产品规格尺寸范围明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProductDimensionBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品规格尺寸范围明细列表 + */ + @Override + public List queryList(PtProductDimensionBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductDimensionBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductDimension::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getDimCode()), PtProductDimension::getDimCode, bo.getDimCode()); + lqw.eq(StringUtils.isNotBlank(bo.getDimNameZh()), PtProductDimension::getDimNameZh, bo.getDimNameZh()); + lqw.eq(bo.getMinValue() != null, PtProductDimension::getMinValue, bo.getMinValue()); + lqw.eq(bo.getMaxValue() != null, PtProductDimension::getMaxValue, bo.getMaxValue()); + lqw.eq(StringUtils.isNotBlank(bo.getUnit()), PtProductDimension::getUnit, bo.getUnit()); + lqw.eq(StringUtils.isNotBlank(bo.getPreferredValues()), PtProductDimension::getPreferredValues, bo.getPreferredValues()); + lqw.eq(StringUtils.isNotBlank(bo.getToleranceGradeRef()), PtProductDimension::getToleranceGradeRef, bo.getToleranceGradeRef()); + lqw.eq(bo.getSortOrder() != null, PtProductDimension::getSortOrder, bo.getSortOrder()); + return lqw; + } + + /** + * 新增产品规格尺寸范围明细 + */ + @Override + public Boolean insertByBo(PtProductDimensionBo bo) { + PtProductDimension add = BeanUtil.toBean(bo, PtProductDimension.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setDimensionId(add.getDimensionId()); + } + return flag; + } + + /** + * 修改产品规格尺寸范围明细 + */ + @Override + public Boolean updateByBo(PtProductDimensionBo bo) { + PtProductDimension update = BeanUtil.toBean(bo, PtProductDimension.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductDimension entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品规格尺寸范围明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductPhysicalPropertyServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductPhysicalPropertyServiceImpl.java new file mode 100644 index 000000000..13be81e2b --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductPhysicalPropertyServiceImpl.java @@ -0,0 +1,122 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductPhysicalPropertyBo; +import com.klp.pt.domain.vo.PtProductPhysicalPropertyVo; +import com.klp.pt.domain.PtProductPhysicalProperty; +import com.klp.pt.mapper.PtProductPhysicalPropertyMapper; +import com.klp.pt.service.IPtProductPhysicalPropertyService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品力学物理性能明细Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductPhysicalPropertyServiceImpl implements IPtProductPhysicalPropertyService { + + private final PtProductPhysicalPropertyMapper baseMapper; + + /** + * 查询产品力学物理性能明细 + */ + @Override + public PtProductPhysicalPropertyVo queryById(Long propertyId){ + return baseMapper.selectVoById(propertyId); + } + + /** + * 查询产品力学物理性能明细列表 + */ + @Override + public TableDataInfo queryPageList(PtProductPhysicalPropertyBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品力学物理性能明细列表 + */ + @Override + public List queryList(PtProductPhysicalPropertyBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductPhysicalPropertyBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductPhysicalProperty::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getPropertyCode()), PtProductPhysicalProperty::getPropertyCode, bo.getPropertyCode()); + lqw.eq(StringUtils.isNotBlank(bo.getPropertyNameZh()), PtProductPhysicalProperty::getPropertyNameZh, bo.getPropertyNameZh()); + lqw.eq(bo.getMinValue() != null, PtProductPhysicalProperty::getMinValue, bo.getMinValue()); + lqw.eq(bo.getMaxValue() != null, PtProductPhysicalProperty::getMaxValue, bo.getMaxValue()); + lqw.eq(bo.getTargetValue() != null, PtProductPhysicalProperty::getTargetValue, bo.getTargetValue()); + lqw.eq(StringUtils.isNotBlank(bo.getUnit()), PtProductPhysicalProperty::getUnit, bo.getUnit()); + lqw.eq(StringUtils.isNotBlank(bo.getTestStandard()), PtProductPhysicalProperty::getTestStandard, bo.getTestStandard()); + lqw.eq(StringUtils.isNotBlank(bo.getTestDirection()), PtProductPhysicalProperty::getTestDirection, bo.getTestDirection()); + lqw.eq(bo.getApplicableThickMin() != null, PtProductPhysicalProperty::getApplicableThickMin, bo.getApplicableThickMin()); + lqw.eq(bo.getApplicableThickMax() != null, PtProductPhysicalProperty::getApplicableThickMax, bo.getApplicableThickMax()); + lqw.eq(StringUtils.isNotBlank(bo.getApplicableThickDesc()), PtProductPhysicalProperty::getApplicableThickDesc, bo.getApplicableThickDesc()); + lqw.eq(bo.getIsMandatory() != null, PtProductPhysicalProperty::getIsMandatory, bo.getIsMandatory()); + lqw.eq(bo.getSortOrder() != null, PtProductPhysicalProperty::getSortOrder, bo.getSortOrder()); + return lqw; + } + + /** + * 新增产品力学物理性能明细 + */ + @Override + public Boolean insertByBo(PtProductPhysicalPropertyBo bo) { + PtProductPhysicalProperty add = BeanUtil.toBean(bo, PtProductPhysicalProperty.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setPropertyId(add.getPropertyId()); + } + return flag; + } + + /** + * 修改产品力学物理性能明细 + */ + @Override + public Boolean updateByBo(PtProductPhysicalPropertyBo bo) { + PtProductPhysicalProperty update = BeanUtil.toBean(bo, PtProductPhysicalProperty.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductPhysicalProperty entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品力学物理性能明细 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductProcessRouteServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductProcessRouteServiceImpl.java new file mode 100644 index 000000000..c3671c774 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductProcessRouteServiceImpl.java @@ -0,0 +1,115 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductProcessRouteBo; +import com.klp.pt.domain.vo.PtProductProcessRouteVo; +import com.klp.pt.domain.PtProductProcessRoute; +import com.klp.pt.mapper.PtProductProcessRouteMapper; +import com.klp.pt.service.IPtProductProcessRouteService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品标准绑定生产工艺中间Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductProcessRouteServiceImpl implements IPtProductProcessRouteService { + + private final PtProductProcessRouteMapper baseMapper; + + /** + * 查询产品标准绑定生产工艺中间 + */ + @Override + public PtProductProcessRouteVo queryById(Long routeId){ + return baseMapper.selectVoById(routeId); + } + + /** + * 查询产品标准绑定生产工艺中间列表 + */ + @Override + public TableDataInfo queryPageList(PtProductProcessRouteBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品标准绑定生产工艺中间列表 + */ + @Override + public List queryList(PtProductProcessRouteBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductProcessRouteBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductProcessRoute::getStandardId, bo.getStandardId()); + lqw.eq(bo.getProcessId() != null, PtProductProcessRoute::getProcessId, bo.getProcessId()); + lqw.eq(bo.getRouteSequence() != null, PtProductProcessRoute::getRouteSequence, bo.getRouteSequence()); + lqw.eq(bo.getIsDefaultRoute() != null, PtProductProcessRoute::getIsDefaultRoute, bo.getIsDefaultRoute()); + lqw.eq(StringUtils.isNotBlank(bo.getApplicabilityRule()), PtProductProcessRoute::getApplicabilityRule, bo.getApplicabilityRule()); + lqw.eq(bo.getEstimatedYield() != null, PtProductProcessRoute::getEstimatedYield, bo.getEstimatedYield()); + lqw.eq(bo.getCostIndex() != null, PtProductProcessRoute::getCostIndex, bo.getCostIndex()); + return lqw; + } + + /** + * 新增产品标准绑定生产工艺中间 + */ + @Override + public Boolean insertByBo(PtProductProcessRouteBo bo) { + PtProductProcessRoute add = BeanUtil.toBean(bo, PtProductProcessRoute.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setRouteId(add.getRouteId()); + } + return flag; + } + + /** + * 修改产品标准绑定生产工艺中间 + */ + @Override + public Boolean updateByBo(PtProductProcessRouteBo bo) { + PtProductProcessRoute update = BeanUtil.toBean(bo, PtProductProcessRoute.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductProcessRoute entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品标准绑定生产工艺中间 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductRefStandardServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductRefStandardServiceImpl.java new file mode 100644 index 000000000..6e26c4a35 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductRefStandardServiceImpl.java @@ -0,0 +1,113 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductRefStandardBo; +import com.klp.pt.domain.vo.PtProductRefStandardVo; +import com.klp.pt.domain.PtProductRefStandard; +import com.klp.pt.mapper.PtProductRefStandardMapper; +import com.klp.pt.service.IPtProductRefStandardService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品引用外部标准Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductRefStandardServiceImpl implements IPtProductRefStandardService { + + private final PtProductRefStandardMapper baseMapper; + + /** + * 查询产品引用外部标准 + */ + @Override + public PtProductRefStandardVo queryById(Long refId){ + return baseMapper.selectVoById(refId); + } + + /** + * 查询产品引用外部标准列表 + */ + @Override + public TableDataInfo queryPageList(PtProductRefStandardBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品引用外部标准列表 + */ + @Override + public List queryList(PtProductRefStandardBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductRefStandardBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(bo.getStandardId() != null, PtProductRefStandard::getStandardId, bo.getStandardId()); + lqw.eq(StringUtils.isNotBlank(bo.getRefStandardCode()), PtProductRefStandard::getRefStandardCode, bo.getRefStandardCode()); + lqw.like(StringUtils.isNotBlank(bo.getRefStandardName()), PtProductRefStandard::getRefStandardName, bo.getRefStandardName()); + lqw.eq(StringUtils.isNotBlank(bo.getRefOrganization()), PtProductRefStandard::getRefOrganization, bo.getRefOrganization()); + lqw.eq(StringUtils.isNotBlank(bo.getRefSection()), PtProductRefStandard::getRefSection, bo.getRefSection()); + return lqw; + } + + /** + * 新增产品引用外部标准 + */ + @Override + public Boolean insertByBo(PtProductRefStandardBo bo) { + PtProductRefStandard add = BeanUtil.toBean(bo, PtProductRefStandard.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setRefId(add.getRefId()); + } + return flag; + } + + /** + * 修改产品引用外部标准 + */ + @Override + public Boolean updateByBo(PtProductRefStandardBo bo) { + PtProductRefStandard update = BeanUtil.toBean(bo, PtProductRefStandard.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductRefStandard entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品引用外部标准 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductStandardServiceImpl.java b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductStandardServiceImpl.java new file mode 100644 index 000000000..9b08546d1 --- /dev/null +++ b/klp-pt/src/main/java/com/klp/pt/service/impl/PtProductStandardServiceImpl.java @@ -0,0 +1,119 @@ +package com.klp.pt.service.impl; + +import cn.hutool.core.bean.BeanUtil; +import com.klp.common.core.page.TableDataInfo; +import com.klp.common.core.domain.PageQuery; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; +import com.klp.common.utils.StringUtils; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Service; +import com.klp.pt.domain.bo.PtProductStandardBo; +import com.klp.pt.domain.vo.PtProductStandardVo; +import com.klp.pt.domain.PtProductStandard; +import com.klp.pt.mapper.PtProductStandardMapper; +import com.klp.pt.service.IPtProductStandardService; + +import java.util.List; +import java.util.Map; +import java.util.Collection; + +/** + * 产品标准主Service业务层处理 + * + * @author klp + * @date 2026-07-02 + */ +@RequiredArgsConstructor +@Service +public class PtProductStandardServiceImpl implements IPtProductStandardService { + + private final PtProductStandardMapper baseMapper; + + /** + * 查询产品标准主 + */ + @Override + public PtProductStandardVo queryById(Long standardId){ + return baseMapper.selectVoById(standardId); + } + + /** + * 查询产品标准主列表 + */ + @Override + public TableDataInfo queryPageList(PtProductStandardBo bo, PageQuery pageQuery) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + Page result = baseMapper.selectVoPage(pageQuery.build(), lqw); + return TableDataInfo.build(result); + } + + /** + * 查询产品标准主列表 + */ + @Override + public List queryList(PtProductStandardBo bo) { + LambdaQueryWrapper lqw = buildQueryWrapper(bo); + return baseMapper.selectVoList(lqw); + } + + private LambdaQueryWrapper buildQueryWrapper(PtProductStandardBo bo) { + Map params = bo.getParams(); + LambdaQueryWrapper lqw = Wrappers.lambdaQuery(); + lqw.eq(StringUtils.isNotBlank(bo.getStandardCode()), PtProductStandard::getStandardCode, bo.getStandardCode()); + lqw.like(StringUtils.isNotBlank(bo.getStandardName()), PtProductStandard::getStandardName, bo.getStandardName()); + lqw.eq(StringUtils.isNotBlank(bo.getProductType()), PtProductStandard::getProductType, bo.getProductType()); + lqw.eq(StringUtils.isNotBlank(bo.getSteelGrade()), PtProductStandard::getSteelGrade, bo.getSteelGrade()); + lqw.eq(StringUtils.isNotBlank(bo.getSteelGradeAlias()), PtProductStandard::getSteelGradeAlias, bo.getSteelGradeAlias()); + lqw.eq(StringUtils.isNotBlank(bo.getProductForm()), PtProductStandard::getProductForm, bo.getProductForm()); + lqw.eq(bo.getCategoryId() != null, PtProductStandard::getCategoryId, bo.getCategoryId()); + lqw.eq(bo.getStatus() != null, PtProductStandard::getStatus, bo.getStatus()); + lqw.eq(bo.getEffectiveDate() != null, PtProductStandard::getEffectiveDate, bo.getEffectiveDate()); + lqw.eq(bo.getExpireDate() != null, PtProductStandard::getExpireDate, bo.getExpireDate()); + lqw.eq(bo.getIsDefault() != null, PtProductStandard::getIsDefault, bo.getIsDefault()); + return lqw; + } + + /** + * 新增产品标准主 + */ + @Override + public Boolean insertByBo(PtProductStandardBo bo) { + PtProductStandard add = BeanUtil.toBean(bo, PtProductStandard.class); + validEntityBeforeSave(add); + boolean flag = baseMapper.insert(add) > 0; + if (flag) { + bo.setStandardId(add.getStandardId()); + } + return flag; + } + + /** + * 修改产品标准主 + */ + @Override + public Boolean updateByBo(PtProductStandardBo bo) { + PtProductStandard update = BeanUtil.toBean(bo, PtProductStandard.class); + validEntityBeforeSave(update); + return baseMapper.updateById(update) > 0; + } + + /** + * 保存前的数据校验 + */ + private void validEntityBeforeSave(PtProductStandard entity){ + //TODO 做一些数据校验,如唯一约束 + } + + /** + * 批量删除产品标准主 + */ + @Override + public Boolean deleteWithValidByIds(Collection ids, Boolean isValid) { + if(isValid){ + //TODO 做一些业务上的校验,判断是否需要校验 + } + return baseMapper.deleteBatchIds(ids) > 0; + } +} diff --git a/klp-pt/src/main/resources/mapper/pt/PtProcessQualityGateMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProcessQualityGateMapper.xml new file mode 100644 index 000000000..8bb5a3491 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProcessQualityGateMapper.xml @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProcessStepParamMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProcessStepParamMapper.xml new file mode 100644 index 000000000..689e6cf14 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProcessStepParamMapper.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProcesseMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProcesseMapper.xml new file mode 100644 index 000000000..8e015bba5 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProcesseMapper.xml @@ -0,0 +1,29 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductApplicationMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductApplicationMapper.xml new file mode 100644 index 000000000..ce8533abc --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductApplicationMapper.xml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductChemicalCompositionMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductChemicalCompositionMapper.xml new file mode 100644 index 000000000..d4b107d26 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductChemicalCompositionMapper.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductCoatingSpecMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductCoatingSpecMapper.xml new file mode 100644 index 000000000..94288b8f1 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductCoatingSpecMapper.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductDimensionMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductDimensionMapper.xml new file mode 100644 index 000000000..35f19dd5b --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductDimensionMapper.xml @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductPhysicalPropertyMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductPhysicalPropertyMapper.xml new file mode 100644 index 000000000..3e915f43d --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductPhysicalPropertyMapper.xml @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductProcessRouteMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductProcessRouteMapper.xml new file mode 100644 index 000000000..362eae6ea --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductProcessRouteMapper.xml @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductRefStandardMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductRefStandardMapper.xml new file mode 100644 index 000000000..1b8f8e7d6 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductRefStandardMapper.xml @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/klp-pt/src/main/resources/mapper/pt/PtProductStandardMapper.xml b/klp-pt/src/main/resources/mapper/pt/PtProductStandardMapper.xml new file mode 100644 index 000000000..103b07a28 --- /dev/null +++ b/klp-pt/src/main/resources/mapper/pt/PtProductStandardMapper.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pom.xml b/pom.xml index 7663e8934..b3b5b1946 100644 --- a/pom.xml +++ b/pom.xml @@ -415,6 +415,13 @@ klp-flow ${klp-flowable-plus.version} + + + + com.klp + klp-pt + ${klp-flowable-plus.version} + @@ -442,6 +449,7 @@ klp-aps klp-cost klp-flow + klp-pt pom