diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryController.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryController.java new file mode 100644 index 0000000..e908e5d --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryController.java @@ -0,0 +1,145 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery; + +import cn.hutool.core.collection.CollUtil; +import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog; +import cn.iocoder.yudao.framework.common.pojo.CommonResult; +import cn.iocoder.yudao.framework.common.pojo.PageParam; +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.framework.common.util.collection.MapUtils; +import cn.iocoder.yudao.framework.common.util.object.BeanUtils; +import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachineryPageReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachineryRespVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachinerySaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO; +import cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkshopDO; +import cn.iocoder.yudao.module.mes.service.dv.machinery.MesDvMachineryService; +import cn.iocoder.yudao.module.mes.service.dv.machinery.MesDvMachineryTypeService; +import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkshopService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.annotation.Resource; +import jakarta.servlet.http.HttpServletResponse; +import jakarta.validation.Valid; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.io.IOException; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT; +import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success; +import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertSet; + +@Tag(name = "管理后台 - MES 设备台账") +@RestController +@RequestMapping("/mes/dv/machinery") +@Validated +public class MesDvMachineryController { + + @Resource + private MesDvMachineryService machineryService; + + @Resource + private MesDvMachineryTypeService machineryTypeService; + + @Resource + private MesMdWorkshopService workshopService; + + @PostMapping("/create") + @Operation(summary = "创建设备") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:create')") + public CommonResult createMachinery(@Valid @RequestBody MesDvMachinerySaveReqVO createReqVO) { + return success(machineryService.createMachinery(createReqVO)); + } + + @PutMapping("/update") + @Operation(summary = "更新设备") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:update')") + public CommonResult updateMachinery(@Valid @RequestBody MesDvMachinerySaveReqVO updateReqVO) { + machineryService.updateMachinery(updateReqVO); + return success(true); + } + + @DeleteMapping("/delete") + @Operation(summary = "删除设备") + @Parameter(name = "id", description = "编号", required = true) + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:delete')") + public CommonResult deleteMachinery(@RequestParam("id") Long id) { + machineryService.deleteMachinery(id); + return success(true); + } + + @GetMapping("/get") + @Operation(summary = "获得设备") + @Parameter(name = "id", description = "编号", required = true, example = "1024") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:query')") + public CommonResult getMachinery(@RequestParam("id") Long id) { + MesDvMachineryDO machinery = machineryService.getMachinery(id); + MesDvMachineryRespVO respVO = BeanUtils.toBean(machinery, MesDvMachineryRespVO.class); + // 拼接设备类型名称和车间名称 + // TODO @AI：复用下 buildMachineryRespVOList 方法； + if (respVO != null) { + if (respVO.getMachineryTypeId() != null) { + MesDvMachineryTypeDO machineryType = machineryTypeService.getMachineryType(respVO.getMachineryTypeId()); + if (machineryType != null) { + respVO.setMachineryTypeName(machineryType.getName()); + } + } + if (respVO.getWorkshopId() != null) { + MesMdWorkshopDO workshop = workshopService.getWorkshop(respVO.getWorkshopId()); + if (workshop != null) { + respVO.setWorkshopName(workshop.getName()); + } + } + } + return success(respVO); + } + + @GetMapping("/page") + @Operation(summary = "获得设备分页") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:query')") + public CommonResult> getMachineryPage(@Valid MesDvMachineryPageReqVO pageReqVO) { + PageResult pageResult = machineryService.getMachineryPage(pageReqVO); + return success(new PageResult<>(buildMachineryRespVOList(pageResult.getList()), pageResult.getTotal())); + } + + @GetMapping("/export-excel") + @Operation(summary = "导出设备 Excel") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery:export')") + @ApiAccessLog(operateType = EXPORT) + public void exportMachineryExcel(@Valid MesDvMachineryPageReqVO pageReqVO, + HttpServletResponse response) throws IOException { + pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE); + List list = machineryService.getMachineryPage(pageReqVO).getList(); + // 导出 Excel + ExcelUtils.write(response, "设备台账.xls", "数据", MesDvMachineryRespVO.class, + buildMachineryRespVOList(list)); + } + + // ==================== 拼接 VO ==================== + + private List buildMachineryRespVOList(List list) { + if (CollUtil.isEmpty(list)) { + return Collections.emptyList(); + } + // 1. 批量获取设备类型和车间信息 + Map machineryTypeMap = machineryTypeService.getMachineryTypeMap( + convertSet(list, MesDvMachineryDO::getMachineryTypeId)); + Map workshopMap = workshopService.getWorkshopMap( + convertSet(list, MesDvMachineryDO::getWorkshopId)); + // 2. 拼接 VO + return BeanUtils.toBean(list, MesDvMachineryRespVO.class, vo -> { + MapUtils.findAndThen(machineryTypeMap, vo.getMachineryTypeId(), + machineryType -> vo.setMachineryTypeName(machineryType.getName())); + MapUtils.findAndThen(workshopMap, vo.getWorkshopId(), + workshop -> vo.setWorkshopName(workshop.getName())); + }); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryTypeController.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryTypeController.java new file mode 100644 index 0000000..ed3c8c7 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/MesDvMachineryTypeController.java @@ -0,0 +1,85 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery; + +import cn.iocoder.yudao.framework.common.enums.CommonStatusEnum; +import cn.iocoder.yudao.framework.common.pojo.CommonResult; +import cn.iocoder.yudao.framework.common.util.object.BeanUtils; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeListReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeRespVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeSaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO; +import cn.iocoder.yudao.module.mes.service.dv.machinery.MesDvMachineryTypeService; +import io.swagger.v3.oas.annotations.Operation; +import io.swagger.v3.oas.annotations.Parameter; +import io.swagger.v3.oas.annotations.tags.Tag; +import jakarta.annotation.Resource; +import jakarta.validation.Valid; +import org.springframework.security.access.prepost.PreAuthorize; +import org.springframework.validation.annotation.Validated; +import org.springframework.web.bind.annotation.*; + +import java.util.List; + +import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success; +import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertList; + +@Tag(name = "管理后台 - MES 设备类型") +@RestController +@RequestMapping("/mes/dv/machinery-type") +@Validated +public class MesDvMachineryTypeController { + + @Resource + private MesDvMachineryTypeService machineryTypeService; + + @PostMapping("/create") + @Operation(summary = "创建设备类型") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery-type:create')") + public CommonResult createMachineryType(@Valid @RequestBody MesDvMachineryTypeSaveReqVO createReqVO) { + return success(machineryTypeService.createMachineryType(createReqVO)); + } + + @PutMapping("/update") + @Operation(summary = "更新设备类型") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery-type:update')") + public CommonResult updateMachineryType(@Valid @RequestBody MesDvMachineryTypeSaveReqVO updateReqVO) { + machineryTypeService.updateMachineryType(updateReqVO); + return success(true); + } + + @DeleteMapping("/delete") + @Operation(summary = "删除设备类型") + @Parameter(name = "id", description = "编号", required = true) + @PreAuthorize("@ss.hasPermission('mes:dv-machinery-type:delete')") + public CommonResult deleteMachineryType(@RequestParam("id") Long id) { + machineryTypeService.deleteMachineryType(id); + return success(true); + } + + @GetMapping("/get") + @Operation(summary = "获得设备类型") + @Parameter(name = "id", description = "编号", required = true, example = "1024") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery-type:query')") + public CommonResult getMachineryType(@RequestParam("id") Long id) { + MesDvMachineryTypeDO machineryType = machineryTypeService.getMachineryType(id); + return success(BeanUtils.toBean(machineryType, MesDvMachineryTypeRespVO.class)); + } + + @GetMapping("/list") + @Operation(summary = "获得设备类型列表") + @PreAuthorize("@ss.hasPermission('mes:dv-machinery-type:query')") + public CommonResult> getMachineryTypeList(@Valid MesDvMachineryTypeListReqVO listReqVO) { + List list = machineryTypeService.getMachineryTypeList(listReqVO); + return success(BeanUtils.toBean(list, MesDvMachineryTypeRespVO.class)); + } + + @GetMapping("/simple-list") + @Operation(summary = "获得设备类型精简列表", description = "只包含被开启的类型，主要用于前端的下拉选项") + public CommonResult> getMachineryTypeSimpleList() { + List list = machineryTypeService.getMachineryTypeList( + new MesDvMachineryTypeListReqVO().setStatus(CommonStatusEnum.ENABLE.getStatus())); + return success(convertList(list, machineryType -> new MesDvMachineryTypeRespVO() + .setId(machineryType.getId()).setName(machineryType.getName()) + .setParentId(machineryType.getParentId()))); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryPageReqVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryPageReqVO.java new file mode 100644 index 0000000..0383a46 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryPageReqVO.java @@ -0,0 +1,33 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo; + +import cn.iocoder.yudao.framework.common.pojo.PageParam; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.ToString; + +@Schema(description = "管理后台 - MES 设备台账分页 Request VO") +@Data +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +public class MesDvMachineryPageReqVO extends PageParam { + + @Schema(description = "设备编码", example = "EQ-001") + private String code; + + @Schema(description = "设备名称", example = "CNC 加工中心") + private String name; + + @Schema(description = "品牌", example = "西门子") + private String brand; + + @Schema(description = "设备类型编号", example = "100") + private Long machineryTypeId; + + @Schema(description = "所属车间编号", example = "200") + private Long workshopId; + + @Schema(description = "设备状态", example = "1") + private Integer status; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryRespVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryRespVO.java new file mode 100644 index 0000000..c15a2e9 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachineryRespVO.java @@ -0,0 +1,85 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo; + +import cn.iocoder.yudao.framework.excel.core.annotations.DictFormat; +import cn.iocoder.yudao.framework.excel.core.convert.DictConvert; +import cn.iocoder.yudao.module.mes.enums.DictTypeConstants; +import cn.idev.excel.annotation.ExcelIgnoreUnannotated; +import cn.idev.excel.annotation.ExcelProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; + +import java.time.LocalDateTime; + +@Schema(description = "管理后台 - MES 设备台账 Response VO") +@Data +@ExcelIgnoreUnannotated +public class MesDvMachineryRespVO { + + @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024") + @ExcelProperty("编号") + private Long id; + + @Schema(description = "设备编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "EQ-001") + @ExcelProperty("设备编码") + private String code; + + @Schema(description = "设备名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "CNC 加工中心") + @ExcelProperty("设备名称") + private String name; + + @Schema(description = "品牌", example = "西门子") + @ExcelProperty("品牌") + private String brand; + + @Schema(description = "规格型号", example = "S7-300") + @ExcelProperty("规格型号") + private String spec; + + @Schema(description = "设备类型编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "100") + private Long machineryTypeId; + + @Schema(description = "设备类型名称", example = "数控机床") + @ExcelProperty("设备类型") + private String machineryTypeName; + + @Schema(description = "所属车间编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "200") + private Long workshopId; + + @Schema(description = "所属车间名称", example = "一号车间") + @ExcelProperty("所属车间") + private String workshopName; + + @Schema(description = "设备状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "1") + @ExcelProperty(value = "设备状态", converter = DictConvert.class) + @DictFormat(DictTypeConstants.MES_DV_MACHINERY_STATUS) + private Integer status; + + @Schema(description = "最近保养时间") + @ExcelProperty("最近保养时间") + private LocalDateTime lastMaintenTime; + + @Schema(description = "最近点检时间") + @ExcelProperty("最近点检时间") + private LocalDateTime lastCheckTime; + + @Schema(description = "备注", example = "备注") + @ExcelProperty("备注") + private String remark; + + @Schema(description = "预留字段1") + private String attribute1; + + @Schema(description = "预留字段2") + private String attribute2; + + @Schema(description = "预留字段3") + private Integer attribute3; + + @Schema(description = "预留字段4") + private Integer attribute4; + + @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED) + @ExcelProperty("创建时间") + private LocalDateTime createTime; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachinerySaveReqVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachinerySaveReqVO.java new file mode 100644 index 0000000..b8e9e67 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/MesDvMachinerySaveReqVO.java @@ -0,0 +1,56 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo; + +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import lombok.Data; + +@Schema(description = "管理后台 - MES 设备台账新增/修改 Request VO") +@Data +public class MesDvMachinerySaveReqVO { + + @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024") + private Long id; + + @Schema(description = "设备编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "EQ-001") + @NotEmpty(message = "设备编码不能为空") + private String code; + + @Schema(description = "设备名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "CNC 加工中心") + @NotEmpty(message = "设备名称不能为空") + private String name; + + @Schema(description = "品牌", example = "西门子") + private String brand; + + @Schema(description = "规格型号", example = "S7-300") + private String spec; + + @Schema(description = "设备类型编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "100") + @NotNull(message = "设备类型不能为空") + private Long machineryTypeId; + + @Schema(description = "所属车间编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "200") + @NotNull(message = "所属车间不能为空") + private Long workshopId; + + @Schema(description = "设备状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "1") + @NotNull(message = "设备状态不能为空") + private Integer status; + + @Schema(description = "备注", example = "备注") + private String remark; + + @Schema(description = "预留字段1") + private String attribute1; + + @Schema(description = "预留字段2") + private String attribute2; + + @Schema(description = "预留字段3") + private Integer attribute3; + + @Schema(description = "预留字段4") + private Integer attribute4; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeListReqVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeListReqVO.java new file mode 100644 index 0000000..47c530d --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeListReqVO.java @@ -0,0 +1,18 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type; + +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; +import lombok.experimental.Accessors; + +@Schema(description = "管理后台 - MES 设备类型列表 Request VO") +@Data +@Accessors(chain = true) +public class MesDvMachineryTypeListReqVO { + + @Schema(description = "类型名称", example = "数控机床") + private String name; + + @Schema(description = "状态", example = "0") + private Integer status; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeRespVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeRespVO.java new file mode 100644 index 0000000..01e9bae --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeRespVO.java @@ -0,0 +1,58 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type; + +import cn.idev.excel.annotation.ExcelIgnoreUnannotated; +import cn.idev.excel.annotation.ExcelProperty; +import io.swagger.v3.oas.annotations.media.Schema; +import lombok.Data; + +import java.time.LocalDateTime; + +@Schema(description = "管理后台 - MES 设备类型 Response VO") +@Data +@ExcelIgnoreUnannotated +public class MesDvMachineryTypeRespVO { + + @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024") + @ExcelProperty("编号") + private Long id; + + @Schema(description = "类型编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "MT-001") + @ExcelProperty("类型编码") + private String code; + + @Schema(description = "类型名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "数控机床") + @ExcelProperty("类型名称") + private String name; + + @Schema(description = "父类型编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + private Long parentId; + + @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + @ExcelProperty("状态") + private Integer status; + + @Schema(description = "显示排序", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + @ExcelProperty("显示排序") + private Integer sort; + + @Schema(description = "备注", example = "备注") + @ExcelProperty("备注") + private String remark; + + @Schema(description = "预留字段1") + private String attribute1; + + @Schema(description = "预留字段2") + private String attribute2; + + @Schema(description = "预留字段3") + private Integer attribute3; + + @Schema(description = "预留字段4") + private Integer attribute4; + + @Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED) + @ExcelProperty("创建时间") + private LocalDateTime createTime; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeSaveReqVO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeSaveReqVO.java new file mode 100644 index 0000000..5730163 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/controller/admin/dv/machinery/vo/type/MesDvMachineryTypeSaveReqVO.java @@ -0,0 +1,50 @@ +package cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type; + +import io.swagger.v3.oas.annotations.media.Schema; +import jakarta.validation.constraints.NotEmpty; +import jakarta.validation.constraints.NotNull; +import lombok.Data; + +@Schema(description = "管理后台 - MES 设备类型新增/修改 Request VO") +@Data +public class MesDvMachineryTypeSaveReqVO { + + @Schema(description = "编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "1024") + private Long id; + + @Schema(description = "类型编码", requiredMode = Schema.RequiredMode.REQUIRED, example = "MT-001") + @NotEmpty(message = "类型编码不能为空") + private String code; + + @Schema(description = "类型名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "数控机床") + @NotEmpty(message = "类型名称不能为空") + private String name; + + @Schema(description = "父类型编号", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + @NotNull(message = "父类型编号不能为空") + private Long parentId; + + @Schema(description = "状态", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + @NotNull(message = "状态不能为空") + private Integer status; + + @Schema(description = "显示排序", requiredMode = Schema.RequiredMode.REQUIRED, example = "0") + @NotNull(message = "显示排序不能为空") + private Integer sort; + + @Schema(description = "备注", example = "备注") + private String remark; + + @Schema(description = "预留字段1") + private String attribute1; + + @Schema(description = "预留字段2") + private String attribute2; + + @Schema(description = "预留字段3") + private Integer attribute3; + + @Schema(description = "预留字段4") + private Integer attribute4; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryDO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryDO.java new file mode 100644 index 0000000..211ef58 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryDO.java @@ -0,0 +1,95 @@ +package cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery; + +import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO; +import com.baomidou.mybatisplus.annotation.KeySequence; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.*; + +import java.time.LocalDateTime; + +/** + * MES 设备台账 DO + * + * @author 芋道源码 + */ +@TableName("mes_dv_machinery") +@KeySequence("mes_dv_machinery_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。 +@Data +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class MesDvMachineryDO extends BaseDO { + + /** + * 编号 + */ + @TableId + private Long id; + /** + * 设备编码 + */ + private String code; + /** + * 设备名称 + */ + private String name; + /** + * 品牌 + */ + private String brand; + /** + * 规格型号 + */ + private String spec; + /** + * 设备类型编号 + * + * 关联 {@link MesDvMachineryTypeDO#getId()} + */ + private Long machineryTypeId; + /** + * 所属车间编号 + * + * 关联 {@link cn.iocoder.yudao.module.mes.dal.dataobject.md.workstation.MesMdWorkshopDO#getId()} + */ + private Long workshopId; + // TODO @AI：搞个枚举类，然后 @下； + /** + * 设备状态 + * + * 字典 mes_dv_machinery_status + */ + private Integer status; + /** + * 最近保养时间 + */ + private LocalDateTime lastMaintenTime; + /** + * 最近点检时间 + */ + private LocalDateTime lastCheckTime; + /** + * 备注 + */ + private String remark; + /** + * 预留字段1 + */ + private String attribute1; + /** + * 预留字段2 + */ + private String attribute2; + /** + * 预留字段3 + */ + private Integer attribute3; + /** + * 预留字段4 + */ + private Integer attribute4; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryTypeDO.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryTypeDO.java new file mode 100644 index 0000000..f7b11c1 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/dataobject/dv/machinery/MesDvMachineryTypeDO.java @@ -0,0 +1,76 @@ +package cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery; + +import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO; +import com.baomidou.mybatisplus.annotation.KeySequence; +import com.baomidou.mybatisplus.annotation.TableId; +import com.baomidou.mybatisplus.annotation.TableName; +import lombok.*; + +/** + * MES 设备类型 DO + * + * @author 芋道源码 + */ +@TableName("mes_dv_machinery_type") +@KeySequence("mes_dv_machinery_type_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库，可不写。 +@Data +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +@Builder +@NoArgsConstructor +@AllArgsConstructor +public class MesDvMachineryTypeDO extends BaseDO { + + public static final Long PARENT_ID_ROOT = 0L; + + /** + * 编号 + */ + @TableId + private Long id; + /** + * 类型编码 + */ + private String code; + /** + * 类型名称 + */ + private String name; + /** + * 父类型编号 + * + * 关联 {@link MesDvMachineryTypeDO#getId()} + */ + private Long parentId; + /** + * 状态 + * + * 枚举 {@link cn.iocoder.yudao.framework.common.enums.CommonStatusEnum} + */ + private Integer status; + /** + * 显示排序 + */ + private Integer sort; + /** + * 备注 + */ + private String remark; + /** + * 预留字段1 + */ + private String attribute1; + /** + * 预留字段2 + */ + private String attribute2; + /** + * 预留字段3 + */ + private Integer attribute3; + /** + * 预留字段4 + */ + private Integer attribute4; + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanMapper.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanMapper.java new file mode 100644 index 0000000..9d2ecad --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanMapper.java @@ -0,0 +1,31 @@ +package cn.iocoder.yudao.module.mes.dal.mysql.cal.plan; + +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; +import cn.iocoder.yudao.module.mes.controller.admin.cal.plan.vo.MesCalPlanPageReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.cal.MesCalPlanDO; +import org.apache.ibatis.annotations.Mapper; + +/** + * MES 排班计划 Mapper + * + * @author 芋道源码 + */ +@Mapper +public interface MesCalPlanMapper extends BaseMapperX { + + default PageResult selectPage(MesCalPlanPageReqVO reqVO) { + return selectPage(reqVO, new LambdaQueryWrapperX() + .likeIfPresent(MesCalPlanDO::getCode, reqVO.getCode()) + .likeIfPresent(MesCalPlanDO::getName, reqVO.getName()) + .eqIfPresent(MesCalPlanDO::getShiftType, reqVO.getShiftType()) + .eqIfPresent(MesCalPlanDO::getStatus, reqVO.getStatus()) + .orderByDesc(MesCalPlanDO::getId)); + } + + default MesCalPlanDO selectByCode(String code) { + return selectOne(MesCalPlanDO::getCode, code); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanTeamMapper.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanTeamMapper.java new file mode 100644 index 0000000..b4c880e --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalPlanTeamMapper.java @@ -0,0 +1,39 @@ +package cn.iocoder.yudao.module.mes.dal.mysql.cal.plan; + +import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; +import cn.iocoder.yudao.module.mes.dal.dataobject.cal.MesCalPlanTeamDO; +import org.apache.ibatis.annotations.Mapper; + +import java.util.List; + +/** + * MES 计划班组关联 Mapper + * + * @author 芋道源码 + */ +@Mapper +public interface MesCalPlanTeamMapper extends BaseMapperX { + + default List selectListByPlanId(Long planId) { + return selectList(new LambdaQueryWrapperX() + .eq(MesCalPlanTeamDO::getPlanId, planId) + .orderByDesc(MesCalPlanTeamDO::getId)); + } + + default Long selectCountByPlanId(Long planId) { + return selectCount(MesCalPlanTeamDO::getPlanId, planId); + } + + default MesCalPlanTeamDO selectByPlanIdAndTeamId(Long planId, Long teamId) { + return selectOne(new LambdaQueryWrapperX() + .eq(MesCalPlanTeamDO::getPlanId, planId) + .eq(MesCalPlanTeamDO::getTeamId, teamId)); + } + + default void deleteByPlanId(Long planId) { + delete(new LambdaQueryWrapperX() + .eq(MesCalPlanTeamDO::getPlanId, planId)); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalShiftMapper.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalShiftMapper.java new file mode 100644 index 0000000..41c0f84 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/cal/plan/MesCalShiftMapper.java @@ -0,0 +1,42 @@ +package cn.iocoder.yudao.module.mes.dal.mysql.cal.plan; + +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; +import cn.iocoder.yudao.module.mes.controller.admin.cal.plan.vo.shift.MesCalShiftPageReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.cal.MesCalShiftDO; +import org.apache.ibatis.annotations.Mapper; + +import java.util.List; + +/** + * MES 计划班次 Mapper + * + * @author 芋道源码 + */ +@Mapper +public interface MesCalShiftMapper extends BaseMapperX { + + default PageResult selectPage(MesCalShiftPageReqVO reqVO) { + return selectPage(reqVO, new LambdaQueryWrapperX() + .eqIfPresent(MesCalShiftDO::getPlanId, reqVO.getPlanId()) + .likeIfPresent(MesCalShiftDO::getName, reqVO.getName()) + .orderByAsc(MesCalShiftDO::getSort)); + } + + default List selectListByPlanId(Long planId) { + return selectList(new LambdaQueryWrapperX() + .eq(MesCalShiftDO::getPlanId, planId) + .orderByAsc(MesCalShiftDO::getSort)); + } + + default Long selectCountByPlanId(Long planId) { + return selectCount(MesCalShiftDO::getPlanId, planId); + } + + default void deleteByPlanId(Long planId) { + delete(new LambdaQueryWrapperX() + .eq(MesCalShiftDO::getPlanId, planId)); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryMapper.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryMapper.java new file mode 100644 index 0000000..e96bf59 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryMapper.java @@ -0,0 +1,37 @@ +package cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery; + +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachineryPageReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO; +import org.apache.ibatis.annotations.Mapper; + +/** + * MES 设备台账 Mapper + * + * @author 芋道源码 + */ +@Mapper +public interface MesDvMachineryMapper extends BaseMapperX { + + default PageResult selectPage(MesDvMachineryPageReqVO reqVO) { + return selectPage(reqVO, new LambdaQueryWrapperX() + .likeIfPresent(MesDvMachineryDO::getCode, reqVO.getCode()) + .likeIfPresent(MesDvMachineryDO::getName, reqVO.getName()) + .likeIfPresent(MesDvMachineryDO::getBrand, reqVO.getBrand()) + .eqIfPresent(MesDvMachineryDO::getMachineryTypeId, reqVO.getMachineryTypeId()) + .eqIfPresent(MesDvMachineryDO::getWorkshopId, reqVO.getWorkshopId()) + .eqIfPresent(MesDvMachineryDO::getStatus, reqVO.getStatus()) + .orderByDesc(MesDvMachineryDO::getId)); + } + + default MesDvMachineryDO selectByCode(String code) { + return selectOne(MesDvMachineryDO::getCode, code); + } + + default Long selectCountByMachineryTypeId(Long machineryTypeId) { + return selectCount(MesDvMachineryDO::getMachineryTypeId, machineryTypeId); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryTypeMapper.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryTypeMapper.java new file mode 100644 index 0000000..6b5fdd9 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/dal/mysql/dv/machinery/MesDvMachineryTypeMapper.java @@ -0,0 +1,49 @@ +package cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery; + +import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX; +import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeListReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO; +import org.apache.ibatis.annotations.Mapper; + +import java.util.List; + +/** + * MES 设备类型 Mapper + * + * @author 芋道源码 + */ +@Mapper +public interface MesDvMachineryTypeMapper extends BaseMapperX { + + default List selectList(MesDvMachineryTypeListReqVO reqVO) { + return selectList(new LambdaQueryWrapperX() + .likeIfPresent(MesDvMachineryTypeDO::getName, reqVO.getName()) + .eqIfPresent(MesDvMachineryTypeDO::getStatus, reqVO.getStatus()) + .orderByAsc(MesDvMachineryTypeDO::getSort) + .orderByDesc(MesDvMachineryTypeDO::getId)); + } + + default List selectList() { + return selectList(new LambdaQueryWrapperX() + .orderByAsc(MesDvMachineryTypeDO::getSort) + .orderByDesc(MesDvMachineryTypeDO::getId)); + } + + default MesDvMachineryTypeDO selectByParentIdAndName(Long parentId, String name) { + return selectOne(new LambdaQueryWrapperX() + .eq(MesDvMachineryTypeDO::getParentId, parentId) + .eq(MesDvMachineryTypeDO::getName, name)); + } + + default MesDvMachineryTypeDO selectByParentIdAndCode(Long parentId, String code) { + return selectOne(new LambdaQueryWrapperX() + .eq(MesDvMachineryTypeDO::getParentId, parentId) + .eq(MesDvMachineryTypeDO::getCode, code)); + } + + default Long selectCountByParentId(Long parentId) { + return selectCount(MesDvMachineryTypeDO::getParentId, parentId); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/DictTypeConstants.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/DictTypeConstants.java index 73905b3..33475b4 100644 --- a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/DictTypeConstants.java +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/DictTypeConstants.java @@ -16,5 +16,6 @@ public interface DictTypeConstants { String MES_CAL_SHIFT_METHOD = "mes_cal_shift_method"; // MES 倒班方式 String MES_CAL_CALENDAR_TYPE = "mes_cal_calendar_type"; // MES 班组类型 String MES_CAL_PLAN_STATUS = "mes_cal_plan_status"; // MES 排班计划状态 + String MES_DV_MACHINERY_STATUS = "mes_dv_machinery_status"; // MES 设备状态 } diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/ErrorCodeConstants.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/ErrorCodeConstants.java index 4675618..3295a5e 100644 --- a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/ErrorCodeConstants.java +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/enums/ErrorCodeConstants.java @@ -104,9 +104,17 @@ public interface ErrorCodeConstants { // ========== MES 设备管理-设备类型（1-040-300-000） ========== ErrorCode DV_MACHINERY_TYPE_NOT_EXISTS = new ErrorCode(1_040_300_000, "设备类型不存在"); + ErrorCode DV_MACHINERY_TYPE_EXITS_CHILDREN = new ErrorCode(1_040_300_001, "存在子类型，无法删除"); + ErrorCode DV_MACHINERY_TYPE_PARENT_NOT_EXITS = new ErrorCode(1_040_300_002, "父级类型不存在"); + ErrorCode DV_MACHINERY_TYPE_PARENT_ERROR = new ErrorCode(1_040_300_003, "不能设置自己为父类型"); + ErrorCode DV_MACHINERY_TYPE_NAME_DUPLICATE = new ErrorCode(1_040_300_004, "同一父类型下已存在该名称"); + ErrorCode DV_MACHINERY_TYPE_CODE_DUPLICATE = new ErrorCode(1_040_300_005, "同一父类型下已存在该编码"); + ErrorCode DV_MACHINERY_TYPE_PARENT_IS_CHILD = new ErrorCode(1_040_300_006, "不能设置自己的子类型为父类型"); + ErrorCode DV_MACHINERY_TYPE_HAS_MACHINERY = new ErrorCode(1_040_300_007, "该类型下存在设备，无法删除"); // ========== MES 设备管理-设备台账（1-040-301-000） ========== ErrorCode DV_MACHINERY_NOT_EXISTS = new ErrorCode(1_040_301_000, "设备不存在"); + ErrorCode DV_MACHINERY_CODE_DUPLICATE = new ErrorCode(1_040_301_001, "设备编码已存在"); // ========== MES 设备管理-点检计划（1-040-302-000） ========== ErrorCode DV_CHECK_PLAN_NOT_EXISTS = new ErrorCode(1_040_302_000, "点检计划不存在"); diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryService.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryService.java new file mode 100644 index 0000000..6d5c7bc --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryService.java @@ -0,0 +1,62 @@ +package cn.iocoder.yudao.module.mes.service.dv.machinery; + +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachineryPageReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachinerySaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO; +import jakarta.validation.Valid; + +/** + * MES 设备台账 Service 接口 + * + * @author 芋道源码 + */ +public interface MesDvMachineryService { + + /** + * 创建设备 + * + * @param createReqVO 创建信息 + * @return 编号 + */ + Long createMachinery(@Valid MesDvMachinerySaveReqVO createReqVO); + + /** + * 更新设备 + * + * @param updateReqVO 更新信息 + */ + void updateMachinery(@Valid MesDvMachinerySaveReqVO updateReqVO); + + /** + * 删除设备 + * + * @param id 编号 + */ + void deleteMachinery(Long id); + + /** + * 获得设备 + * + * @param id 编号 + * @return 设备 + */ + MesDvMachineryDO getMachinery(Long id); + + /** + * 获得设备分页 + * + * @param pageReqVO 分页查询 + * @return 设备分页 + */ + PageResult getMachineryPage(MesDvMachineryPageReqVO pageReqVO); + + /** + * 获得指定设备类型下的设备数量 + * + * @param machineryTypeId 设备类型编号 + * @return 设备数量 + */ + Long getMachineryCountByMachineryTypeId(Long machineryTypeId); + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryServiceImpl.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryServiceImpl.java new file mode 100644 index 0000000..09996e8 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryServiceImpl.java @@ -0,0 +1,114 @@ +package cn.iocoder.yudao.module.mes.service.dv.machinery; + +import cn.hutool.core.util.ObjUtil; +import cn.iocoder.yudao.framework.common.pojo.PageResult; +import cn.iocoder.yudao.framework.common.util.object.BeanUtils; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachineryPageReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.MesDvMachinerySaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryDO; +import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper; +import cn.iocoder.yudao.module.mes.service.md.workstation.MesMdWorkshopService; +import jakarta.annotation.Resource; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; +import org.springframework.validation.annotation.Validated; + +import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception; +import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*; + +/** + * MES 设备台账 Service 实现类 + * + * @author 芋道源码 + */ +@Service +@Validated +public class MesDvMachineryServiceImpl implements MesDvMachineryService { + + @Resource + private MesDvMachineryMapper machineryMapper; + + @Resource + @Lazy // 延迟加载，避免循环依赖 + private MesDvMachineryTypeService machineryTypeService; + + @Resource + @Lazy + private MesMdWorkshopService workshopService; + + @Override + public Long createMachinery(MesDvMachinerySaveReqVO createReqVO) { + // 校验设备类型存在 + machineryTypeService.getMachineryType(createReqVO.getMachineryTypeId()); + // 校验车间存在 + workshopService.getWorkshop(createReqVO.getWorkshopId()); + // 校验编码唯一 + validateMachineryCodeUnique(null, createReqVO.getCode()); + + // 插入 + MesDvMachineryDO machinery = BeanUtils.toBean(createReqVO, MesDvMachineryDO.class); + machineryMapper.insert(machinery); + return machinery.getId(); + } + + @Override + public void updateMachinery(MesDvMachinerySaveReqVO updateReqVO) { + // 校验存在 + validateMachineryExists(updateReqVO.getId()); + // 校验设备类型存在 + machineryTypeService.getMachineryType(updateReqVO.getMachineryTypeId()); + // 校验车间存在 + workshopService.getWorkshop(updateReqVO.getWorkshopId()); + // 校验编码唯一 + validateMachineryCodeUnique(updateReqVO.getId(), updateReqVO.getCode()); + + // 更新 + MesDvMachineryDO updateObj = BeanUtils.toBean(updateReqVO, MesDvMachineryDO.class); + machineryMapper.updateById(updateObj); + } + + @Override + public void deleteMachinery(Long id) { + // 校验存在 + validateMachineryExists(id); + // TODO @芋艿：后续补充点检计划、保养记录、维修工单等引用校验 + + // 删除 + machineryMapper.deleteById(id); + } + + private void validateMachineryExists(Long id) { + if (machineryMapper.selectById(id) == null) { + throw exception(DV_MACHINERY_NOT_EXISTS); + } + } + + private void validateMachineryCodeUnique(Long id, String code) { + if (code == null) { + return; + } + MesDvMachineryDO machinery = machineryMapper.selectByCode(code); + if (machinery == null) { + return; + } + if (ObjUtil.notEqual(machinery.getId(), id)) { + throw exception(DV_MACHINERY_CODE_DUPLICATE); + } + } + + @Override + public MesDvMachineryDO getMachinery(Long id) { + return machineryMapper.selectById(id); + } + + @Override + public PageResult getMachineryPage(MesDvMachineryPageReqVO pageReqVO) { + return machineryMapper.selectPage(pageReqVO); + } + + @Override + public Long getMachineryCountByMachineryTypeId(Long machineryTypeId) { + return machineryMapper.selectCountByMachineryTypeId(machineryTypeId); + } + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeService.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeService.java new file mode 100644 index 0000000..0f63253 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeService.java @@ -0,0 +1,85 @@ +package cn.iocoder.yudao.module.mes.service.dv.machinery; + +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeListReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeSaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO; +import jakarta.validation.Valid; + +import java.util.Collection; +import java.util.List; +import java.util.Map; + +import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.convertMap; + +/** + * MES 设备类型 Service 接口 + * + * @author 芋道源码 + */ +public interface MesDvMachineryTypeService { + + /** + * 创建设备类型 + * + * @param createReqVO 创建信息 + * @return 编号 + */ + Long createMachineryType(@Valid MesDvMachineryTypeSaveReqVO createReqVO); + + /** + * 更新设备类型 + * + * @param updateReqVO 更新信息 + */ + void updateMachineryType(@Valid MesDvMachineryTypeSaveReqVO updateReqVO); + + /** + * 删除设备类型 + * + * @param id 编号 + */ + void deleteMachineryType(Long id); + + /** + * 获得设备类型 + * + * @param id 编号 + * @return 设备类型 + */ + MesDvMachineryTypeDO getMachineryType(Long id); + + /** + * 获得设备类型列表 + * + * @param listReqVO 列表查询 + * @return 设备类型列表 + */ + List getMachineryTypeList(MesDvMachineryTypeListReqVO listReqVO); + + /** + * 获得设备类型列表 + * + * @param ids 编号数组 + * @return 设备类型列表 + */ + List getMachineryTypeList(Collection ids); + + /** + * 获得设备类型 Map + * + * @param ids 编号数组 + * @return 设备类型 Map + */ + default Map getMachineryTypeMap(Collection ids) { + return convertMap(getMachineryTypeList(ids), MesDvMachineryTypeDO::getId); + } + + /** + * 获得指定父类型下的所有子类型（递归） + * + * @param parentId 父类型编号 + * @return 子类型列表 + */ + List getMachineryTypeChildrenList(Long parentId); + +} diff --git a/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeServiceImpl.java b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeServiceImpl.java new file mode 100644 index 0000000..9ae5eb2 --- /dev/null +++ b/yudao-module-mes/src/main/java/cn/iocoder/yudao/module/mes/service/dv/machinery/MesDvMachineryTypeServiceImpl.java @@ -0,0 +1,185 @@ +package cn.iocoder.yudao.module.mes.service.dv.machinery; + +import cn.hutool.core.collection.CollUtil; +import cn.hutool.core.util.ObjUtil; +import cn.iocoder.yudao.framework.common.util.object.BeanUtils; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeListReqVO; +import cn.iocoder.yudao.module.mes.controller.admin.dv.machinery.vo.type.MesDvMachineryTypeSaveReqVO; +import cn.iocoder.yudao.module.mes.dal.dataobject.dv.machinery.MesDvMachineryTypeDO; +import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryMapper; +import cn.iocoder.yudao.module.mes.dal.mysql.dv.machinery.MesDvMachineryTypeMapper; +import jakarta.annotation.Resource; +import org.springframework.context.annotation.Lazy; +import org.springframework.stereotype.Service; +import org.springframework.validation.annotation.Validated; + +import java.util.*; + +import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception; +import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*; + +/** + * MES 设备类型 Service 实现类 + * + * @author 芋道源码 + */ +@Service +@Validated +public class MesDvMachineryTypeServiceImpl implements MesDvMachineryTypeService { + + @Resource + private MesDvMachineryTypeMapper machineryTypeMapper; + + @Resource + @Lazy // 延迟加载，避免循环依赖 + private MesDvMachineryService machineryService; + + @Override + public Long createMachineryType(MesDvMachineryTypeSaveReqVO createReqVO) { + // 校验父类型编号的有效性 + validateParentMachineryType(null, createReqVO.getParentId()); + // 校验类型名称的唯一性 + validateMachineryTypeNameUnique(null, createReqVO.getParentId(), createReqVO.getName()); + // 校验类型编码的唯一性 + validateMachineryTypeCodeUnique(null, createReqVO.getParentId(), createReqVO.getCode()); + + // 插入 + MesDvMachineryTypeDO machineryType = BeanUtils.toBean(createReqVO, MesDvMachineryTypeDO.class); + machineryTypeMapper.insert(machineryType); + return machineryType.getId(); + } + + @Override + public void updateMachineryType(MesDvMachineryTypeSaveReqVO updateReqVO) { + // 校验存在 + validateMachineryTypeExists(updateReqVO.getId()); + // 校验父类型编号的有效性 + validateParentMachineryType(updateReqVO.getId(), updateReqVO.getParentId()); + // 校验类型名称的唯一性 + validateMachineryTypeNameUnique(updateReqVO.getId(), updateReqVO.getParentId(), updateReqVO.getName()); + // 校验类型编码的唯一性 + validateMachineryTypeCodeUnique(updateReqVO.getId(), updateReqVO.getParentId(), updateReqVO.getCode()); + + // 更新 + MesDvMachineryTypeDO updateObj = BeanUtils.toBean(updateReqVO, MesDvMachineryTypeDO.class); + machineryTypeMapper.updateById(updateObj); + } + + @Override + public void deleteMachineryType(Long id) { + // 1.1 校验存在 + validateMachineryTypeExists(id); + // 1.2 校验是否有子类型 + if (machineryTypeMapper.selectCountByParentId(id) > 0) { + throw exception(DV_MACHINERY_TYPE_EXITS_CHILDREN); + } + // 1.3 校验是否有设备 + if (machineryService.getMachineryCountByMachineryTypeId(id) > 0) { + throw exception(DV_MACHINERY_TYPE_HAS_MACHINERY); + } + + // 2. 删除 + machineryTypeMapper.deleteById(id); + } + + private void validateMachineryTypeExists(Long id) { + if (machineryTypeMapper.selectById(id) == null) { + throw exception(DV_MACHINERY_TYPE_NOT_EXISTS); + } + } + + private void validateParentMachineryType(Long id, Long parentId) { + if (parentId == null || MesDvMachineryTypeDO.PARENT_ID_ROOT.equals(parentId)) { + return; + } + // 1. 不能设置自己为父类型 + if (Objects.equals(id, parentId)) { + throw exception(DV_MACHINERY_TYPE_PARENT_ERROR); + } + // 2. 父类型不存在 + MesDvMachineryTypeDO parentType = machineryTypeMapper.selectById(parentId); + if (parentType == null) { + throw exception(DV_MACHINERY_TYPE_PARENT_NOT_EXITS); + } + // 3. 递归校验父类型，如果父类型是自己的子类型，则报错，避免形成环路 + if (id == null) { // id 为空，说明新增，不需要考虑环路 + return; + } + for (int i = 0; i < Short.MAX_VALUE; i++) { + // 3.1 校验环路 + parentId = parentType.getParentId(); + if (Objects.equals(id, parentId)) { + throw exception(DV_MACHINERY_TYPE_PARENT_IS_CHILD); + } + // 3.2 继续递归下一级父类型 + if (parentId == null || MesDvMachineryTypeDO.PARENT_ID_ROOT.equals(parentId)) { + break; + } + parentType = machineryTypeMapper.selectById(parentId); + if (parentType == null) { + break; + } + } + } + + private void validateMachineryTypeNameUnique(Long id, Long parentId, String name) { + MesDvMachineryTypeDO machineryType = machineryTypeMapper.selectByParentIdAndName(parentId, name); + if (machineryType == null) { + return; + } + if (ObjUtil.notEqual(machineryType.getId(), id)) { + throw exception(DV_MACHINERY_TYPE_NAME_DUPLICATE); + } + } + + private void validateMachineryTypeCodeUnique(Long id, Long parentId, String code) { + MesDvMachineryTypeDO machineryType = machineryTypeMapper.selectByParentIdAndCode(parentId, code); + if (machineryType == null) { + return; + } + if (ObjUtil.notEqual(machineryType.getId(), id)) { + throw exception(DV_MACHINERY_TYPE_CODE_DUPLICATE); + } + } + + @Override + public MesDvMachineryTypeDO getMachineryType(Long id) { + return machineryTypeMapper.selectById(id); + } + + @Override + public List getMachineryTypeList(MesDvMachineryTypeListReqVO listReqVO) { + return machineryTypeMapper.selectList(listReqVO); + } + + @Override + public List getMachineryTypeList(Collection ids) { + if (CollUtil.isEmpty(ids)) { + return Collections.emptyList(); + } + return machineryTypeMapper.selectByIds(ids); + } + + @Override + public List getMachineryTypeChildrenList(Long parentId) { + List allList = machineryTypeMapper.selectList(); // 类型总量小，全量查 + // 递归收集所有子类型 + List result = new ArrayList<>(); + collectMachineryTypeChildren(result, parentId, allList); + return result; + } + + /** + * 递归收集所有子类型 + */ + private void collectMachineryTypeChildren(List result, Long parentId, + List allList) { + for (MesDvMachineryTypeDO machineryType : allList) { + if (Objects.equals(machineryType.getParentId(), parentId)) { + result.add(machineryType); + collectMachineryTypeChildren(result, machineryType.getId(), allList); + } + } + } + +}