kkk-ops 2 months ago
commit fc267eaefa

@ -52,7 +52,8 @@ public interface ErrorCodeConstants {
ErrorCode CREATE_TDENGINE_FAILURE= new ErrorCode(1_003_000_000, "创建Tdengine子表失败");
ErrorCode RECIPE_NOT_EXISTS = new ErrorCode(1_003_000_000, "配方主不存在");
ErrorCode RECIPE_POINT_NOT_EXISTS = new ErrorCode(1_003_000_000, "配方点位配置表(配方与设备点位关联)不存在");
ErrorCode RECIPE_TYPE_NOT_EXISTS = new ErrorCode(1_003_000_000, "配方类型表(基础字典)不存在");
ErrorCode RECIPE_POINT_NOT_EXISTS = new ErrorCode(1_003_000_000, "手动配置参数表(绑定配方)不存在");
ErrorCode RECIPE_DEVICE_ATTRIBUTE_NOT_EXISTS = new ErrorCode(1_003_000_000, "配方配置(关联采集设备模型-点位管理)不存在");
}

@ -87,7 +87,6 @@ public class RecipeController {
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<RecipeDO> list = recipeService.getRecipePage(pageReqVO).getList();
PageResult<RecipeDO> pageResult = recipeService.getRecipePage(pageReqVO);
// 导出 Excel
ExcelUtils.write(response, "配方管理主.xls", "数据", RecipeRespVO.class,
BeanUtils.toBean(list, RecipeRespVO.class));

@ -15,25 +15,19 @@ import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_
@ToString(callSuper = true)
public class RecipePageReqVO extends PageParam {
@Schema(description = "配方名称", example = "赵六")
@Schema(description = "配方名称", example = "李四")
private String name;
@Schema(description = "配方编码")
private String recipeCode;
@Schema(description = "配方类型(关联配方类型表code", example = "2")
@Schema(description = "关联配方类型", example = "2")
private String recipeType;
@Schema(description = "关联产品名称", example = "李四")
@Schema(description = "关联产品名字", example = "赵六")
private String productName;
@Schema(description = "关联设备ID关联iot_device.id", example = "14725")
private Long machineId;
@Schema(description = "关联设备编码(冗余字段)")
private String machineCode;
@Schema(description = "关联设备名称(冗余字段)", example = "芋艿")
@Schema(description = "关联设备名字", example = "赵六")
private String machineName;
@Schema(description = "配方描述")
@ -49,7 +43,8 @@ public class RecipePageReqVO extends PageParam {
@Schema(description = "数据单位")
private String dataUnit;
@Schema(description = "id集合导出用多选导出时传逗号分隔的ID")
// 新增多选导出的ids字段逗号分隔的id字符串如"1,2,3"
@Schema(description = "多选导出ID集合逗号分隔", example = "1,2,3")
private String ids;
}

@ -12,36 +12,28 @@ import com.alibaba.excel.annotation.*;
@ExcelIgnoreUnannotated
public class RecipeRespVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "6587")
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "631")
// @ExcelProperty("主键ID")
private Long id;
@Schema(description = "配方名称", example = "赵六")
@Schema(description = "配方名称", example = "李四")
@ExcelProperty("配方名称")
private String name;
@Schema(description = "配方编码")
// @ExcelProperty("配方编码")
@ExcelProperty("配方编码")
private String recipeCode;
@Schema(description = "配方类型(关联配方类型表code", example = "2")
@ExcelProperty("配方类型(工序)")
@Schema(description = "关联配方类型", example = "2")
@ExcelProperty("配方类型")
private String recipeType;
@Schema(description = "关联产品名称", example = "李四")
// @ExcelProperty("关联产品名称")
@Schema(description = "关联产品名字", example = "赵六")
@ExcelProperty("关联产品")
private String productName;
@Schema(description = "关联设备ID关联iot_device.id", example = "14725")
// @ExcelProperty("关联设备ID关联iot_device.id")
private Long machineId;
@Schema(description = "关联设备编码(冗余字段)")
// @ExcelProperty("关联设备编码(冗余字段)")
private String machineCode;
@Schema(description = "关联设备名称(冗余字段)", example = "芋艿")
// @ExcelProperty("关联设备名称(冗余字段)")
@Schema(description = "关联设备名字", example = "赵六")
@ExcelProperty("关联设备")
private String machineName;
@Schema(description = "配方描述")

@ -9,28 +9,22 @@ import javax.validation.constraints.*;
@Data
public class RecipeSaveReqVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "6587")
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "631")
private Long id;
@Schema(description = "配方名称", example = "赵六")
@Schema(description = "配方名称", example = "李四")
private String name;
@Schema(description = "配方编码")
private String recipeCode;
@Schema(description = "配方类型(关联配方类型表code", example = "2")
@Schema(description = "关联配方类型", example = "2")
private String recipeType;
@Schema(description = "关联产品名称", example = "李四")
@Schema(description = "关联产品名字", example = "赵六")
private String productName;
@Schema(description = "关联设备ID关联iot_device.id", example = "14725")
private Long machineId;
@Schema(description = "关联设备编码(冗余字段)")
private String machineCode;
@Schema(description = "关联设备名称(冗余字段)", example = "芋艿")
@Schema(description = "关联设备名字", example = "赵六")
private String machineName;
@Schema(description = "配方描述")

@ -0,0 +1,95 @@
package cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo.*;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipedeviceattribute.RecipeDeviceAttributeDO;
import cn.iocoder.yudao.module.iot.service.recipedeviceattribute.RecipeDeviceAttributeService;
@Tag(name = "管理后台 - 配方配置(关联采集设备模型-点位管理)")
@RestController
@RequestMapping("/iot/recipe-device-attribute")
@Validated
public class RecipeDeviceAttributeController {
@Resource
private RecipeDeviceAttributeService recipeDeviceAttributeService;
@PostMapping("/create")
@Operation(summary = "创建配方配置(关联采集设备模型-点位管理)")
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:create')")
public CommonResult<Boolean> createRecipeDeviceAttribute(@Valid @RequestBody RecipeDeviceAttributeSaveReqVO createReqVO) {
return success(recipeDeviceAttributeService.createRecipeDeviceAttributeBatch(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新配方配置(关联采集设备模型-点位管理)")
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:update')")
public CommonResult<Boolean> updateRecipeDeviceAttribute(@Valid @RequestBody RecipeDeviceAttributeSaveReqVO updateReqVO) {
recipeDeviceAttributeService.updateRecipeDeviceAttribute(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除配方配置(关联采集设备模型-点位管理)")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:delete')")
public CommonResult<Boolean> deleteRecipeDeviceAttribute(@RequestParam("id") Long id) {
recipeDeviceAttributeService.deleteRecipeDeviceAttribute(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得配方配置(关联采集设备模型-点位管理)")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:query')")
public CommonResult<RecipeDeviceAttributeRespVO> getRecipeDeviceAttribute(@RequestParam("id") Long id) {
RecipeDeviceAttributeDO recipeDeviceAttribute = recipeDeviceAttributeService.getRecipeDeviceAttribute(id);
return success(BeanUtils.toBean(recipeDeviceAttribute, RecipeDeviceAttributeRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得配方配置(关联采集设备模型-点位管理)分页")
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:query')")
public CommonResult<PageResult<RecipeDeviceAttributeRespVO>> getRecipeDeviceAttributePage(@Valid RecipeDeviceAttributePageReqVO pageReqVO) {
PageResult<RecipeDeviceAttributeDO> pageResult = recipeDeviceAttributeService.getRecipeDeviceAttributePage(pageReqVO);
return success(BeanUtils.toBean(pageResult, RecipeDeviceAttributeRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出配方配置(关联采集设备模型-点位管理) Excel")
@PreAuthorize("@ss.hasPermission('iot:recipe-device-attribute:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportRecipeDeviceAttributeExcel(@Valid RecipeDeviceAttributePageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<RecipeDeviceAttributeDO> list = recipeDeviceAttributeService.getRecipeDeviceAttributePage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "配方配置(关联采集设备模型-点位管理).xls", "数据", RecipeDeviceAttributeRespVO.class,
BeanUtils.toBean(list, RecipeDeviceAttributeRespVO.class));
}
}

@ -0,0 +1,40 @@
package cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 配方配置(关联采集设备模型-点位管理)分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class RecipeDeviceAttributePageReqVO extends PageParam {
@Schema(description = "关联配方id", example = "1102")
private Long recipeId;
@Schema(description = "关联点位id", example = "21675")
private Long attributeId;
@Schema(description = "点位名字", example = "王五")
private String attributeName;
@Schema(description = "点位类型", example = "1")
private String attributeType;
@Schema(description = "数据类型", example = "2")
private String dataType;
@Schema(description = "单位")
private String dataUnit;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,47 @@
package cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 配方配置(关联采集设备模型-点位管理) Response VO")
@Data
@ExcelIgnoreUnannotated
public class RecipeDeviceAttributeRespVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1118")
@ExcelProperty("主键ID")
private Long id;
@Schema(description = "关联配方id", requiredMode = Schema.RequiredMode.REQUIRED, example = "1102")
@ExcelProperty("关联配方id")
private Long recipeId;
@Schema(description = "关联点位id", requiredMode = Schema.RequiredMode.REQUIRED, example = "21675")
@ExcelProperty("关联点位id")
private Long attributeId;
@Schema(description = "点位名字", example = "王五")
@ExcelProperty("点位名字")
private String attributeName;
@Schema(description = "点位类型", example = "1")
@ExcelProperty("点位类型")
private String attributeType;
@Schema(description = "数据类型", example = "2")
@ExcelProperty("数据类型")
private String dataType;
@Schema(description = "单位")
@ExcelProperty("单位")
private String dataUnit;
@Schema(description = "创建时间")
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,39 @@
package cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 配方配置(关联采集设备模型-点位管理)新增/修改 Request VO")
@Data
public class RecipeDeviceAttributeSaveReqVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "1118")
private Long id;
@Schema(description = "关联配方id", requiredMode = Schema.RequiredMode.REQUIRED, example = "1102")
// @NotNull(message = "关联配方id不能为空")
private Long recipeId;
@Schema(description = "关联点位id", requiredMode = Schema.RequiredMode.REQUIRED, example = "21675")
// @NotNull(message = "关联点位id不能为空")
private Long attributeId;
@Schema(description = "点位名字", example = "王五")
private String attributeName;
@Schema(description = "点位类型", example = "1")
private String attributeType;
@Schema(description = "数据类型", example = "2")
private String dataType;
@Schema(description = "单位")
private String dataUnit;
// 新增批量创建的属性ID集合
@Schema(description = "批量创建的属性ID集合", requiredMode = Schema.RequiredMode.REQUIRED)
private List<Long> ids;
}

@ -29,7 +29,7 @@ import cn.iocoder.yudao.module.iot.controller.admin.recipepoint.vo.*;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipepoint.RecipePointDO;
import cn.iocoder.yudao.module.iot.service.recipepoint.RecipePointService;
@Tag(name = "管理后台 - 配方点位配置表(配方与设备点位关联")
@Tag(name = "管理后台 - 手动配置参数表(绑定配方")
@RestController
@RequestMapping("/iot/recipe-point")
@Validated
@ -39,14 +39,14 @@ public class RecipePointController {
private RecipePointService recipePointService;
@PostMapping("/create")
@Operation(summary = "创建配方点位配置表(配方与设备点位关联")
@Operation(summary = "创建手动配置参数表(绑定配方")
@PreAuthorize("@ss.hasPermission('iot:recipe-point:create')")
public CommonResult<Long> createRecipePoint(@Valid @RequestBody RecipePointSaveReqVO createReqVO) {
return success(recipePointService.createRecipePoint(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新配方点位配置表(配方与设备点位关联")
@Operation(summary = "更新手动配置参数表(绑定配方")
@PreAuthorize("@ss.hasPermission('iot:recipe-point:update')")
public CommonResult<Boolean> updateRecipePoint(@Valid @RequestBody RecipePointSaveReqVO updateReqVO) {
recipePointService.updateRecipePoint(updateReqVO);
@ -54,7 +54,7 @@ public class RecipePointController {
}
@DeleteMapping("/delete")
@Operation(summary = "删除配方点位配置表(配方与设备点位关联")
@Operation(summary = "删除手动配置参数表(绑定配方")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('iot:recipe-point:delete')")
public CommonResult<Boolean> deleteRecipePoint(@RequestParam("id") Long id) {
@ -63,7 +63,7 @@ public class RecipePointController {
}
@GetMapping("/get")
@Operation(summary = "获得配方点位配置表(配方与设备点位关联")
@Operation(summary = "获得手动配置参数表(绑定配方")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('iot:recipe-point:query')")
public CommonResult<RecipePointRespVO> getRecipePoint(@RequestParam("id") Long id) {
@ -72,7 +72,7 @@ public class RecipePointController {
}
@GetMapping("/page")
@Operation(summary = "获得配方点位配置表(配方与设备点位关联)分页")
@Operation(summary = "获得手动配置参数表(绑定配方)分页")
@PreAuthorize("@ss.hasPermission('iot:recipe-point:query')")
public CommonResult<PageResult<RecipePointRespVO>> getRecipePointPage(@Valid RecipePointPageReqVO pageReqVO) {
PageResult<RecipePointDO> pageResult = recipePointService.getRecipePointPage(pageReqVO);
@ -80,7 +80,7 @@ public class RecipePointController {
}
@GetMapping("/export-excel")
@Operation(summary = "导出配方点位配置表(配方与设备点位关联 Excel")
@Operation(summary = "导出手动配置参数表(绑定配方 Excel")
@PreAuthorize("@ss.hasPermission('iot:recipe-point:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportRecipePointExcel(@Valid RecipePointPageReqVO pageReqVO,
@ -88,7 +88,7 @@ public class RecipePointController {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<RecipePointDO> list = recipePointService.getRecipePointPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "配方点位配置表(配方与设备点位关联.xls", "数据", RecipePointRespVO.class,
ExcelUtils.write(response, "手动配置参数表(绑定配方.xls", "数据", RecipePointRespVO.class,
BeanUtils.toBean(list, RecipePointRespVO.class));
}

@ -4,40 +4,38 @@ import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import java.math.BigDecimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 配方点位配置表(配方与设备点位关联)分页 Request VO")
@Schema(description = "管理后台 - 手动配置参数表(绑定配方)分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class RecipePointPageReqVO extends PageParam {
@Schema(description = "关联配方ID关联iot_recipe.id", example = "8760")
@Schema(description = "关联配方ID", example = "28516")
private Long recipeId;
@Schema(description = "点位编码关联iot_device_attribute_type.code")
private String pointCode;
@Schema(description = "参数名字", example = "李四")
private String name;
@Schema(description = "点位名称", example = "李四")
private String pointName;
@Schema(description = "上限")
private BigDecimal max;
@Schema(description = "点位类型", example = "1")
private String pointType;
@Schema(description = "下限")
private BigDecimal min;
@Schema(description = "数据类型Time、Number等", example = "1")
@Schema(description = "数据类型", example = "1")
private String dataType;
@Schema(description = "单位s、min等")
private String unit;
@Schema(description = "单位")
private String dataUnit;
@Schema(description = "设定值")
private String setValue;
@Schema(description = "实际值(从设备上载同步)")
private String actualValue;
@Schema(description = "备注", example = "你说的对")
private String remark;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)

@ -3,52 +3,49 @@ package cn.iocoder.yudao.module.iot.controller.admin.recipepoint.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import java.math.BigDecimal;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 配方点位配置表(配方与设备点位关联 Response VO")
@Schema(description = "管理后台 - 手动配置参数表(绑定配方 Response VO")
@Data
@ExcelIgnoreUnannotated
public class RecipePointRespVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "27323")
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "16742")
@ExcelProperty("主键ID")
private Long id;
@Schema(description = "关联配方ID关联iot_recipe.id", example = "8760")
@ExcelProperty("关联配方ID关联iot_recipe.id")
@Schema(description = "关联配方ID", example = "28516")
@ExcelProperty("关联配方ID")
private Long recipeId;
@Schema(description = "点位编码关联iot_device_attribute_type.code")
@ExcelProperty("点位编码关联iot_device_attribute_type.code")
private String pointCode;
@Schema(description = "参数名字", example = "李四")
@ExcelProperty("参数名字")
private String name;
@Schema(description = "点位名称", example = "李四")
@ExcelProperty("点位名称")
private String pointName;
@Schema(description = "上限")
@ExcelProperty("上限")
private BigDecimal max;
@Schema(description = "点位类型", example = "1")
@ExcelProperty("点位类型")
private String pointType;
@Schema(description = "下限")
@ExcelProperty("下限")
private BigDecimal min;
@Schema(description = "数据类型Time、Number等", example = "1")
@ExcelProperty("数据类型Time、Number等")
@Schema(description = "数据类型", example = "1")
@ExcelProperty("数据类型")
private String dataType;
@Schema(description = "单位s、min等")
@ExcelProperty("单位s、min等")
private String unit;
@Schema(description = "单位")
@ExcelProperty("单位")
private String dataUnit;
@Schema(description = "设定值")
@ExcelProperty("设定值")
private String setValue;
@Schema(description = "备注", example = "你说的对")
@ExcelProperty("备注")
private String remark;
@Schema(description = "实际值(从设备上载同步)")
@ExcelProperty("实际值(从设备上载同步)")
private String actualValue;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@Schema(description = "创建时间")
@ExcelProperty("创建时间")
private LocalDateTime createTime;

@ -4,36 +4,34 @@ import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import java.math.BigDecimal;
@Schema(description = "管理后台 - 配方点位配置表(配方与设备点位关联)新增/修改 Request VO")
@Schema(description = "管理后台 - 手动配置参数表(绑定配方)新增/修改 Request VO")
@Data
public class RecipePointSaveReqVO {
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "27323")
@Schema(description = "主键ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "16742")
private Long id;
@Schema(description = "关联配方ID关联iot_recipe.id", example = "8760")
@Schema(description = "关联配方ID", example = "28516")
private Long recipeId;
@Schema(description = "点位编码关联iot_device_attribute_type.code")
private String pointCode;
@Schema(description = "参数名字", example = "李四")
private String name;
@Schema(description = "点位名称", example = "李四")
private String pointName;
@Schema(description = "上限")
private BigDecimal max;
@Schema(description = "点位类型", example = "1")
private String pointType;
@Schema(description = "下限")
private BigDecimal min;
@Schema(description = "数据类型Time、Number等", example = "1")
@Schema(description = "数据类型", example = "1")
private String dataType;
@Schema(description = "单位s、min等")
private String unit;
@Schema(description = "单位")
private String dataUnit;
@Schema(description = "设定值")
private String setValue;
@Schema(description = "实际值(从设备上载同步)")
private String actualValue;
@Schema(description = "备注", example = "你说的对")
private String remark;
}

@ -79,6 +79,31 @@ public class RecipeTypeController {
return success(BeanUtils.toBean(pageResult, RecipeTypeRespVO.class));
}
@GetMapping("/page-all")
@Operation(summary = "获得配方类型表(不传分页参数查全部,传则分页)")
@PreAuthorize("@ss.hasPermission('iot:recipe-type:query')")
public CommonResult<PageResult<RecipeTypeRespVO>> getRecipeTypePageAll(
RecipeTypePageReqVO pageReqVO,
HttpServletRequest request) { // 注入request判断参数是否传了
// 核心优化判断前端是否真的传了pageNo/pageSize而非判断值避免前端传1/10时误判
boolean hasPageNo = request.getParameter("pageNo") != null;
boolean hasPageSize = request.getParameter("pageSize") != null;
boolean isQueryAll = !hasPageNo && !hasPageSize;
PageResult<RecipeTypeDO> pageResult;
if (isQueryAll) {
// 查全部逻辑
pageResult = recipeTypeService.getRecipeTypeAll(pageReqVO);
} else {
// 传了分页参数则手动校验(替代@Valid避免必填报错
// ValidatorUtil.validate(pageReqVO);
// 复用原有分页逻辑
pageResult = recipeTypeService.getRecipeTypePage(pageReqVO);
}
return success(BeanUtils.toBean(pageResult, RecipeTypeRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出配方类型表(基础字典) Excel")
@PreAuthorize("@ss.hasPermission('iot:recipe-type:export')")

@ -36,23 +36,15 @@ public class RecipeDO extends BaseDO {
*/
private String recipeCode;
/**
* code
*
*/
private String recipeType;
/**
*
*
*/
private String productName;
/**
* IDiot_device.id
*/
private Long machineId;
/**
*
*/
private String machineCode;
/**
*
*
*/
private String machineName;
/**

@ -0,0 +1,55 @@
package cn.iocoder.yudao.module.iot.dal.dataobject.recipedeviceattribute;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* - DO
*
* @author
*/
@TableName("iot_recipe_device_attribute")
@KeySequence("iot_recipe_device_attribute_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RecipeDeviceAttributeDO extends BaseDO {
/**
* ID
*/
@TableId
private Long id;
/**
* id
*/
private Long recipeId;
/**
* id
*/
private Long attributeId;
/**
*
*/
private String attributeName;
/**
*
*/
private String attributeType;
/**
*
*/
private String dataType;
/**
*
*/
private String dataUnit;
}

@ -2,13 +2,15 @@ package cn.iocoder.yudao.module.iot.dal.dataobject.recipepoint;
import lombok.*;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
* DO
*
* @author
*/
@ -28,36 +30,32 @@ public class RecipePointDO extends BaseDO {
@TableId
private Long id;
/**
* IDiot_recipe.id
* ID
*/
private Long recipeId;
/**
* iot_device_attribute_type.code
*
*/
private String pointCode;
private String name;
/**
*
*
*/
private String pointName;
private BigDecimal max;
/**
*
*
*/
private String pointType;
private BigDecimal min;
/**
* TimeNumber
*
*/
private String dataType;
/**
* smin
*
*/
private String unit;
private String dataUnit;
/**
*
*
*/
private String setValue;
/**
*
*/
private String actualValue;
private String remark;
}

@ -1,53 +1,17 @@
//package cn.iocoder.yudao.module.iot.dal.mysql.recipe;
//
//import java.util.*;
//
//import cn.iocoder.yudao.framework.common.pojo.PageResult;
//import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
//import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
//import cn.iocoder.yudao.module.iot.dal.dataobject.recipe.RecipeDO;
//import org.apache.ibatis.annotations.Mapper;
//import cn.iocoder.yudao.module.iot.controller.admin.recipe.vo.*;
//
///**
// * 配方管理主 Mapper
// *
// * @author 内蒙必硕
// */
//@Mapper
//public interface RecipeMapper extends BaseMapperX<RecipeDO> {
//
// default PageResult<RecipeDO> selectPage(RecipePageReqVO reqVO) {
// return selectPage(reqVO, new LambdaQueryWrapperX<RecipeDO>()
// .likeIfPresent(RecipeDO::getName, reqVO.getName())
// .eqIfPresent(RecipeDO::getRecipeCode, reqVO.getRecipeCode())
// .eqIfPresent(RecipeDO::getRecipeType, reqVO.getRecipeType())
// .likeIfPresent(RecipeDO::getProductName, reqVO.getProductName())
// .eqIfPresent(RecipeDO::getMachineId, reqVO.getMachineId())
// .eqIfPresent(RecipeDO::getMachineCode, reqVO.getMachineCode())
// .likeIfPresent(RecipeDO::getMachineName, reqVO.getMachineName())
// .eqIfPresent(RecipeDO::getRecipeDesc, reqVO.getRecipeDesc())
// .eqIfPresent(RecipeDO::getIsEnable, reqVO.getIsEnable())
// .betweenIfPresent(RecipeDO::getCreateTime, reqVO.getCreateTime())
// .eqIfPresent(RecipeDO::getDataUnit, reqVO.getDataUnit())
// .orderByDesc(RecipeDO::getId));
// }
//
//}
package cn.iocoder.yudao.module.iot.dal.mysql.recipe;
import java.util.*;
import java.util.stream.Collectors;
import com.alibaba.excel.util.StringUtils;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
//import cn.iocoder.yudao.framework.common.util.StringUtils;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipe.RecipeDO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.iot.controller.admin.recipe.vo.*;
import cn.iocoder.yudao.module.iot.controller.admin.recipe.vo.RecipePageReqVO;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* Mapper
*
@ -57,13 +21,13 @@ import java.util.stream.Collectors;
public interface RecipeMapper extends BaseMapperX<RecipeDO> {
default PageResult<RecipeDO> selectPage(RecipePageReqVO reqVO) {
// 1. 先创建查询条件对象
LambdaQueryWrapperX<RecipeDO> queryWrapper = new LambdaQueryWrapperX<RecipeDO>()
// 原有所有查询条件(保留不变)
.likeIfPresent(RecipeDO::getName, reqVO.getName())
.eqIfPresent(RecipeDO::getRecipeCode, reqVO.getRecipeCode())
.likeIfPresent(RecipeDO::getRecipeCode, reqVO.getRecipeCode())
.eqIfPresent(RecipeDO::getRecipeType, reqVO.getRecipeType())
.likeIfPresent(RecipeDO::getProductName, reqVO.getProductName())
.eqIfPresent(RecipeDO::getMachineId, reqVO.getMachineId())
.eqIfPresent(RecipeDO::getMachineCode, reqVO.getMachineCode())
.likeIfPresent(RecipeDO::getMachineName, reqVO.getMachineName())
.eqIfPresent(RecipeDO::getRecipeDesc, reqVO.getRecipeDesc())
.eqIfPresent(RecipeDO::getIsEnable, reqVO.getIsEnable())
@ -71,15 +35,18 @@ public interface RecipeMapper extends BaseMapperX<RecipeDO> {
.eqIfPresent(RecipeDO::getDataUnit, reqVO.getDataUnit())
.orderByDesc(RecipeDO::getId);
// 新增处理ids多选导出条件
// 2. 新增处理ids多选导出条件(和参考代码逻辑一致)
if (StringUtils.isNotBlank(reqVO.getIds())) {
// 将逗号分隔的ids字符串转为Long类型的List
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
.map(Long::valueOf)
.map(String::trim) // 去除空格,避免空字符导致转换失败
.map(Long::valueOf) // 转为Long类型
.collect(Collectors.toList());
// 添加idIn条件只查询指定ids的记录
queryWrapper.in(RecipeDO::getId, idList);
}
// 3. 执行分页查询
return selectPage(reqVO, queryWrapper);
}

@ -0,0 +1,32 @@
package cn.iocoder.yudao.module.iot.dal.mysql.recipedeviceattribute;
import java.util.*;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipedeviceattribute.RecipeDeviceAttributeDO;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo.*;
/**
* - Mapper
*
* @author
*/
@Mapper
public interface RecipeDeviceAttributeMapper extends BaseMapperX<RecipeDeviceAttributeDO> {
default PageResult<RecipeDeviceAttributeDO> selectPage(RecipeDeviceAttributePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<RecipeDeviceAttributeDO>()
.eqIfPresent(RecipeDeviceAttributeDO::getRecipeId, reqVO.getRecipeId())
.eqIfPresent(RecipeDeviceAttributeDO::getAttributeId, reqVO.getAttributeId())
.likeIfPresent(RecipeDeviceAttributeDO::getAttributeName, reqVO.getAttributeName())
.eqIfPresent(RecipeDeviceAttributeDO::getAttributeType, reqVO.getAttributeType())
.eqIfPresent(RecipeDeviceAttributeDO::getDataType, reqVO.getDataType())
.eqIfPresent(RecipeDeviceAttributeDO::getDataUnit, reqVO.getDataUnit())
.betweenIfPresent(RecipeDeviceAttributeDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(RecipeDeviceAttributeDO::getId));
}
}

@ -10,7 +10,7 @@ import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.iot.controller.admin.recipepoint.vo.*;
/**
* Mapper
* Mapper
*
* @author
*/
@ -20,13 +20,12 @@ public interface RecipePointMapper extends BaseMapperX<RecipePointDO> {
default PageResult<RecipePointDO> selectPage(RecipePointPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<RecipePointDO>()
.eqIfPresent(RecipePointDO::getRecipeId, reqVO.getRecipeId())
.eqIfPresent(RecipePointDO::getPointCode, reqVO.getPointCode())
.likeIfPresent(RecipePointDO::getPointName, reqVO.getPointName())
.eqIfPresent(RecipePointDO::getPointType, reqVO.getPointType())
.likeIfPresent(RecipePointDO::getName, reqVO.getName())
.eqIfPresent(RecipePointDO::getMax, reqVO.getMax())
.eqIfPresent(RecipePointDO::getMin, reqVO.getMin())
.eqIfPresent(RecipePointDO::getDataType, reqVO.getDataType())
.eqIfPresent(RecipePointDO::getUnit, reqVO.getUnit())
.eqIfPresent(RecipePointDO::getSetValue, reqVO.getSetValue())
.eqIfPresent(RecipePointDO::getActualValue, reqVO.getActualValue())
.eqIfPresent(RecipePointDO::getDataUnit, reqVO.getDataUnit())
.eqIfPresent(RecipePointDO::getRemark, reqVO.getRemark())
.betweenIfPresent(RecipePointDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(RecipePointDO::getId));
}

@ -19,12 +19,54 @@ import cn.iocoder.yudao.module.iot.controller.admin.recipetype.vo.*;
*
* @author
*/
//@Mapper
//public interface RecipeTypeMapper extends BaseMapperX<RecipeTypeDO> {
//
// default PageResult<RecipeTypeDO> selectPage(RecipeTypePageReqVO reqVO) {
// LambdaQueryWrapperX<RecipeTypeDO> queryWrapper = new LambdaQueryWrapperX<RecipeTypeDO>()
//// return selectPage(reqVO, new LambdaQueryWrapperX<RecipeTypeDO>()
// .eqIfPresent(RecipeTypeDO::getCode, reqVO.getCode())
// .likeIfPresent(RecipeTypeDO::getName, reqVO.getName())
// .eqIfPresent(RecipeTypeDO::getProcess, reqVO.getProcess())
// .eqIfPresent(RecipeTypeDO::getRemark, reqVO.getRemark())
// .eqIfPresent(RecipeTypeDO::getSort, reqVO.getSort())
// .betweenIfPresent(RecipeTypeDO::getCreateTime, reqVO.getCreateTime())
// .orderByDesc(RecipeTypeDO::getId);
//
// // 新增处理ids多选导出条件
// if (StringUtils.isNotBlank(reqVO.getIds())) {
// List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
// .map(String::trim)
// .map(Long::valueOf)
// .collect(Collectors.toList());
// queryWrapper.in(RecipeTypeDO::getId, idList);
// }
//
// return selectPage(reqVO, queryWrapper);
//
//
// }
//
//}
@Mapper
public interface RecipeTypeMapper extends BaseMapperX<RecipeTypeDO> {
// 原有selectPage方法保留不动
default PageResult<RecipeTypeDO> selectPage(RecipeTypePageReqVO reqVO) {
LambdaQueryWrapperX<RecipeTypeDO> queryWrapper = buildQueryWrapper(reqVO);
return selectPage(reqVO, queryWrapper);
}
// 新增selectList方法复用查询条件仅查全部列表解决Service报错
default List<RecipeTypeDO> selectList(RecipeTypePageReqVO reqVO) {
LambdaQueryWrapperX<RecipeTypeDO> queryWrapper = buildQueryWrapper(reqVO);
return selectList(queryWrapper); // 调用BaseMapperX的selectList方法
}
// 抽取通用查询条件构造方法(复用,避免代码重复)
default LambdaQueryWrapperX<RecipeTypeDO> buildQueryWrapper(RecipeTypePageReqVO reqVO) {
LambdaQueryWrapperX<RecipeTypeDO> queryWrapper = new LambdaQueryWrapperX<RecipeTypeDO>()
// return selectPage(reqVO, new LambdaQueryWrapperX<RecipeTypeDO>()
.eqIfPresent(RecipeTypeDO::getCode, reqVO.getCode())
.likeIfPresent(RecipeTypeDO::getName, reqVO.getName())
.eqIfPresent(RecipeTypeDO::getProcess, reqVO.getProcess())
@ -33,7 +75,7 @@ public interface RecipeTypeMapper extends BaseMapperX<RecipeTypeDO> {
.betweenIfPresent(RecipeTypeDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(RecipeTypeDO::getId);
// 新增:处理ids多选导出条件
// 处理ids多选导出条件(复用原有逻辑)
if (StringUtils.isNotBlank(reqVO.getIds())) {
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
@ -41,10 +83,7 @@ public interface RecipeTypeMapper extends BaseMapperX<RecipeTypeDO> {
.collect(Collectors.toList());
queryWrapper.in(RecipeTypeDO::getId, idList);
}
return selectPage(reqVO, queryWrapper);
return queryWrapper;
}
}

@ -71,5 +71,4 @@ public class RecipeServiceImpl implements RecipeService {
return recipeMapper.selectPage(pageReqVO);
}
}

@ -0,0 +1,57 @@
package cn.iocoder.yudao.module.iot.service.recipedeviceattribute;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo.*;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipedeviceattribute.RecipeDeviceAttributeDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* - Service
*
* @author
*/
public interface RecipeDeviceAttributeService {
/**
* -
*
* @param createReqVO
* @return
*/
// Long createRecipeDeviceAttribute(@Valid RecipeDeviceAttributeSaveReqVO createReqVO);
/**
* -
*
* @param updateReqVO
*/
void updateRecipeDeviceAttribute(@Valid RecipeDeviceAttributeSaveReqVO updateReqVO);
/**
* -
*
* @param id
*/
void deleteRecipeDeviceAttribute(Long id);
/**
* -
*
* @param id
* @return -
*/
RecipeDeviceAttributeDO getRecipeDeviceAttribute(Long id);
/**
* -
*
* @param pageReqVO
* @return -
*/
PageResult<RecipeDeviceAttributeDO> getRecipeDeviceAttributePage(RecipeDeviceAttributePageReqVO pageReqVO);
Boolean createRecipeDeviceAttributeBatch(RecipeDeviceAttributeSaveReqVO createReqVO);
}

@ -0,0 +1,110 @@
package cn.iocoder.yudao.module.iot.service.recipedeviceattribute;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import cn.iocoder.yudao.module.iot.controller.admin.recipedeviceattribute.vo.*;
import cn.iocoder.yudao.module.iot.dal.dataobject.recipedeviceattribute.RecipeDeviceAttributeDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.iot.dal.mysql.recipedeviceattribute.RecipeDeviceAttributeMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; // 或芋道的CollectionUtils
import java.util.List;
import java.util.stream.Collectors;
//import cn.iocoder.yudao.framework.common.util.bean.BeanUtils; // 确保BeanUtils的导入正确
/**
* - Service
*
* @author
*/
@Service
@Validated
public class RecipeDeviceAttributeServiceImpl implements RecipeDeviceAttributeService {
@Resource
private RecipeDeviceAttributeMapper recipeDeviceAttributeMapper;
// @Override
// public Long createRecipeDeviceAttribute(RecipeDeviceAttributeSaveReqVO createReqVO) {
// // 插入
// RecipeDeviceAttributeDO recipeDeviceAttribute = BeanUtils.toBean(createReqVO, RecipeDeviceAttributeDO.class);
// recipeDeviceAttributeMapper.insert(recipeDeviceAttribute);
// // 返回
// return recipeDeviceAttribute.getId();
// }
@Override
public Boolean createRecipeDeviceAttributeBatch(RecipeDeviceAttributeSaveReqVO createReqVO) {
// 1. 非空校验ids集合不能为空
if (CollectionUtils.isEmpty(createReqVO.getIds())) {
throw new IllegalArgumentException("批量创建失败属性ID集合ids不能为空");
}
// 2. 非空校验基础字段如recipe_id不能为空
if (createReqVO.getRecipeId() == null) {
throw new IllegalArgumentException("批量创建失败配方IDrecipeId不能为空");
}
List<RecipeDeviceAttributeDO> attributeList = createReqVO.getIds().stream()
.map(attributeId -> {
RecipeDeviceAttributeDO attributeDO = BeanUtils.toBean(createReqVO, RecipeDeviceAttributeDO.class);
attributeDO.setAttributeId(attributeId);
return attributeDO;
})
.collect(Collectors.toList());
// 4. 批量插入(调整接收类型)
Boolean insertSuccess = recipeDeviceAttributeMapper.insertBatch(attributeList);
// 5. 返回是否批量插入成功
return insertSuccess;
}
@Override
public void updateRecipeDeviceAttribute(RecipeDeviceAttributeSaveReqVO updateReqVO) {
// 校验存在
validateRecipeDeviceAttributeExists(updateReqVO.getId());
// 更新
RecipeDeviceAttributeDO updateObj = BeanUtils.toBean(updateReqVO, RecipeDeviceAttributeDO.class);
recipeDeviceAttributeMapper.updateById(updateObj);
}
@Override
public void deleteRecipeDeviceAttribute(Long id) {
// 校验存在
validateRecipeDeviceAttributeExists(id);
// 删除
recipeDeviceAttributeMapper.deleteById(id);
}
private void validateRecipeDeviceAttributeExists(Long id) {
if (recipeDeviceAttributeMapper.selectById(id) == null) {
throw exception(RECIPE_DEVICE_ATTRIBUTE_NOT_EXISTS);
}
}
@Override
public RecipeDeviceAttributeDO getRecipeDeviceAttribute(Long id) {
return recipeDeviceAttributeMapper.selectById(id);
}
@Override
public PageResult<RecipeDeviceAttributeDO> getRecipeDeviceAttributePage(RecipeDeviceAttributePageReqVO pageReqVO) {
return recipeDeviceAttributeMapper.selectPage(pageReqVO);
}
}

@ -8,14 +8,14 @@ import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* Service
* Service
*
* @author
*/
public interface RecipePointService {
/**
*
*
*
* @param createReqVO
* @return
@ -23,32 +23,32 @@ public interface RecipePointService {
Long createRecipePoint(@Valid RecipePointSaveReqVO createReqVO);
/**
*
*
*
* @param updateReqVO
*/
void updateRecipePoint(@Valid RecipePointSaveReqVO updateReqVO);
/**
*
*
*
* @param id
*/
void deleteRecipePoint(Long id);
/**
*
*
*
* @param id
* @return
* @return
*/
RecipePointDO getRecipePoint(Long id);
/**
*
*
*
* @param pageReqVO
* @return
* @return
*/
PageResult<RecipePointDO> getRecipePointPage(RecipePointPageReqVO pageReqVO);

@ -18,7 +18,7 @@ import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionU
import static cn.iocoder.yudao.module.iot.enums.ErrorCodeConstants.*;
/**
* Service
* Service
*
* @author
*/

@ -52,4 +52,14 @@ public interface RecipeTypeService {
*/
PageResult<RecipeTypeDO> getRecipeTypePage(RecipeTypePageReqVO pageReqVO);
/**
*
* @param pageReqVO
* @return
*/
PageResult<RecipeTypeDO> getRecipeTypeAll(RecipeTypePageReqVO pageReqVO);
}

@ -71,4 +71,12 @@ public class RecipeTypeServiceImpl implements RecipeTypeService {
return recipeTypeMapper.selectPage(pageReqVO);
}
@Override
public PageResult<RecipeTypeDO> getRecipeTypeAll(RecipeTypePageReqVO pageReqVO) {
// 调用Mapper查询全部数据复用原有分页的查询条件只是不分页
List<RecipeTypeDO> list = recipeTypeMapper.selectList(pageReqVO);
// 封装成PageResult返回总数=列表长度,保持返回格式和分页接口一致)
return new PageResult<>(list, (long) list.size());
}
}

@ -0,0 +1,12 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.iocoder.yudao.module.iot.dal.mysql.recipedeviceattribute.RecipeDeviceAttributeMapper">
<!--
一般情况下,尽可能使用 Mapper 进行 CRUD 增删改查即可。
无法满足的场景,例如说多表关联查询,才使用 XML 编写 SQL。
代码生成器暂时只生成 Mapper XML 文件本身,更多推荐 MybatisX 快速开发插件来生成查询。
文档可见https://www.iocoder.cn/MyBatis/x-plugins/
-->
</mapper>

@ -83,4 +83,21 @@ public interface ErrorCodeConstants {
ErrorCode ZJ_ITEM_NOT_EXISTS = new ErrorCode(5_0091, "检验项目不存在");
ErrorCode ZJ_SCHEMA_NOT_EXISTS = new ErrorCode(5_0092, "检验方案不存在");
ErrorCode ZJ_PRODUCT_NOT_EXISTS = new ErrorCode(5_0093, "检验参数不存在");
//======================================设备台账相关 1002000000=================================================
ErrorCode DEVICE_TYPE_NOT_EXISTS = new ErrorCode(1002000000, "设备类型不存在");
ErrorCode DEVICE_TYPE_PARENT_NOT_EXISTS = new ErrorCode(1002000001, "父级设备类型不存在");
ErrorCode DEVICE_TYPE_PARENT_IS_SELF = new ErrorCode(1002000002, "不能设置自己为父级");
ErrorCode DEVICE_TYPE_PARENT_IS_CHILD = new ErrorCode(1002000003, "不能设置子节点为父级");
ErrorCode DEVICE_TYPE_EXITS_CHILDREN = new ErrorCode(1002000004, "存在子设备类型,无法删除");
ErrorCode DEVICE_LEDGER_NOT_EXISTS = new ErrorCode(1002000005, "该设备不存在");
ErrorCode DEVICE_LEDGER_CODE_NOT_ONLY = new ErrorCode(1002000006, "设备类型编码已存在");
ErrorCode PLAN_MAINTENANCE_NOT_EXISTS = new ErrorCode(1002000007, "方案维护不存在");
ErrorCode SUBJECT_PLAN_NOT_EXISTS = new ErrorCode(1002000008, "项目方案关联不存在");
ErrorCode SUBJECT_ID_NOT_EXISTS = new ErrorCode(1002000009, "项目Id不存在");
ErrorCode DEVICE_LEDGER_EXISTS = new ErrorCode(1002000010, "设备台账编码已存在");
ErrorCode SUBJECT_EXISTS = new ErrorCode(1002000010, "项目编码已存在");
ErrorCode TASK_MANAGEMENT_NOT_EXISTS = new ErrorCode(1002000011, "设备类型不存在");
}

@ -0,0 +1,103 @@
package cn.iocoder.yudao.module.mes.controller.admin.deviceledger;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger.DeviceLedgerDO;
import cn.iocoder.yudao.module.mes.service.deviceledger.DeviceLedgerService;
@Tag(name = "管理后台 - 设备台账")
@RestController
@RequestMapping("/mes/device-ledger")
@Validated
public class DeviceLedgerController {
@Resource
private DeviceLedgerService deviceLedgerService;
@PostMapping("/create")
@Operation(summary = "创建设备台账")
@PreAuthorize("@ss.hasPermission('mes:device-ledger:create')")
public CommonResult<Long> createDeviceLedger(@Valid @RequestBody DeviceLedgerSaveReqVO createReqVO) {
return success(deviceLedgerService.createDeviceLedger(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新设备台账")
@PreAuthorize("@ss.hasPermission('mes:device-ledger:update')")
public CommonResult<Boolean> updateDeviceLedger(@Valid @RequestBody DeviceLedgerSaveReqVO updateReqVO) {
deviceLedgerService.updateDeviceLedger(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除设备台账")
@Parameter(name = "ids", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:device-ledger:delete')")
public CommonResult<Boolean> deleteDeviceLedger(@RequestParam("ids") String ids) {
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream(ids.split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
deviceLedgerService.deleteDeviceLedger(idList);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得设备台账")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:device-ledger:query')")
public CommonResult<DeviceLedgerRespVO> getDeviceLedger(@RequestParam("id") Long id) {
DeviceLedgerDO deviceLedger = deviceLedgerService.getDeviceLedger(id);
return success(BeanUtils.toBean(deviceLedger, DeviceLedgerRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得设备台账分页")
@PreAuthorize("@ss.hasPermission('mes:device-ledger:query')")
public CommonResult<PageResult<DeviceLedgerRespVO>> getDeviceLedgerPage(@Valid DeviceLedgerPageReqVO pageReqVO) {
PageResult<DeviceLedgerDO> pageResult = deviceLedgerService.getDeviceLedgerPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, DeviceLedgerRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出设备台账 Excel")
@PreAuthorize("@ss.hasPermission('mes:device-ledger:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportDeviceLedgerExcel(@Valid DeviceLedgerPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<DeviceLedgerDO> list = deviceLedgerService.getDeviceLedgerPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "设备台账.xls", "数据", DeviceLedgerRespVO.class,
BeanUtils.toBean(list, DeviceLedgerRespVO.class));
}
}

@ -0,0 +1,78 @@
package cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 设备类型分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class DeviceLedgerPageReqVO extends PageParam {
@Schema(description = "设备编号")
private String deviceCode;
@Schema(description = "设备名称", example = "赵六")
private String deviceName;
@Schema(description = "设备状态 (0-正常, 1-停用, 2-维修, 3-报废)", example = "2")
private Integer deviceStatus;
@Schema(description = "设备品牌")
private String deviceBrand;
@Schema(description = "设备型号")
private String deviceModel;
@Schema(description = "设备规格")
private String deviceSpec;
@Schema(description = "设备类型", example = "1")
private Long deviceType;
@Schema(description = "供应商")
private String supplier;
@Schema(description = "所属车间")
private String workshop;
@Schema(description = "所属系统组织")
private String systemOrg;
@Schema(description = "设备位置")
private String deviceLocation;
@Schema(description = "设备负责人")
private String deviceManager;
@Schema(description = "设备生产日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] productionDate;
@Schema(description = "设备入厂日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] factoryEntryDate;
@Schema(description = "设备备注", example = "随便")
private String deviceRemark;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "排序")
private Integer sort;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "id集合导出用")
private String ids;
}

@ -0,0 +1,91 @@
package cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 设备类型 Response VO")
@Data
@ExcelIgnoreUnannotated
public class DeviceLedgerRespVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "24467")
@ExcelProperty("id")
private Long id;
@Schema(description = "设备编号")
@ExcelProperty("设备编号")
private String deviceCode;
@Schema(description = "设备名称", example = "赵六")
@ExcelProperty("设备名称")
private String deviceName;
@Schema(description = "设备状态 (0-正常, 1-停用, 2-维修, 3-报废)", example = "2")
@ExcelProperty("设备状态 (0-正常, 1-停用, 2-维修, 3-报废)")
private Integer deviceStatus;
@Schema(description = "设备品牌")
@ExcelProperty("设备品牌")
private String deviceBrand;
@Schema(description = "设备型号")
@ExcelProperty("设备型号")
private String deviceModel;
@Schema(description = "设备规格")
@ExcelProperty("设备规格")
private String deviceSpec;
@Schema(description = "设备类型", example = "1")
@ExcelProperty("设备类型")
private String deviceType;
@Schema(description = "供应商")
@ExcelProperty("供应商")
private String supplier;
@Schema(description = "所属车间")
@ExcelProperty("所属车间")
private String workshop;
@Schema(description = "所属系统组织")
@ExcelProperty("所属系统组织")
private String systemOrg;
@Schema(description = "设备位置")
@ExcelProperty("设备位置")
private String deviceLocation;
@Schema(description = "设备负责人")
@ExcelProperty("设备负责人")
private String deviceManager;
@Schema(description = "设备生产日期")
@ExcelProperty("设备生产日期")
private LocalDateTime productionDate;
@Schema(description = "设备入厂日期")
@ExcelProperty("设备入厂日期")
private LocalDateTime factoryEntryDate;
@Schema(description = "设备备注", example = "随便")
@ExcelProperty("设备备注")
private String deviceRemark;
@Schema(description = "备注", example = "随便")
@ExcelProperty("备注")
private String remark;
@Schema(description = "排序")
@ExcelProperty("排序")
private Integer sort;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,68 @@
package cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 设备类型新增/修改 Request VO")
@Data
public class DeviceLedgerSaveReqVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "24467")
private Long id;
@Schema(description = "设备编号")
private String deviceCode;
@Schema(description = "设备名称", example = "赵六")
private String deviceName;
@Schema(description = "设备状态 (0-正常, 1-停用, 2-维修, 3-报废)", example = "2")
private Integer deviceStatus;
@Schema(description = "设备品牌")
private String deviceBrand;
@Schema(description = "设备型号")
private String deviceModel;
@Schema(description = "设备规格")
private String deviceSpec;
@Schema(description = "设备类型", example = "1")
private String deviceType;
@Schema(description = "供应商")
private String supplier;
@Schema(description = "所属车间")
private String workshop;
@Schema(description = "所属系统组织")
private String systemOrg;
@Schema(description = "设备位置")
private String deviceLocation;
@Schema(description = "设备负责人")
private String deviceManager;
@Schema(description = "设备生产日期")
private LocalDateTime productionDate;
@Schema(description = "设备入厂日期")
private LocalDateTime factoryEntryDate;
@Schema(description = "设备备注", example = "随便")
private String deviceRemark;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "排序")
private Integer sort;
}

@ -0,0 +1,137 @@
package cn.iocoder.yudao.module.mes.controller.admin.devicetype;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.DeviceTypeTreeRespVO;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import cn.iocoder.yudao.module.mes.service.devicetype.DeviceTypeService;
@Tag(name = "管理后台 - 设备类型")
@RestController
@RequestMapping("/mes/device-type")
@Validated
public class DeviceTypeController {
@Resource
private DeviceTypeService deviceTypeService;
@PostMapping("/create")
@Operation(summary = "创建设备类型")
@PreAuthorize("@ss.hasPermission('mes:device-type:create')")
public CommonResult<Long> createDeviceType(@Valid @RequestBody DeviceTypeSaveReqVO createReqVO) {
return success(deviceTypeService.createDeviceType(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新设备类型")
@PreAuthorize("@ss.hasPermission('mes:device-type:update')")
public CommonResult<Boolean> updateDeviceType(@Valid @RequestBody DeviceTypeSaveReqVO updateReqVO) {
deviceTypeService.updateDeviceType(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除设备类型")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:device-type:delete')")
public CommonResult<Boolean> deleteDeviceType(@RequestParam("id") Long id) {
deviceTypeService.deleteDeviceType(id);
return success(true);
}
@DeleteMapping("/delete-batch")
@Operation(summary = "批量删除设备类型")
@PreAuthorize("@ss.hasPermission('mes:device-type:delete')")
public CommonResult<Boolean> deleteDeviceTypeBatch(@RequestParam("ids") List<Long> ids) {
deviceTypeService.deleteDeviceTypeBatch(ids);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得设备类型")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<DeviceTypeRespVO> getDeviceType(@RequestParam("id") Long id) {
DeviceTypeDO deviceType = deviceTypeService.getDeviceType(id);
return success(BeanUtils.toBean(deviceType, DeviceTypeRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得设备类型分页")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<PageResult<DeviceTypeRespVO>> getDeviceTypePage(@Valid DeviceTypePageReqVO pageReqVO) {
PageResult<DeviceTypeDO> pageResult = deviceTypeService.getDeviceTypePage(pageReqVO);
return success(BeanUtils.toBean(pageResult, DeviceTypeRespVO.class));
}
@GetMapping("/list")
@Operation(summary = "获得设备类型列表")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<List<DeviceTypeRespVO>> getDeviceTypeList(@Valid DeviceTypeListReqVO listReqVO) {
List<DeviceTypeDO> list = deviceTypeService.getDeviceTypeList(listReqVO);
return success(BeanUtils.toBean(list, DeviceTypeRespVO.class));
}
@GetMapping("/tree")
@Operation(summary = "获得设备类型树")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<List<DeviceTypeTreeRespVO>> getDeviceTypeTree(@Valid DeviceTypeListReqVO pageReqVO) {
List<DeviceTypeTreeRespVO> tree = deviceTypeService.getDeviceTypeTree(pageReqVO);
return success(tree);
}
@GetMapping("/children")
@Operation(summary = "获得子设备类型列表")
@Parameter(name = "parentId", description = "父级ID", required = true, example = "0")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<List<DeviceTypeRespVO>> getChildrenDeviceTypes(@RequestParam("parentId") Long parentId) {
List<DeviceTypeDO> list = deviceTypeService.getChildrenDeviceTypes(parentId);
return success(BeanUtils.toBean(list, DeviceTypeRespVO.class));
}
@GetMapping("/ancestors")
@Operation(summary = "获得祖先设备类型列表")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:device-type:query')")
public CommonResult<List<DeviceTypeRespVO>> getAncestorDeviceTypes(@RequestParam("id") Long id) {
List<DeviceTypeDO> list = deviceTypeService.getAncestorDeviceTypes(id);
return success(BeanUtils.toBean(list, DeviceTypeRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出设备类型 Excel")
@PreAuthorize("@ss.hasPermission('mes:device-type:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportDeviceTypeExcel(@Valid DeviceTypePageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<DeviceTypeDO> list = deviceTypeService.getDeviceTypePage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "设备类型.xls", "数据", DeviceTypeRespVO.class,
BeanUtils.toBean(list, DeviceTypeRespVO.class));
}
}

@ -0,0 +1,32 @@
// DeviceTypeListReqVO.java
package cn.iocoder.yudao.module.mes.controller.admin.devicetype.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;
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Schema(description = "管理后台 - 设备类型列表 Request VO")
public class DeviceTypeListReqVO extends PageParam {
@Schema(description = "父级ID")
private Long parentId;
@Schema(description = "父级链")
private String parentChain;
@Schema(description = "编码")
private String code;
@Schema(description = "名称")
private String name;
@Schema(description = "开始创建时间")
private String createStartTime;
@Schema(description = "结束创建时间")
private String createEndTime;
}

@ -0,0 +1,40 @@
package cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 设备类型分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class DeviceTypePageReqVO extends PageParam {
@Schema(description = "编码")
private String code;
@Schema(description = "名称", example = "赵六")
private String name;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "排序")
private Integer sort;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "排序")
private Long parentId;
@Schema(description = "排序")
private String parentChain;
}

@ -0,0 +1,45 @@
package cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 设备类型 Response VO")
@Data
@ExcelIgnoreUnannotated
public class DeviceTypeRespVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "3230")
@ExcelProperty("id")
private Long id;
@Schema(description = "编码", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("编码")
private String code;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "赵六")
@ExcelProperty("名称")
private String name;
@Schema(description = "备注", example = "随便")
@ExcelProperty("备注")
private String remark;
@Schema(description = "排序")
@ExcelProperty("排序")
private Integer sort;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
private Long parentId;
/** */
private String parentChain;
}

@ -0,0 +1,36 @@
package cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 设备类型新增/修改 Request VO")
@Data
public class DeviceTypeSaveReqVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "3230")
private Long id;
@Schema(description = "编码", requiredMode = Schema.RequiredMode.REQUIRED)
@NotEmpty(message = "编码不能为空")
private String code;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "赵六")
@NotEmpty(message = "名称不能为空")
private String name;
@Schema(description = "备注", example = "随便")
private String remark;
@Schema(description = "排序")
private Integer sort;
@NotNull(message = "parentId参数不存在")
private Long parentId;
private String parentChain;
}

@ -0,0 +1,20 @@
package cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
@Data
@EqualsAndHashCode(callSuper = true)
@Schema(description = "管理后台 - 设备类型树形结构 Response VO")
public class DeviceTypeTreeRespVO extends DeviceTypeRespVO {
@Schema(description = "子设备类型列表")
private List<DeviceTypeTreeRespVO> children;
@Schema(description = "是否叶子节点", example = "true")
private Boolean leaf = true;
}

@ -22,7 +22,9 @@ import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.validation.Valid;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
@ -53,10 +55,17 @@ public class DvSubjectController {
@DeleteMapping("/delete")
@Operation(summary = "删除维保项目")
@Parameter(name = "id", description = "编号", required = true)
@Parameter(name = "ids", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:dv-subject:delete')")
public CommonResult<Boolean> deleteDvSubject(@RequestParam("id") Long id) {
dvSubjectService.deleteDvSubject(id);
public CommonResult<Boolean> deleteDvSubject(@RequestParam("ids") String ids) {
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream(ids.split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
dvSubjectService.deleteDvSubject(idList);
return success(true);
}

@ -1,5 +1,6 @@
package cn.iocoder.yudao.module.mes.controller.admin.dvsubject.vo;
import com.alibaba.excel.annotation.ExcelProperty;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
@ -37,4 +38,15 @@ public class DvSubjectPageReqVO extends PageParam {
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "检验方式")
private String inspectionMethod;
@Schema(description = "值类型")
private String valueType;
@Schema(description = "判定基准")
private String judgmentCriteria;
@Schema(description = "id集合导出用")
private String ids;
}

@ -28,15 +28,15 @@ public class DvSubjectRespVO {
private String subjectName;
@Schema(description = "项目类型", example = "2")
@ExcelProperty("项目类型")
// @ExcelProperty("项目类型")
private String subjectType;
@Schema(description = "项目内容", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("项目内容")
// @ExcelProperty("项目内容")
private String subjectContent;
@Schema(description = "标准")
@ExcelProperty("标准")
// @ExcelProperty("标准")
private String subjectStandard;
@Schema(description = "是否启用", requiredMode = Schema.RequiredMode.REQUIRED)
@ -48,4 +48,16 @@ public class DvSubjectRespVO {
@ExcelProperty("创建时间")
private LocalDateTime createTime;
@Schema(description = "检验方式")
@ExcelProperty("检验方式")
private String inspectionMethod;
@Schema(description = "值类型")
@ExcelProperty("值类型")
private String valueType;
@Schema(description = "判定基准")
@ExcelProperty("判定基准")
private String judgmentCriteria;
}

@ -35,4 +35,5 @@ public class DvSubjectSaveReqVO {
@NotNull(message = "是否启用不能为空")
private Boolean isEnable;
}

@ -0,0 +1,112 @@
package cn.iocoder.yudao.module.mes.controller.admin.planmaintenance;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance.PlanMaintenanceDO;
import cn.iocoder.yudao.module.mes.service.planmaintenance.PlanMaintenanceService;
@Tag(name = "管理后台 - 方案维护")
@RestController
@RequestMapping("/mes/plan-maintenance")
@Validated
public class PlanMaintenanceController {
@Resource
private PlanMaintenanceService planMaintenanceService;
@PostMapping("/create")
@Operation(summary = "创建方案维护")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:create')")
public CommonResult<Long> createPlanMaintenance(@Valid @RequestBody PlanMaintenanceSaveReqVO createReqVO) {
return success(planMaintenanceService.createPlanMaintenance(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新方案维护")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:update')")
public CommonResult<Boolean> updatePlanMaintenance(@Valid @RequestBody PlanMaintenanceSaveReqVO updateReqVO) {
planMaintenanceService.updatePlanMaintenance(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除方案维护")
@Parameter(name = "ids", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:delete')")
public CommonResult<Boolean> deletePlanMaintenance(@RequestParam("ids") String ids) {
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream(ids.split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
planMaintenanceService.deletePlanMaintenance(idList);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得方案维护")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:query')")
public CommonResult<PlanMaintenanceRespVO> getPlanMaintenance(@RequestParam("id") Long id) {
PlanMaintenanceDO planMaintenance = planMaintenanceService.getPlanMaintenance(id);
return success(BeanUtils.toBean(planMaintenance, PlanMaintenanceRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得方案维护分页")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:query')")
public CommonResult<PageResult<PlanMaintenanceRespVO>> getPlanMaintenancePage(@Valid PlanMaintenancePageReqVO pageReqVO) {
PageResult<PlanMaintenanceDO> pageResult = planMaintenanceService.getPlanMaintenancePage(pageReqVO);
return success(BeanUtils.toBean(pageResult, PlanMaintenanceRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出方案维护 Excel")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportPlanMaintenanceExcel(@Valid PlanMaintenancePageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<PlanMaintenanceDO> list = planMaintenanceService.getPlanMaintenancePage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "方案维护.xls", "数据", PlanMaintenanceRespVO.class,
BeanUtils.toBean(list, PlanMaintenanceRespVO.class));
}
@GetMapping("/getSubjectList")
@Operation(summary = "查询项目集合列表")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:plan-maintenance:query')")
public CommonResult<List<SubjectPlanDO>> getSubjectList(@RequestParam("id") Long id) {
List<SubjectPlanDO> subjectPlanDOList = planMaintenanceService.getSubjectList(id);
return success(subjectPlanDOList);
}
}

@ -0,0 +1,34 @@
package cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 方案维护分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class PlanMaintenancePageReqVO extends PageParam {
@Schema(description = "名称", example = "王五")
private String planName;
@Schema(description = "名称", example = "1")
private String planType;
@Schema(description = "描述", example = "你猜")
private String description;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "id集合导出用")
private String ids;
}

@ -0,0 +1,35 @@
package cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 方案维护 Response VO")
@Data
@ExcelIgnoreUnannotated
public class PlanMaintenanceRespVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "19033")
@ExcelProperty("id")
private Long id;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "王五")
@ExcelProperty("名称")
private String planName;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@ExcelProperty("名称")
private String planType;
@Schema(description = "描述", example = "你猜")
@ExcelProperty("描述")
private String description;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,28 @@
package cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 方案维护新增/修改 Request VO")
@Data
public class PlanMaintenanceSaveReqVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "19033")
private Long id;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "王五")
@NotEmpty(message = "名称不能为空")
private String planName;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "1")
@NotEmpty(message = "名称不能为空")
private String planType;
@Schema(description = "描述")
private String description;
@Schema(description = "项目id集合", example = "1")
private String subjectIdS;
}

@ -0,0 +1,95 @@
package cn.iocoder.yudao.module.mes.controller.admin.subjectplan;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import cn.iocoder.yudao.module.mes.service.subjectplan.SubjectPlanService;
@Tag(name = "管理后台 - 项目方案关联")
@RestController
@RequestMapping("/mes/subject-plan")
@Validated
public class SubjectPlanController {
@Resource
private SubjectPlanService subjectPlanService;
@PostMapping("/create")
@Operation(summary = "创建项目方案关联")
@PreAuthorize("@ss.hasPermission('mes:subject-plan:create')")
public CommonResult<Long> createSubjectPlan(@Valid @RequestBody SubjectPlanSaveReqVO createReqVO) {
return success(subjectPlanService.createSubjectPlan(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新项目方案关联")
@PreAuthorize("@ss.hasPermission('mes:subject-plan:update')")
public CommonResult<Boolean> updateSubjectPlan(@Valid @RequestBody SubjectPlanSaveReqVO updateReqVO) {
subjectPlanService.updateSubjectPlan(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除项目方案关联")
@Parameter(name = "id", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:subject-plan:delete')")
public CommonResult<Boolean> deleteSubjectPlan(@RequestParam("id") Long id) {
subjectPlanService.deleteSubjectPlan(id);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得项目方案关联")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:subject-plan:query')")
public CommonResult<SubjectPlanRespVO> getSubjectPlan(@RequestParam("id") Long id) {
SubjectPlanDO subjectPlan = subjectPlanService.getSubjectPlan(id);
return success(BeanUtils.toBean(subjectPlan, SubjectPlanRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得项目方案关联分页")
@PreAuthorize("@ss.hasPermission('mes:subject-plan:query')")
public CommonResult<PageResult<SubjectPlanRespVO>> getSubjectPlanPage(@Valid SubjectPlanPageReqVO pageReqVO) {
PageResult<SubjectPlanDO> pageResult = subjectPlanService.getSubjectPlanPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, SubjectPlanRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出项目方案关联 Excel")
@PreAuthorize("@ss.hasPermission('mes:subject-plan:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportSubjectPlanExcel(@Valid SubjectPlanPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<SubjectPlanDO> list = subjectPlanService.getSubjectPlanPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "项目方案关联.xls", "数据", SubjectPlanRespVO.class,
BeanUtils.toBean(list, SubjectPlanRespVO.class));
}
}

@ -0,0 +1,28 @@
package cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 项目方案关联分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class SubjectPlanPageReqVO extends PageParam {
@Schema(description = "项目ID", example = "21197")
private String subjectId;
@Schema(description = "方案ID", example = "19398")
private String planId;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
}

@ -0,0 +1,31 @@
package cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 项目方案关联 Response VO")
@Data
@ExcelIgnoreUnannotated
public class SubjectPlanRespVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "29831")
@ExcelProperty("id")
private Long id;
@Schema(description = "项目ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "21197")
@ExcelProperty("项目ID")
private String subjectId;
@Schema(description = "方案ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "19398")
@ExcelProperty("方案ID")
private String planId;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,23 @@
package cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
@Schema(description = "管理后台 - 项目方案关联新增/修改 Request VO")
@Data
public class SubjectPlanSaveReqVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "29831")
private Long id;
@Schema(description = "项目ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "21197")
@NotEmpty(message = "项目ID不能为空")
private String subjectId;
@Schema(description = "方案ID", requiredMode = Schema.RequiredMode.REQUIRED, example = "19398")
@NotEmpty(message = "方案ID不能为空")
private String planId;
}

@ -0,0 +1,101 @@
package cn.iocoder.yudao.module.mes.controller.admin.taskmanagement;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.security.access.prepost.PreAuthorize;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import javax.validation.constraints.*;
import javax.validation.*;
import javax.servlet.http.*;
import java.util.*;
import java.io.IOException;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.*;
import cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.taskmanagement.TaskManagementDO;
import cn.iocoder.yudao.module.mes.service.taskmanagement.TaskManagementService;
@Tag(name = "管理后台 - 任务管理")
@RestController
@RequestMapping("/mes/task-management")
@Validated
public class TaskManagementController {
@Resource
private TaskManagementService taskManagementService;
@PostMapping("/create")
@Operation(summary = "创建任务管理")
@PreAuthorize("@ss.hasPermission('mes:task-management:create')")
public CommonResult<Long> createTaskManagement(@Valid @RequestBody TaskManagementSaveReqVO createReqVO) {
return success(taskManagementService.createTaskManagement(createReqVO));
}
@PutMapping("/update")
@Operation(summary = "更新任务管理")
@PreAuthorize("@ss.hasPermission('mes:task-management:update')")
public CommonResult<Boolean> updateTaskManagement(@Valid @RequestBody TaskManagementSaveReqVO updateReqVO) {
taskManagementService.updateTaskManagement(updateReqVO);
return success(true);
}
@DeleteMapping("/delete")
@Operation(summary = "删除任务管理")
@Parameter(name = "ids", description = "编号", required = true)
@PreAuthorize("@ss.hasPermission('mes:task-management:delete')")
public CommonResult<Boolean> deleteTaskManagement(@RequestParam("ids") String ids) {
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream(ids.split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
taskManagementService.deleteTaskManagement(idList);
return success(true);
}
@GetMapping("/get")
@Operation(summary = "获得任务管理")
@Parameter(name = "id", description = "编号", required = true, example = "1024")
@PreAuthorize("@ss.hasPermission('mes:task-management:query')")
public CommonResult<TaskManagementRespVO> getTaskManagement(@RequestParam("id") Long id) {
TaskManagementDO taskManagement = taskManagementService.getTaskManagement(id);
return success(BeanUtils.toBean(taskManagement, TaskManagementRespVO.class));
}
@GetMapping("/page")
@Operation(summary = "获得任务管理分页")
@PreAuthorize("@ss.hasPermission('mes:task-management:query')")
public CommonResult<PageResult<TaskManagementRespVO>> getTaskManagementPage(@Valid TaskManagementPageReqVO pageReqVO) {
PageResult<TaskManagementDO> pageResult = taskManagementService.getTaskManagementPage(pageReqVO);
return success(BeanUtils.toBean(pageResult, TaskManagementRespVO.class));
}
@GetMapping("/export-excel")
@Operation(summary = "导出任务管理 Excel")
@PreAuthorize("@ss.hasPermission('mes:task-management:export')")
@ApiAccessLog(operateType = EXPORT)
public void exportTaskManagementExcel(@Valid TaskManagementPageReqVO pageReqVO,
HttpServletResponse response) throws IOException {
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
List<TaskManagementDO> list = taskManagementService.getTaskManagementPage(pageReqVO).getList();
// 导出 Excel
ExcelUtils.write(response, "设备类型.xls", "数据", TaskManagementRespVO.class,
BeanUtils.toBean(list, TaskManagementRespVO.class));
}
}

@ -0,0 +1,54 @@
package cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo;
import lombok.*;
import java.util.*;
import io.swagger.v3.oas.annotations.media.Schema;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import static cn.iocoder.yudao.framework.common.util.date.DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND;
@Schema(description = "管理后台 - 设备类型分页 Request VO")
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
public class TaskManagementPageReqVO extends PageParam {
@Schema(description = "名称", example = "李四")
private String name;
@Schema(description = "类型(1-点检 2-保养)", example = "2")
private Integer taskType;
@Schema(description = "设备列表")
private String deviceList;
@Schema(description = "项目表单")
private Long projectForm;
@Schema(description = "起止开始日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] startDate;
@Schema(description = "起止结束日期")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] endDate;
@Schema(description = "cron表达式")
private String cronExpression;
@Schema(description = "可操作人")
private String operableUsers;
@Schema(description = "是否启用")
private Boolean enabled;
@Schema(description = "创建时间")
@DateTimeFormat(pattern = FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)
private LocalDateTime[] createTime;
@Schema(description = "id集合导出用")
private String ids;
}

@ -0,0 +1,59 @@
package cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
import com.alibaba.excel.annotation.*;
@Schema(description = "管理后台 - 设备类型 Response VO")
@Data
@ExcelIgnoreUnannotated
public class TaskManagementRespVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "26348")
@ExcelProperty("id")
private Long id;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "李四")
@ExcelProperty("名称")
private String name;
@Schema(description = "类型(1-点检 2-保养)", example = "2")
@ExcelProperty("类型(1-点检 2-保养)")
private Integer taskType;
@Schema(description = "设备列表")
@ExcelProperty("设备列表")
private String deviceList;
@Schema(description = "项目表单")
@ExcelProperty("项目表单")
private Long projectForm;
@Schema(description = "起止开始日期")
@ExcelProperty("起止开始日期")
private LocalDateTime startDate;
@Schema(description = "起止结束日期")
@ExcelProperty("起止结束日期")
private LocalDateTime endDate;
@Schema(description = "cron表达式")
@ExcelProperty("cron表达式")
private String cronExpression;
@Schema(description = "可操作人")
@ExcelProperty("可操作人")
private String operableUsers;
@Schema(description = "是否启用", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("是否启用")
private Boolean enabled;
@Schema(description = "创建时间", requiredMode = Schema.RequiredMode.REQUIRED)
@ExcelProperty("创建时间")
private LocalDateTime createTime;
}

@ -0,0 +1,46 @@
package cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.*;
import java.util.*;
import javax.validation.constraints.*;
import org.springframework.format.annotation.DateTimeFormat;
import java.time.LocalDateTime;
@Schema(description = "管理后台 - 设备类型新增/修改 Request VO")
@Data
public class TaskManagementSaveReqVO {
@Schema(description = "id", requiredMode = Schema.RequiredMode.REQUIRED, example = "26348")
private Long id;
@Schema(description = "名称", requiredMode = Schema.RequiredMode.REQUIRED, example = "李四")
@NotEmpty(message = "名称不能为空")
private String name;
@Schema(description = "类型(1-点检 2-保养)", example = "2")
private Integer taskType;
@Schema(description = "设备列表")
private String deviceList;
@Schema(description = "项目表单")
private Long projectForm;
@Schema(description = "起止开始日期")
private LocalDateTime startDate;
@Schema(description = "起止结束日期")
private LocalDateTime endDate;
@Schema(description = "cron表达式")
private String cronExpression;
@Schema(description = "可操作人")
private String operableUsers;
@Schema(description = "是否启用", requiredMode = Schema.RequiredMode.REQUIRED)
@NotNull(message = "是否启用不能为空")
private Boolean enabled;
}

@ -0,0 +1,101 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("mes_device_ledger")
@KeySequence("mes_device_ledger_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DeviceLedgerDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
*
*/
private String deviceCode;
/**
*
*/
private String deviceName;
/**
* (0-, 1-, 2-, 3-)
*/
private Integer deviceStatus;
/**
*
*/
private String deviceBrand;
/**
*
*/
private String deviceModel;
/**
*
*/
private String deviceSpec;
/**
*
*/
private Long deviceType;
/**
*
*/
private String supplier;
/**
*
*/
private String workshop;
/**
*
*/
private String systemOrg;
/**
*
*/
private String deviceLocation;
/**
*
*/
private String deviceManager;
/**
*
*/
private LocalDateTime productionDate;
/**
*
*/
private LocalDateTime factoryEntryDate;
/**
*
*/
private String deviceRemark;
/**
*
*/
private String remark;
/**
*
*/
private Integer sort;
}

@ -0,0 +1,56 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.devicetype;
import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("mes_device_type")
@KeySequence("mes_device_type_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class DeviceTypeDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
*
*/
private String code;
/**
*
*/
private String name;
/**
*
*/
private String remark;
/**
*
*/
private Integer sort;
/** */
@JsonProperty("parent_id")
private Long parentId;
/** */
@JsonProperty("parent_chain")
private String parentChain;
}

@ -54,4 +54,17 @@ public class DvSubjectDO extends BaseDO {
*/
private Boolean isEnable;
/**
*
*/
private String inspectionMethod;
/**
*
*/
private String valueType;
/**
*
*/
private String judgmentCriteria;
}

@ -0,0 +1,43 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("mes_plan_maintenance")
@KeySequence("mes_plan_maintenance_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PlanMaintenanceDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
*
*/
private String planName;
/**
*
*/
private String planType;
/**
*
*/
private String description;
}

@ -0,0 +1,39 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("mes_subject_plan")
@KeySequence("mes_subject_plan_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class SubjectPlanDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
* ID
*/
private Long subjectId;
/**
* ID
*/
private Long planId;
}

@ -0,0 +1,69 @@
package cn.iocoder.yudao.module.mes.dal.dataobject.taskmanagement;
import lombok.*;
import java.util.*;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import java.time.LocalDateTime;
import com.baomidou.mybatisplus.annotation.*;
import cn.iocoder.yudao.framework.mybatis.core.dataobject.BaseDO;
/**
* DO
*
* @author
*/
@TableName("mes_task_management")
@KeySequence("mes_task_management_seq") // 用于 Oracle、PostgreSQL、Kingbase、DB2、H2 数据库的主键自增。如果是 MySQL 等数据库,可不写。
@Data
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class TaskManagementDO extends BaseDO {
/**
* id
*/
@TableId
private Long id;
/**
*
*/
private String name;
/**
* (1- 2-)
*/
private Integer taskType;
/**
*
*/
private String deviceList;
/**
*
*/
private Long projectForm;
/**
*
*/
private LocalDateTime startDate;
/**
*
*/
private LocalDateTime endDate;
/**
* cron
*/
private String cronExpression;
/**
*
*/
private String operableUsers;
/**
*
*/
private Boolean enabled;
}

@ -0,0 +1,59 @@
package cn.iocoder.yudao.module.mes.dal.mysql.deviceledger;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.iot.dal.dataobject.device.DeviceDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger.DeviceLedgerDO;
import com.alibaba.excel.util.StringUtils;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface DeviceLedgerMapper extends BaseMapperX<DeviceLedgerDO> {
default PageResult<DeviceLedgerDO> selectPage(DeviceLedgerPageReqVO reqVO) {
LambdaQueryWrapperX<DeviceLedgerDO> deviceLedgerDOLambdaQueryWrapperX = new LambdaQueryWrapperX<>();
deviceLedgerDOLambdaQueryWrapperX
.eqIfPresent(DeviceLedgerDO::getDeviceCode, reqVO.getDeviceCode())
.likeIfPresent(DeviceLedgerDO::getDeviceName, reqVO.getDeviceName())
.eqIfPresent(DeviceLedgerDO::getDeviceStatus, reqVO.getDeviceStatus())
.eqIfPresent(DeviceLedgerDO::getDeviceBrand, reqVO.getDeviceBrand())
.eqIfPresent(DeviceLedgerDO::getDeviceModel, reqVO.getDeviceModel())
.eqIfPresent(DeviceLedgerDO::getDeviceSpec, reqVO.getDeviceSpec())
.eqIfPresent(DeviceLedgerDO::getDeviceType, reqVO.getDeviceType())
.eqIfPresent(DeviceLedgerDO::getSupplier, reqVO.getSupplier())
.eqIfPresent(DeviceLedgerDO::getWorkshop, reqVO.getWorkshop())
.eqIfPresent(DeviceLedgerDO::getSystemOrg, reqVO.getSystemOrg())
.eqIfPresent(DeviceLedgerDO::getDeviceLocation, reqVO.getDeviceLocation())
.eqIfPresent(DeviceLedgerDO::getDeviceManager, reqVO.getDeviceManager())
.betweenIfPresent(DeviceLedgerDO::getProductionDate, reqVO.getProductionDate())
.betweenIfPresent(DeviceLedgerDO::getFactoryEntryDate, reqVO.getFactoryEntryDate())
.eqIfPresent(DeviceLedgerDO::getDeviceRemark, reqVO.getDeviceRemark())
.eqIfPresent(DeviceLedgerDO::getRemark, reqVO.getRemark())
.eqIfPresent(DeviceLedgerDO::getSort, reqVO.getSort())
.betweenIfPresent(DeviceLedgerDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(DeviceLedgerDO::getId);
// 单独处理 ids 条件
if (StringUtils.isNotBlank(reqVO.getIds())) {
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
.map(Long::valueOf)
.collect(Collectors.toList());
deviceLedgerDOLambdaQueryWrapperX.in(DeviceLedgerDO::getId, idList);
}
return selectPage(reqVO, deviceLedgerDOLambdaQueryWrapperX);
}
}

@ -0,0 +1,50 @@
package cn.iocoder.yudao.module.mes.dal.mysql.devicetype;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.*;
import java.util.List;
/**
* Mapper
*
* @author
*/
@Mapper
public interface DeviceTypeMapper extends BaseMapperX<DeviceTypeDO> {
default PageResult<DeviceTypeDO> selectPage(DeviceTypePageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<DeviceTypeDO>()
.eqIfPresent(DeviceTypeDO::getParentId, reqVO.getParentId())
.likeIfPresent(DeviceTypeDO::getParentChain, reqVO.getParentChain())
.eqIfPresent(DeviceTypeDO::getCode, reqVO.getCode())
.likeIfPresent(DeviceTypeDO::getName, reqVO.getName())
.eqIfPresent(DeviceTypeDO::getRemark, reqVO.getRemark())
.eqIfPresent(DeviceTypeDO::getSort, reqVO.getSort())
.betweenIfPresent(DeviceTypeDO::getCreateTime, reqVO.getCreateTime())
.orderByAsc(DeviceTypeDO::getSort)
.orderByDesc(DeviceTypeDO::getId));
}
default List<DeviceTypeDO> selectList(DeviceTypeListReqVO reqVO) {
return selectList(new LambdaQueryWrapperX<DeviceTypeDO>()
.eqIfPresent(DeviceTypeDO::getParentId, reqVO.getParentId())
.likeIfPresent(DeviceTypeDO::getParentChain, reqVO.getParentChain())
.likeIfPresent(DeviceTypeDO::getCode, reqVO.getCode())
.likeIfPresent(DeviceTypeDO::getName, reqVO.getName())
.betweenIfPresent(DeviceTypeDO::getCreateTime, reqVO.getCreateStartTime(), reqVO.getCreateEndTime())
.orderByAsc(DeviceTypeDO::getSort)
.orderByDesc(DeviceTypeDO::getId));
}
default List<DeviceTypeDO> selectList() {
return selectList(new LambdaQueryWrapper<DeviceTypeDO>()
.orderByAsc(DeviceTypeDO::getSort)
.orderByDesc(DeviceTypeDO::getId));
}
}

@ -1,11 +1,14 @@
package cn.iocoder.yudao.module.mes.dal.mysql.dvsubject;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger.DeviceLedgerDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.dvsubject.DvSubjectDO;
import com.alibaba.excel.util.StringUtils;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.mes.controller.admin.dvsubject.vo.*;
@ -18,15 +21,32 @@ import cn.iocoder.yudao.module.mes.controller.admin.dvsubject.vo.*;
public interface DvSubjectMapper extends BaseMapperX<DvSubjectDO> {
default PageResult<DvSubjectDO> selectPage(DvSubjectPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<DvSubjectDO>()
.eqIfPresent(DvSubjectDO::getSubjectCode, reqVO.getSubjectCode())
LambdaQueryWrapperX<DvSubjectDO> dvSubjectDOLambdaQueryWrapperX = new LambdaQueryWrapperX<>();
dvSubjectDOLambdaQueryWrapperX
.likeIfPresent(DvSubjectDO::getInspectionMethod, reqVO.getInspectionMethod())
.likeIfPresent(DvSubjectDO::getValueType, reqVO.getValueType())
.likeIfPresent(DvSubjectDO::getJudgmentCriteria, reqVO.getJudgmentCriteria())
.likeIfPresent(DvSubjectDO::getSubjectCode, reqVO.getSubjectCode())
.likeIfPresent(DvSubjectDO::getSubjectName, reqVO.getSubjectName())
.eqIfPresent(DvSubjectDO::getSubjectType, reqVO.getSubjectType())
.eqIfPresent(DvSubjectDO::getSubjectContent, reqVO.getSubjectContent())
.eqIfPresent(DvSubjectDO::getSubjectStandard, reqVO.getSubjectStandard())
.eqIfPresent(DvSubjectDO::getIsEnable, reqVO.getIsEnable())
.betweenIfPresent(DvSubjectDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(DvSubjectDO::getId));
.orderByDesc(DvSubjectDO::getId);
// 单独处理 ids 条件
if (StringUtils.isNotBlank(reqVO.getIds())) {
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
.map(Long::valueOf)
.collect(Collectors.toList());
dvSubjectDOLambdaQueryWrapperX.in(DvSubjectDO::getId, idList);
}
return selectPage(reqVO, dvSubjectDOLambdaQueryWrapperX);
}
}

@ -0,0 +1,45 @@
package cn.iocoder.yudao.module.mes.dal.mysql.planmaintenance;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.dvsubject.DvSubjectDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance.PlanMaintenanceDO;
import com.alibaba.excel.util.StringUtils;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface PlanMaintenanceMapper extends BaseMapperX<PlanMaintenanceDO> {
default PageResult<PlanMaintenanceDO> selectPage(PlanMaintenancePageReqVO reqVO) {
LambdaQueryWrapperX<PlanMaintenanceDO> planMaintenanceDOLambdaQueryWrapperX = new LambdaQueryWrapperX<>();
planMaintenanceDOLambdaQueryWrapperX
.likeIfPresent(PlanMaintenanceDO::getPlanName, reqVO.getPlanName())
.eqIfPresent(PlanMaintenanceDO::getPlanType, reqVO.getPlanType())
.eqIfPresent(PlanMaintenanceDO::getDescription, reqVO.getDescription())
.betweenIfPresent(PlanMaintenanceDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(PlanMaintenanceDO::getId);
// 单独处理 ids 条件
if (StringUtils.isNotBlank(reqVO.getIds())) {
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
.map(Long::valueOf)
.collect(Collectors.toList());
planMaintenanceDOLambdaQueryWrapperX.in(PlanMaintenanceDO::getId, idList);
}
return selectPage(reqVO, planMaintenanceDOLambdaQueryWrapperX);
}
}

@ -0,0 +1,35 @@
package cn.iocoder.yudao.module.mes.dal.mysql.subjectplan;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface SubjectPlanMapper extends BaseMapperX<SubjectPlanDO> {
default PageResult<SubjectPlanDO> selectPage(SubjectPlanPageReqVO reqVO) {
return selectPage(reqVO, new LambdaQueryWrapperX<SubjectPlanDO>()
.eqIfPresent(SubjectPlanDO::getSubjectId, reqVO.getSubjectId())
.eqIfPresent(SubjectPlanDO::getPlanId, reqVO.getPlanId())
.betweenIfPresent(SubjectPlanDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(SubjectPlanDO::getId));
}
/**
*
*
* @param planId ID
*/
@Delete("DELETE FROM besure.mes_subject_plan WHERE plan_id = #{planId}")
void deleteByPlanId(Long planId);
}

@ -0,0 +1,53 @@
package cn.iocoder.yudao.module.mes.dal.mysql.taskmanagement;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.mybatis.core.query.LambdaQueryWrapperX;
import cn.iocoder.yudao.framework.mybatis.core.mapper.BaseMapperX;
import cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance.PlanMaintenanceDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.taskmanagement.TaskManagementDO;
import com.alibaba.excel.util.StringUtils;
import org.apache.ibatis.annotations.Mapper;
import cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo.*;
/**
* Mapper
*
* @author
*/
@Mapper
public interface TaskManagementMapper extends BaseMapperX<TaskManagementDO> {
default PageResult<TaskManagementDO> selectPage(TaskManagementPageReqVO reqVO) {
LambdaQueryWrapperX<TaskManagementDO> taskManagementDOLambdaQueryWrapperX = new LambdaQueryWrapperX<>();
taskManagementDOLambdaQueryWrapperX
.likeIfPresent(TaskManagementDO::getName, reqVO.getName())
.eqIfPresent(TaskManagementDO::getTaskType, reqVO.getTaskType())
.eqIfPresent(TaskManagementDO::getDeviceList, reqVO.getDeviceList())
.eqIfPresent(TaskManagementDO::getProjectForm, reqVO.getProjectForm())
.betweenIfPresent(TaskManagementDO::getStartDate, reqVO.getStartDate())
.betweenIfPresent(TaskManagementDO::getEndDate, reqVO.getEndDate())
.eqIfPresent(TaskManagementDO::getCronExpression, reqVO.getCronExpression())
.eqIfPresent(TaskManagementDO::getOperableUsers, reqVO.getOperableUsers())
.eqIfPresent(TaskManagementDO::getEnabled, reqVO.getEnabled())
.betweenIfPresent(TaskManagementDO::getCreateTime, reqVO.getCreateTime())
.orderByDesc(TaskManagementDO::getId);
// 单独处理 ids 条件
if (StringUtils.isNotBlank(reqVO.getIds())) {
List<Long> idList = Arrays.stream(reqVO.getIds().split(","))
.map(String::trim)
.map(Long::valueOf)
.collect(Collectors.toList());
taskManagementDOLambdaQueryWrapperX.in(TaskManagementDO::getId, idList);
}
return selectPage(reqVO, taskManagementDOLambdaQueryWrapperX);
}
}

@ -0,0 +1,55 @@
package cn.iocoder.yudao.module.mes.service.deviceledger;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger.DeviceLedgerDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* Service
*
* @author
*/
public interface DeviceLedgerService {
/**
*
*
* @param createReqVO
* @return
*/
Long createDeviceLedger(@Valid DeviceLedgerSaveReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateDeviceLedger(@Valid DeviceLedgerSaveReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteDeviceLedger( List<Long> idList );
/**
*
*
* @param id
* @return
*/
DeviceLedgerDO getDeviceLedger(Long id);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<DeviceLedgerDO> getDeviceLedgerPage(DeviceLedgerPageReqVO pageReqVO);
}

@ -0,0 +1,89 @@
package cn.iocoder.yudao.module.mes.service.deviceledger;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import cn.iocoder.yudao.module.mes.controller.admin.deviceledger.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.deviceledger.DeviceLedgerDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.dal.mysql.deviceledger.DeviceLedgerMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class DeviceLedgerServiceImpl implements DeviceLedgerService {
@Resource
private DeviceLedgerMapper deviceLedgerMapper;
@Override
public Long createDeviceLedger(DeviceLedgerSaveReqVO createReqVO) {
//验证是否唯一编码
validateCodeOnly(createReqVO.getDeviceCode());
// 插入
DeviceLedgerDO deviceLedger = BeanUtils.toBean(createReqVO, DeviceLedgerDO.class);
deviceLedgerMapper.insert(deviceLedger);
// 返回
return deviceLedger.getId();
}
private void validateCodeOnly( String code) {
if (deviceLedgerMapper.exists(Wrappers.<DeviceLedgerDO>lambdaQuery()
.eq(DeviceLedgerDO::getDeviceCode, code))) {
throw exception(DEVICE_LEDGER_EXISTS);
}
}
@Override
public void updateDeviceLedger(DeviceLedgerSaveReqVO updateReqVO) {
// 校验存在
validateDeviceLedgerExists(updateReqVO.getId());
// 更新
DeviceLedgerDO updateObj = BeanUtils.toBean(updateReqVO, DeviceLedgerDO.class);
deviceLedgerMapper.updateById(updateObj);
}
@Override
public void deleteDeviceLedger(List<Long> idList ) {
for (Long id : idList) {
// 校验存在
validateDeviceLedgerExists(id);
}
// 删除
deviceLedgerMapper.deleteByIds(idList);
}
private void validateDeviceLedgerExists(Long id) {
if (deviceLedgerMapper.selectById(id) == null) {
throw exception(DEVICE_LEDGER_NOT_EXISTS);
}
}
@Override
public DeviceLedgerDO getDeviceLedger(Long id) {
return deviceLedgerMapper.selectById(id);
}
@Override
public PageResult<DeviceLedgerDO> getDeviceLedgerPage(DeviceLedgerPageReqVO pageReqVO) {
return deviceLedgerMapper.selectPage(pageReqVO);
}
}

@ -0,0 +1,40 @@
package cn.iocoder.yudao.module.mes.service.devicetype;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.DeviceTypeTreeRespVO;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
/**
* Service
*
* @author
*/
public interface DeviceTypeService {
Long createDeviceType(DeviceTypeSaveReqVO createReqVO);
void updateDeviceType(DeviceTypeSaveReqVO updateReqVO);
void deleteDeviceType(Long id);
void deleteDeviceTypeBatch(List<Long> ids);
DeviceTypeDO getDeviceType(Long id);
PageResult<DeviceTypeDO> getDeviceTypePage(DeviceTypePageReqVO pageReqVO);
List<DeviceTypeDO> getDeviceTypeList(DeviceTypeListReqVO listReqVO);
List<DeviceTypeTreeRespVO> getDeviceTypeTree(DeviceTypeListReqVO pageReqVO);
List<DeviceTypeDO> getChildrenDeviceTypes(Long parentId);
List<DeviceTypeDO> getAncestorDeviceTypes(Long id);
}

@ -0,0 +1,312 @@
package cn.iocoder.yudao.module.mes.service.devicetype;
import cn.iocoder.yudao.framework.common.util.collection.CollectionUtils;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.DeviceTypeTreeRespVO;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.module.mes.controller.admin.devicetype.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.dal.mysql.devicetype.DeviceTypeMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
import static com.baomidou.mybatisplus.extension.toolkit.Db.list;
/**
* Service
*
* @author
*/
@Service
@Validated
public class DeviceTypeServiceImpl implements DeviceTypeService {
@Resource
private DeviceTypeMapper deviceTypeMapper;
@Override
public Long createDeviceType(DeviceTypeSaveReqVO createReqVO) {
// 1. 验证父级设备类型是否存在以及编码是否唯一
validateParentDeviceType(Long.valueOf(createReqVO.getParentId()));
validateCodeOnly(createReqVO.getCode());
// 2. 插入
DeviceTypeDO deviceType = BeanUtils.toBean(createReqVO, DeviceTypeDO.class);
// 3. 设置父级链
if (createReqVO.getParentId() != null && createReqVO.getParentId() > 0) {
DeviceTypeDO parent = getDeviceType(Long.valueOf(createReqVO.getParentId()));
deviceType.setParentChain(buildParentChain(parent));
} else {
deviceType.setParentChain(""); // 根节点
}
deviceTypeMapper.insert(deviceType);
// 4. 更新子节点的父级链(如果有的话)
updateChildrenParentChain(deviceType);
return deviceType.getId();
}
private void validateCodeOnly( String code) {
if (deviceTypeMapper.exists(Wrappers.<DeviceTypeDO>lambdaQuery()
.eq(DeviceTypeDO::getCode, code))) {
throw exception(DEVICE_LEDGER_CODE_NOT_ONLY);
}
}
@Override
public void updateDeviceType(DeviceTypeSaveReqVO updateReqVO) {
// 1. 校验存在
validateDeviceTypeExists(updateReqVO.getId());
// 2. 验证父级设备类型是否存在且不能是自己的子节点
validateParentDeviceType(Long.valueOf(updateReqVO.getParentId()));
if (updateReqVO.getParentId() != null) {
validateNotChildOfSelf(updateReqVO.getId(), Long.valueOf(updateReqVO.getParentId()));
}
// 3. 获取旧数据
DeviceTypeDO oldDeviceType = getDeviceType(updateReqVO.getId());
// 4. 更新
DeviceTypeDO updateObj = BeanUtils.toBean(updateReqVO, DeviceTypeDO.class);
// 5. 如果父级有变化,更新父级链
if (!Objects.equals(oldDeviceType.getParentId(), updateReqVO.getParentId())) {
if (updateReqVO.getParentId() != null && updateReqVO.getParentId() > 0) {
DeviceTypeDO parent = getDeviceType(Long.valueOf(updateReqVO.getParentId()));
updateObj.setParentChain(buildParentChain(parent));
} else {
updateObj.setParentChain(""); // 根节点
}
// 更新所有子节点的父级链
updateChildrenParentChain(updateObj);
}
deviceTypeMapper.updateById(updateObj);
}
@Override
public void deleteDeviceType(Long id) {
// 1. 校验存在
validateDeviceTypeExists(id);
// 2. 校验是否有子节点
if (hasChildren(id)) {
throw exception(DEVICE_TYPE_EXITS_CHILDREN);
}
// 3. 删除
deviceTypeMapper.deleteById(id);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteDeviceTypeBatch(List<Long> ids) {
for (Long id : ids) {
deleteDeviceType(id);
}
}
private void validateDeviceTypeExists(Long id) {
if (deviceTypeMapper.selectById(id) == null) {
throw exception(DEVICE_TYPE_NOT_EXISTS);
}
}
@Override
public DeviceTypeDO getDeviceType(Long id) {
return deviceTypeMapper.selectById(id);
}
@Override
public PageResult<DeviceTypeDO> getDeviceTypePage(DeviceTypePageReqVO pageReqVO) {
return deviceTypeMapper.selectPage(pageReqVO);
}
@Override
public List<DeviceTypeDO> getDeviceTypeList(DeviceTypeListReqVO listReqVO) {
return deviceTypeMapper.selectList(listReqVO);
}
@Override
public List<DeviceTypeTreeRespVO> getDeviceTypeTree(DeviceTypeListReqVO pageReqVO) {
// 1. 查询所有设备类型
List<DeviceTypeDO> allDeviceTypes = deviceTypeMapper.selectList(pageReqVO);
// 2. 构建树形结构
return buildDeviceTypeTree(allDeviceTypes);
}
@Override
public List<DeviceTypeDO> getChildrenDeviceTypes(Long parentId) {
LambdaQueryWrapper<DeviceTypeDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DeviceTypeDO::getParentId, parentId)
.orderByAsc(DeviceTypeDO::getSort, DeviceTypeDO::getId);
return deviceTypeMapper.selectList(queryWrapper);
}
@Override
public List<DeviceTypeDO> getAncestorDeviceTypes(Long id) {
DeviceTypeDO deviceType = getDeviceType(id);
if (deviceType == null || deviceType.getParentChain() == null ||
deviceType.getParentChain().isEmpty()) {
return Collections.emptyList();
}
String[] parentIds = deviceType.getParentChain().split(",");
List<Long> ids = Arrays.stream(parentIds)
.filter(s -> !s.isEmpty())
.map(Long::valueOf)
.collect(Collectors.toList());
if (ids.isEmpty()) {
return Collections.emptyList();
}
return deviceTypeMapper.selectBatchIds(ids);
}
// ========== 私有方法 ==========
/**
*
*/
private List<DeviceTypeTreeRespVO> buildDeviceTypeTree(List<DeviceTypeDO> allDeviceTypes) {
// 按父级ID分组
Map<Long, List<DeviceTypeDO>> childrenMap = CollectionUtils.convertMultiMap(
allDeviceTypes, DeviceTypeDO::getParentId);
// 获取根节点parentId为空或0
List<DeviceTypeDO> rootDeviceTypes = childrenMap.getOrDefault(0L, Collections.emptyList());
rootDeviceTypes.addAll(childrenMap.getOrDefault(null, Collections.emptyList()));
// 排序
rootDeviceTypes.sort(Comparator.comparing(DeviceTypeDO::getSort)
.thenComparing(DeviceTypeDO::getId));
// 递归构建树
return rootDeviceTypes.stream()
.map(deviceType -> convertToTree(deviceType, childrenMap))
.collect(Collectors.toList());
}
/**
*
*/
private DeviceTypeTreeRespVO convertToTree(DeviceTypeDO deviceType,
Map<Long, List<DeviceTypeDO>> childrenMap) {
DeviceTypeTreeRespVO treeNode = BeanUtils.toBean(deviceType, DeviceTypeTreeRespVO.class);
// 获取子节点
List<DeviceTypeDO> children = childrenMap.getOrDefault(deviceType.getId(), Collections.emptyList());
if (!children.isEmpty()) {
// 排序
children.sort(Comparator.comparing(DeviceTypeDO::getSort)
.thenComparing(DeviceTypeDO::getId));
// 递归转换子节点
List<DeviceTypeTreeRespVO> childNodes = children.stream()
.map(child -> convertToTree(child, childrenMap))
.collect(Collectors.toList());
treeNode.setChildren(childNodes);
treeNode.setLeaf(false);
}
return treeNode;
}
/**
*
*/
private void validateParentDeviceType(Long parentId) {
if (parentId != null && parentId > 0) {
if (deviceTypeMapper.selectById(parentId) == null) {
throw exception(DEVICE_TYPE_PARENT_NOT_EXISTS);
}
}
}
/**
*
*/
private void validateNotChildOfSelf(Long id, Long parentId) {
if (id.equals(parentId)) {
throw exception(DEVICE_TYPE_PARENT_IS_SELF);
}
// 获取父级的父级链
DeviceTypeDO parent = getDeviceType(parentId);
if (parent != null && parent.getParentChain() != null) {
String parentChain = parent.getParentChain();
if (parentChain.contains("," + id + ",") ||
parentChain.startsWith(id + ",") ||
parentChain.endsWith("," + id)) {
throw exception(DEVICE_TYPE_PARENT_IS_CHILD);
}
}
}
/**
*
*/
private boolean hasChildren(Long id) {
LambdaQueryWrapper<DeviceTypeDO> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(DeviceTypeDO::getParentId, id);
return deviceTypeMapper.selectCount(queryWrapper) > 0;
}
/**
*
*/
private String buildParentChain(DeviceTypeDO parent) {
if (parent == null) {
return "";
}
StringBuilder chain = new StringBuilder();
if (parent.getParentChain() != null && !parent.getParentChain().isEmpty()) {
chain.append(parent.getParentChain()).append(",");
}
chain.append(parent.getId());
return chain.toString();
}
/**
*
*/
private void updateChildrenParentChain(DeviceTypeDO deviceType) {
List<DeviceTypeDO> children = getChildrenDeviceTypes(deviceType.getId());
for (DeviceTypeDO child : children) {
String newParentChain = buildParentChain(deviceType);
child.setParentChain(newParentChain);
deviceTypeMapper.updateById(child);
// 递归更新孙子节点
updateChildrenParentChain(child);
}
}
}

@ -6,6 +6,7 @@ import cn.iocoder.yudao.module.mes.controller.admin.dvsubject.vo.DvSubjectSaveRe
import cn.iocoder.yudao.module.mes.dal.dataobject.dvsubject.DvSubjectDO;
import javax.validation.Valid;
import java.util.List;
/**
* Service
@ -34,7 +35,7 @@ public interface DvSubjectService {
*
* @param id
*/
void deleteDvSubject(Long id);
void deleteDvSubject(List<Long> idList);
/**
*

@ -4,15 +4,19 @@ 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.dvsubject.vo.DvSubjectPageReqVO;
import cn.iocoder.yudao.module.mes.controller.admin.dvsubject.vo.DvSubjectSaveReqVO;
import cn.iocoder.yudao.module.mes.dal.dataobject.devicetype.DeviceTypeDO;
import cn.iocoder.yudao.module.mes.dal.dataobject.dvsubject.DvSubjectDO;
import cn.iocoder.yudao.module.mes.dal.mysql.dvsubject.DvSubjectMapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.stereotype.Service;
import org.springframework.validation.annotation.Validated;
import javax.annotation.Resource;
import java.util.List;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.DV_SUBJECT_NOT_EXISTS;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
/**
* Service
@ -28,6 +32,8 @@ public class DvSubjectServiceImpl implements DvSubjectService {
@Override
public Long createDvSubject(DvSubjectSaveReqVO createReqVO) {
validateCodeOnly(createReqVO.getSubjectCode());
// 插入
DvSubjectDO dvSubject = BeanUtils.toBean(createReqVO, DvSubjectDO.class);
dvSubjectMapper.insert(dvSubject);
@ -35,6 +41,13 @@ public class DvSubjectServiceImpl implements DvSubjectService {
return dvSubject.getId();
}
private void validateCodeOnly( String code) {
if (dvSubjectMapper.exists(Wrappers.<DvSubjectDO>lambdaQuery()
.eq(DvSubjectDO::getSubjectCode, code))) {
throw exception(SUBJECT_EXISTS);
}
}
@Override
public void updateDvSubject(DvSubjectSaveReqVO updateReqVO) {
// 校验存在
@ -45,11 +58,15 @@ public class DvSubjectServiceImpl implements DvSubjectService {
}
@Override
public void deleteDvSubject(Long id) {
// 校验存在
validateDvSubjectExists(id);
public void deleteDvSubject(List<Long> idList) {
for (Long id : idList) {
// 校验存在
validateDvSubjectExists(id);
}
// 删除
dvSubjectMapper.deleteById(id);
dvSubjectMapper.deleteByIds(idList);
}
private void validateDvSubjectExists(Long id) {

@ -0,0 +1,58 @@
package cn.iocoder.yudao.module.mes.service.planmaintenance;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance.PlanMaintenanceDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
/**
* Service
*
* @author
*/
public interface PlanMaintenanceService {
/**
*
*
* @param createReqVO
* @return
*/
Long createPlanMaintenance(@Valid PlanMaintenanceSaveReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updatePlanMaintenance(@Valid PlanMaintenanceSaveReqVO updateReqVO);
/**
*
*
* @param id
*/
void deletePlanMaintenance( List<Long> idList);
/**
*
*
* @param id
* @return
*/
PlanMaintenanceDO getPlanMaintenance(Long id);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<PlanMaintenanceDO> getPlanMaintenancePage(PlanMaintenancePageReqVO pageReqVO);
List<SubjectPlanDO> getSubjectList(Long id);
}

@ -0,0 +1,164 @@
package cn.iocoder.yudao.module.mes.service.planmaintenance;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import cn.iocoder.yudao.module.mes.dal.mysql.subjectplan.SubjectPlanMapper;
import cn.iocoder.yudao.module.mes.service.subjectplan.SubjectPlanService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
import cn.iocoder.yudao.module.mes.controller.admin.planmaintenance.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.planmaintenance.PlanMaintenanceDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.dal.mysql.planmaintenance.PlanMaintenanceMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class PlanMaintenanceServiceImpl implements PlanMaintenanceService {
@Resource
private PlanMaintenanceMapper planMaintenanceMapper;
@Resource
private SubjectPlanMapper subjectPlanMapper;
@Override
@Transactional(rollbackFor = Exception.class)
public Long createPlanMaintenance(PlanMaintenanceSaveReqVO createReqVO) {
// 插入
PlanMaintenanceDO planMaintenance = BeanUtils.toBean(createReqVO, PlanMaintenanceDO.class);
planMaintenanceMapper.insert(planMaintenance);
if (StringUtils.isNotBlank(createReqVO.getSubjectIdS())){
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream( createReqVO.getSubjectIdS().split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
//插入关联表
insertSubjectPlan(planMaintenance.getId(),idList);
}
// 返回
return planMaintenance.getId();
}
private void insertSubjectPlan(Long id, List<Long> idList) {
List<SubjectPlanDO> subjectPlanDOArrayList = new ArrayList<>();
for (Long subjectId : idList) {
SubjectPlanDO subjectPlanDO = new SubjectPlanDO();
subjectPlanDO.setPlanId(id);
subjectPlanDO.setSubjectId(subjectId);
subjectPlanDOArrayList.add(subjectPlanDO);
}
subjectPlanMapper.insertBatch(subjectPlanDOArrayList);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updatePlanMaintenance(PlanMaintenanceSaveReqVO updateReqVO) {
// 校验存在
validatePlanMaintenanceExists(updateReqVO.getId());
// 更新
PlanMaintenanceDO updateObj = BeanUtils.toBean(updateReqVO, PlanMaintenanceDO.class);
planMaintenanceMapper.updateById(updateObj);
if (StringUtils.isNotBlank(updateReqVO.getSubjectIdS())) {
// 将逗号分隔的字符串转换为Long类型的List
List<Long> idList = Arrays.stream( updateReqVO.getSubjectIdS().split(","))
.map(String::trim) // 去除可能存在的空格
.map(Long::valueOf)
.collect(Collectors.toList());
//更新关联表
updateSubjectPlan(updateObj.getId(),idList);
}
}
private void updateSubjectPlan(Long id, List<Long> idList) {
subjectPlanMapper.deleteByPlanId(id);
List<SubjectPlanDO> subjectPlanDOArrayList = new ArrayList<>();
for (Long subjectId : idList) {
SubjectPlanDO subjectPlanDO = new SubjectPlanDO();
subjectPlanDO.setPlanId(id);
subjectPlanDO.setSubjectId(subjectId);
subjectPlanDOArrayList.add(subjectPlanDO);
}
subjectPlanMapper.insertBatch(subjectPlanDOArrayList);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deletePlanMaintenance( List<Long> idList) {
for (Long id : idList) {
// 校验存在
validatePlanMaintenanceExists(id);
}
// 删除
planMaintenanceMapper.deleteByIds(idList);
//删除关联表数据
deleteSubjectPlan(idList);
}
private void deleteSubjectPlan(List<Long> idList) {
for (Long id : idList) {
if (id != null ){
subjectPlanMapper.delete(Wrappers.<SubjectPlanDO>lambdaQuery()
.eq(SubjectPlanDO::getPlanId, id));
}
}
}
private void validatePlanMaintenanceExists(Long id) {
if (planMaintenanceMapper.selectById(id) == null) {
throw exception(PLAN_MAINTENANCE_NOT_EXISTS);
}
}
@Override
public PlanMaintenanceDO getPlanMaintenance(Long id) {
return planMaintenanceMapper.selectById(id);
}
@Override
public PageResult<PlanMaintenanceDO> getPlanMaintenancePage(PlanMaintenancePageReqVO pageReqVO) {
return planMaintenanceMapper.selectPage(pageReqVO);
}
@Override
public List<SubjectPlanDO> getSubjectList(Long id) {
if (id == null ){
throw exception(SUBJECT_ID_NOT_EXISTS);
}
return subjectPlanMapper.selectList(Wrappers.<SubjectPlanDO>lambdaQuery()
.eq(SubjectPlanDO::getSubjectId, id));
}
}

@ -0,0 +1,55 @@
package cn.iocoder.yudao.module.mes.service.subjectplan;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* Service
*
* @author
*/
public interface SubjectPlanService {
/**
*
*
* @param createReqVO
* @return
*/
Long createSubjectPlan(@Valid SubjectPlanSaveReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateSubjectPlan(@Valid SubjectPlanSaveReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteSubjectPlan(Long id);
/**
*
*
* @param id
* @return
*/
SubjectPlanDO getSubjectPlan(Long id);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<SubjectPlanDO> getSubjectPlanPage(SubjectPlanPageReqVO pageReqVO);
}

@ -0,0 +1,74 @@
package cn.iocoder.yudao.module.mes.service.subjectplan;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import cn.iocoder.yudao.module.mes.controller.admin.subjectplan.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.subjectplan.SubjectPlanDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.dal.mysql.subjectplan.SubjectPlanMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class SubjectPlanServiceImpl implements SubjectPlanService {
@Resource
private SubjectPlanMapper subjectPlanMapper;
@Override
public Long createSubjectPlan(SubjectPlanSaveReqVO createReqVO) {
// 插入
SubjectPlanDO subjectPlan = BeanUtils.toBean(createReqVO, SubjectPlanDO.class);
subjectPlanMapper.insert(subjectPlan);
// 返回
return subjectPlan.getId();
}
@Override
public void updateSubjectPlan(SubjectPlanSaveReqVO updateReqVO) {
// 校验存在
validateSubjectPlanExists(updateReqVO.getId());
// 更新
SubjectPlanDO updateObj = BeanUtils.toBean(updateReqVO, SubjectPlanDO.class);
subjectPlanMapper.updateById(updateObj);
}
@Override
public void deleteSubjectPlan(Long id) {
// 校验存在
validateSubjectPlanExists(id);
// 删除
subjectPlanMapper.deleteById(id);
}
private void validateSubjectPlanExists(Long id) {
if (subjectPlanMapper.selectById(id) == null) {
throw exception(SUBJECT_PLAN_NOT_EXISTS);
}
}
@Override
public SubjectPlanDO getSubjectPlan(Long id) {
return subjectPlanMapper.selectById(id);
}
@Override
public PageResult<SubjectPlanDO> getSubjectPlanPage(SubjectPlanPageReqVO pageReqVO) {
return subjectPlanMapper.selectPage(pageReqVO);
}
}

@ -0,0 +1,55 @@
package cn.iocoder.yudao.module.mes.service.taskmanagement;
import java.util.*;
import javax.validation.*;
import cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.taskmanagement.TaskManagementDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
/**
* Service
*
* @author
*/
public interface TaskManagementService {
/**
*
*
* @param createReqVO
* @return
*/
Long createTaskManagement(@Valid TaskManagementSaveReqVO createReqVO);
/**
*
*
* @param updateReqVO
*/
void updateTaskManagement(@Valid TaskManagementSaveReqVO updateReqVO);
/**
*
*
* @param id
*/
void deleteTaskManagement(List<Long> idList );
/**
*
*
* @param id
* @return
*/
TaskManagementDO getTaskManagement(Long id);
/**
*
*
* @param pageReqVO
* @return
*/
PageResult<TaskManagementDO> getTaskManagementPage(TaskManagementPageReqVO pageReqVO);
}

@ -0,0 +1,76 @@
package cn.iocoder.yudao.module.mes.service.taskmanagement;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import org.springframework.validation.annotation.Validated;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import cn.iocoder.yudao.module.mes.controller.admin.taskmanagement.vo.*;
import cn.iocoder.yudao.module.mes.dal.dataobject.taskmanagement.TaskManagementDO;
import cn.iocoder.yudao.framework.common.pojo.PageResult;
import cn.iocoder.yudao.framework.common.pojo.PageParam;
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
import cn.iocoder.yudao.module.mes.dal.mysql.taskmanagement.TaskManagementMapper;
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
import static cn.iocoder.yudao.module.mes.enums.ErrorCodeConstants.*;
/**
* Service
*
* @author
*/
@Service
@Validated
public class TaskManagementServiceImpl implements TaskManagementService {
@Resource
private TaskManagementMapper taskManagementMapper;
@Override
public Long createTaskManagement(TaskManagementSaveReqVO createReqVO) {
// 插入
TaskManagementDO taskManagement = BeanUtils.toBean(createReqVO, TaskManagementDO.class);
taskManagementMapper.insert(taskManagement);
// 返回
return taskManagement.getId();
}
@Override
public void updateTaskManagement(TaskManagementSaveReqVO updateReqVO) {
// 校验存在
validateTaskManagementExists(updateReqVO.getId());
// 更新
TaskManagementDO updateObj = BeanUtils.toBean(updateReqVO, TaskManagementDO.class);
taskManagementMapper.updateById(updateObj);
}
@Override
public void deleteTaskManagement(List<Long> idList ) {
for (Long id : idList) {
// 校验存在
validateTaskManagementExists(id);
}
// 删除
taskManagementMapper.deleteByIds(idList);
}
private void validateTaskManagementExists(Long id) {
if (taskManagementMapper.selectById(id) == null) {
throw exception(TASK_MANAGEMENT_NOT_EXISTS);
}
}
@Override
public TaskManagementDO getTaskManagement(Long id) {
return taskManagementMapper.selectById(id);
}
@Override
public PageResult<TaskManagementDO> getTaskManagementPage(TaskManagementPageReqVO pageReqVO) {
return taskManagementMapper.selectPage(pageReqVO);
}
}

@ -12,6 +12,8 @@ import org.springframework.context.annotation.Import;
import javax.annotation.Resource;
import java.util.Collections;
import static cn.iocoder.yudao.framework.common.util.date.LocalDateTimeUtils.buildBetweenTime;
import static cn.iocoder.yudao.framework.common.util.object.ObjectUtils.cloneIgnoreId;
import static cn.iocoder.yudao.framework.test.core.util.AssertUtils.assertPojoEquals;
@ -84,7 +86,7 @@ public class DvSubjectServiceImplTest extends BaseDbUnitTest {
Long id = dbDvSubject.getId();
// 调用
dvSubjectService.deleteDvSubject(id);
dvSubjectService.deleteDvSubject(Collections.singletonList(id));
// 校验数据不存在了
assertNull(dvSubjectMapper.selectById(id));
}
@ -95,7 +97,7 @@ public class DvSubjectServiceImplTest extends BaseDbUnitTest {
Long id = randomLongId();
// 调用, 并断言异常
assertServiceException(() -> dvSubjectService.deleteDvSubject(id), DV_SUBJECT_NOT_EXISTS);
assertServiceException(() -> dvSubjectService.deleteDvSubject(Collections.singletonList(id)), DV_SUBJECT_NOT_EXISTS);
}
@Test

Loading…
Cancel
Save