设备保养接口

@@ -6,8 +6,7 @@ CREATE TABLE "public"."qg_malfunction_reason" (
      "create_time" timestamp(6),
      "creator" varchar(36),
      "updater" varchar(36),
-     "update_time" timestamp(6),
-     "remark" varchar(255),
+     "update_time" timestamp(6)
      CONSTRAINT "qg_malfunction_reason_pkey" PRIMARY KEY ("id")
 );
 
@@ -43,8 +42,7 @@ CREATE TABLE "public"."qg_repair_order" (
     "create_time" timestamp(6),
     "creator" varchar(36),
     "updater" varchar(36),
-    "update_time" timestamp(6),
-    "remark" varchar(255),
+    "update_time" timestamp(6)
     CONSTRAINT "qg_repair_order_pkey" PRIMARY KEY ("id")
 );
 
@@ -75,8 +73,7 @@ CREATE TABLE "public"."qg_repair_record" (
     "create_time" timestamp(6),
     "creator" varchar(36),
     "updater" varchar(36),
-    "update_time" timestamp(6),
-    "remark" varchar(255),
+    "update_time" timestamp(6)
     CONSTRAINT "qg_repair_record_pkey" PRIMARY KEY ("id")
 );
 
@@ -199,4 +196,72 @@ COMMENT ON TABLE "public"."qg_inspection_details" IS '巡检记录明细';
 COMMENT ON COLUMN "public"."qg_inspection_details"."id" IS '主键ID';
 COMMENT ON COLUMN "public"."qg_inspection_details"."check_device_id" IS '巡检设备';
 COMMENT ON COLUMN "public"."qg_inspection_details"."plan_details" IS '巡检内容';
-COMMENT ON COLUMN "public"."qg_inspection_details"."record_result" IS '巡检结果';
\ No newline at end of file
+COMMENT ON COLUMN "public"."qg_inspection_details"."record_result" IS '巡检结果';
+
+CREATE TABLE "public"."qg_preserve_detail" (
+   "id" varchar(36)  NOT NULL,
+   "detail_code" varchar(50),
+   "preserve_detail" varchar(200),
+   "preserve_plan_id" varchar(36),
+   "device_id" varchar(36),
+   "check_plan_id" varchar(36),
+   "detail_status" varchar(50),
+   "tenant_id" varchar(36),
+   "create_time" timestamp(6),
+   "creator" varchar(36),
+   "updater" varchar(36),
+   "update_time" timestamp(6),
+   CONSTRAINT "qg_preserve_detail_pkey" PRIMARY KEY ("id")
+);
+
+COMMENT ON TABLE "public"."qg_preserve_detail" IS '保养明细';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."detail_code" IS '保养明细编码';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."preserve_detail" IS '方案明细';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."preserve_plan_id" IS '保养计划id';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."device_id" IS '设备id';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."check_plan_id" IS '方案id';
+COMMENT ON COLUMN "public"."qg_preserve_detail"."detail_status" IS '状态';
+
+CREATE TABLE "public"."qg_preserve_plan" (
+   "id" varchar(36)  NOT NULL,
+   "preserve_code" varchar(50),
+   "preserve_name" varchar(200),
+   "status" varchar(50),
+   "times" int4,
+   "frequency" varchar(50),
+   "tenant_id" varchar(36),
+   "create_time" timestamp(6),
+   "creator" varchar(36),
+   "updater" varchar(36),
+   "update_time" timestamp(6),
+   CONSTRAINT "qg_preserve_plan_pkey" PRIMARY KEY ("id")
+);
+
+COMMENT ON TABLE "public"."qg_preserve_plan" IS '保养计划';
+COMMENT ON COLUMN "public"."qg_preserve_plan"."preserve_code" IS '保养计划编码';
+COMMENT ON COLUMN "public"."qg_preserve_plan"."preserve_name" IS '保养计划名称';
+COMMENT ON COLUMN "public"."qg_preserve_plan"."status" IS '状态';
+COMMENT ON COLUMN "public"."qg_preserve_plan"."times" IS '次数';
+COMMENT ON COLUMN "public"."qg_preserve_plan"."frequency" IS '频率';
+
+CREATE TABLE "public"."qg_preserve_record" (
+    "id" varchar(36)  NOT NULL,
+    "record_code" varchar(50),
+    "preserve_plan_id" varchar(36),
+    "preserve_date" timestamp(6),
+    "preserve_by" varchar(36),
+    "preserve_status" varchar(50),
+    "tenant_id" varchar(36),
+    "create_time" timestamp(6),
+    "creator" varchar(36),
+    "updater" varchar(36),
+    "update_time" timestamp(6),
+    CONSTRAINT "qg_preserve_record_pkey" PRIMARY KEY ("id")
+);
+
+COMMENT ON TABLE "public"."qg_preserve_record" IS '保养记录';
+COMMENT ON COLUMN "public"."qg_preserve_record"."record_code" IS '保养记录编码';
+COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_plan_id" IS '保养计划id';
+COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_date" IS '保养日期';
+COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_by" IS '保养日期';
+COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_status" IS '状态';

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveDetailDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreservePlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveDetailService;
+import org.thingsboard.server.dao.yunteng.service.TkPreservePlanService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("api/yt/preservePlan")
+@Api(tags = {"保养计划"})
+@Slf4j
+public class TkPreservePlanController extends BaseController {
+
+    private final TkPreservePlanService tkPreservePlanService;
+
+    private final TkPreserveDetailService tkPreserveDetailService;
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划保存")
+    public ResponseEntity<TkPreservePlanDTO> save(@RequestBody TkPreservePlanDTO dto) throws ThingsboardException {
+        TkPreservePlanDTO preservePlanDTO = tkPreservePlanService.save(dto);
+        return ResponseEntity.ok(preservePlanDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划删除")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkPreservePlanService.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划详情")
+    public ResponseEntity<TkPreservePlanDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkPreservePlanDTO deviceDTO = tkPreservePlanService.detail(id);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划分页列表")
+    public TkPageData<TkPreservePlanDTO> pageData(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody TkPreservePlanDTO dto)
+            throws ThingsboardException {
+        dto.setPage(page);
+        dto.setPageSize(pageSize);
+        return tkPreservePlanService.page(dto);
+    }
+
+    @PostMapping("/updateStatus")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("更新保养计划状态")
+    public ResponseEntity<TkPreservePlanDTO> updateStatus(@RequestBody TkPreservePlanDTO dto) throws ThingsboardException {
+        TkPreservePlanDTO orderInfo = tkPreservePlanService.load(dto.getId());
+        if (orderInfo == null) {
+            throw new TkDataValidationException("保养计划不存在！");
+        }
+
+        tkPreservePlanService.updateStatus(dto.getId(), dto.getStatus());
+        return ResponseEntity.ok(orderInfo);
+    }
+
+    @PostMapping("/pageDetail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划详情分页列表")
+    public TkPageData<TkPreserveDetailDTO> pageDetail(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody TkPreserveDetailDTO dto)
+            throws ThingsboardException {
+        dto.setPage(page);
+        dto.setPageSize(pageSize);
+        return tkPreserveDetailService.page(dto);
+    }
+}

+package org.thingsboard.server.controller.yunteng;
+
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveRecordServcie;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.Map;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("api/yt/preserveRecord")
+@Api(tags = {"保养记录"})
+@Slf4j
+public class TkPreserveRecordController extends BaseController {
+
+    private final TkPreserveRecordServcie tkPreserveRecordServcie;
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养记录保存")
+    public ResponseEntity<TkPreserveRecordDTO> save(@RequestBody TkPreserveRecordDTO dto) throws ThingsboardException {
+        TkPreserveRecordDTO preservePlanDTO = tkPreserveRecordServcie.save(dto);
+        return ResponseEntity.ok(preservePlanDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养记录删除")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkPreserveRecordServcie.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养记录详情")
+    public ResponseEntity<TkPreserveRecordDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkPreserveRecordDTO deviceDTO = tkPreserveRecordServcie.detail(id);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @PostMapping("/updateStatus")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("更新保养记录状态")
+    public ResponseEntity<TkPreserveRecordDTO> updateStatus(@RequestBody TkPreserveRecordDTO dto) throws ThingsboardException {
+        TkPreserveRecordDTO orderInfo = tkPreserveRecordServcie.load(dto.getId());
+        if (orderInfo == null) {
+            throw new TkDataValidationException("保养记录不存在！");
+        }
+
+        tkPreserveRecordServcie.updateStatus(dto.getId(), dto.getPreserveStatus());
+        return ResponseEntity.ok(orderInfo);
+    }
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养记录分页列表")
+    public TkPageData<TkPreserveRecordDTO> pageData(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody Map<String, Object> params)
+            throws ThingsboardException {
+        params.put(PAGE, page);
+        params.put(PAGE_SIZE, pageSize);
+        return tkPreserveRecordServcie.page(params);
+    }
+}

@@ -59,7 +59,7 @@ public class TkRepairOrderController extends BaseController {
         }
 
         if (StringUtils.isBlank(dto.getStatus())) {
-            dto.setStatus(RepairOrderStatusEnum.SCHEDULING.name());
+            dto.setStatus(RepairOrderStatusEnum.DRAFT.name());
         }
 
         TkRepairOrderDTO deviceDTO = tkRepairOrderService.save(dto);
@@ -93,4 +93,17 @@ public class TkRepairOrderController extends BaseController {
         params.put(PAGE_SIZE, pageSize);
         return tkRepairOrderService.page(getCurrentUser().getCurrentTenantId(), params);
     }
+
+    @PostMapping("/updateStatus")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("更新工单状态")
+    public ResponseEntity<TkRepairOrderDTO> updateStatus(@RequestBody TkRepairOrderDTO dto) throws ThingsboardException {
+        TkRepairOrderDTO orderInfo = tkRepairOrderService.load(dto.getId());
+        if (orderInfo == null) {
+            throw new TkDataValidationException("工单不存在！");
+        }
+
+        tkRepairOrderService.updateStatus(dto.getId(), dto.getStatus());
+        return ResponseEntity.ok(orderInfo);
+    }
 }

@@ -143,4 +143,10 @@ public class DeviceDTO extends TenantDTO {
   private Integer isEdge;
   @ApiModelProperty(value = "设备负责人id")
   private String directorId;
+  @ApiModelProperty(value = "设备负责人名称")
+  private String directorName;
+  @ApiModelProperty(value = "类别id")
+  private String categoryId;
+  @ApiModelProperty(value = "类别名称")
+  private String categoryName;
 }

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkPreserveDetailDTO extends TenantDTO {
+    @ApiModelProperty(value = "保养明细编码")
+    private String detailCode;
+
+    @ApiModelProperty(value = "方案明细")
+    private String preserveDetail;
+
+    @ApiModelProperty(value = "保养计划id")
+    private String preservePlanId;
+
+    @ApiModelProperty(value = "设备id")
+    private String deviceId;
+
+    @ApiModelProperty(value = "设备信息")
+    private DeviceDTO deviceInfo;
+
+    @ApiModelProperty(value = "方案id")
+    private String checkPlanId;
+
+    @ApiModelProperty(value = "执行状态(UNEXECUTED未执行，EXECUTED已执行)")
+    private String detailStatus;
+
+    @ApiModelProperty(value = "页号")
+    private Integer page;
+
+    @ApiModelProperty(value = "页码")
+    private Integer pageSize;
+
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkPreservePlanDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "保养计划编码")
+    private String preserveCode;
+
+    @ApiModelProperty(value = "保养计划名称")
+    private String preserveName;
+
+    @ApiModelProperty(value = "状态(NOTSTART 未开始,UNDERWAY进行中,COMPLETED已完成,STOP停用)")
+    private String status;
+
+    @ApiModelProperty(value = "次数")
+    private Integer times;
+
+    @ApiModelProperty(value = "频率")
+    private String frequency;
+
+    @ApiModelProperty(value = "保养明细")
+    List<TkPreserveDetailDTO> preserveDetailList;
+
+    @ApiModelProperty(value = "页号")
+    private Integer page;
+
+    @ApiModelProperty(value = "页码")
+    private Integer pageSize;
+
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkPreserveRecordDTO extends TenantDTO {
+    @ApiModelProperty(value = "记录编号")
+    private String recordCode;
+
+    @ApiModelProperty(value = "保养计划id")
+    private String preservePlanId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "保养日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime preserveDate;
+
+    @ApiModelProperty(value = "保养人员id")
+    private String preserveBy;
+
+    @ApiModelProperty(value = "状态(INCOMPLETE未完成,COMPLETE已完成)")
+    private String preserveStatus;
+
+    @ApiModelProperty(value = "保养人员姓名")
+    private String preserveByName;
+
+    @ApiModelProperty(value = "保养计划名称")
+    private String preservePlanName;
+
+    @ApiModelProperty(value = "查询开始时间")
+    private LocalDateTime startDate;
+
+    @ApiModelProperty(value = "查询开始结束")
+    private LocalDateTime endDate;
+
+    @ApiModelProperty(value = "页号")
+    private Integer page;
+
+    @ApiModelProperty(value = "页码")
+    private Integer pageSize;
+
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum PreserveDetailStatusEnum {
+    //未执行
+    UNEXECUTED,
+    //已执行
+    EXECUTED
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum PreservePlanStatusEnum {
+    //未开始
+    NOTSTART,
+    //进行中
+    UNDERWAY,
+    //已完成
+    COMPLETED,
+    //停用
+    STOP
+}

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum PreserveRecordStatusEnum {
+    //未完成
+    INCOMPLETE,
+    //完成
+    COMPLETE,
+}

 package org.thingsboard.server.common.data.yunteng.enums;
 
 public enum RepairOrderStatusEnum {
+    //DRAFT
+    DRAFT,
     //排期中
     SCHEDULING,
     //维修完成

@@ -680,6 +680,9 @@ public class ModelConstants {
      * 维修记录
      */
     public static final String TKREPAIRRECORD_TABLE_NAME = "qg_repair_record";
+    public static final String TKPRESERVEPLAN_TABLE_NAME = "qg_preserve_plan";
+    public static final String TKPRESERVEDETAIL_TABLE_NAME = "qg_preserve_detail";
+    public static final String TKPRESERVERECORD_TABLE_NAME = "qg_preserve_record";
 
     public static final String TKINSPECTIONPLAN_TABLE_NAME= "qg_inspection_plan"; // 巡检计划
     public static final String TKCHECKPLAN_TABLE_NAME= "qg_check_plan"; // 巡检/保养方案

@@ -90,4 +90,6 @@ public class TkDeviceEntity extends TbTenantBaseEntity {
 
   private String directorId;
 
+  private String categoryId;
+
 }

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.dao.model.ModelConstants;
+
+/**
+ * 保养明细
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.TKPRESERVEDETAIL_TABLE_NAME, autoResultMap = true)
+public class TkPreserveDetailEntity extends TenantBaseEntity {
+    private String detailCode;
+    private String preserveDetail;
+    private String preservePlanId;
+    private String deviceId;
+    private String checkPlanId;
+    private String detailStatus;
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.dao.model.ModelConstants;
+
+/**
+ * 保养计划
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.TKPRESERVEPLAN_TABLE_NAME, autoResultMap = true)
+public class TkPreservePlanEntity extends TenantBaseEntity {
+    private String preserveCode;
+    private String preserveName;
+    private String status;
+    private Integer times;
+    private String frequency;
+}

+package org.thingsboard.server.dao.yunteng.entities;
+
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.dao.model.ModelConstants;
+
+import java.time.LocalDateTime;
+
+/**
+ * 保养记录
+ */
+@Data
+@EqualsAndHashCode(callSuper = true)
+@TableName(value = ModelConstants.TKPRESERVERECORD_TABLE_NAME, autoResultMap = true)
+public class TkPreserveRecordEntity extends TenantBaseEntity {
+    private String recordCode;
+    private String preservePlanId;
+    private LocalDateTime preserveDate;
+    private String preserveBy;
+    private String preserveStatus;
+}

@@ -7,9 +7,11 @@ import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
 import org.thingsboard.server.common.data.yunteng.dto.TkMalfunctionReasonDTO;
 import org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.yunteng.entities.TkMalfunctionReasonEntity;
 import org.thingsboard.server.dao.yunteng.mapper.TkMalfunctionReasonMapper;
@@ -33,10 +35,10 @@ public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfun
         LambdaQueryWrapper<TkMalfunctionReasonEntity> lambda = wrapper.lambda();
         lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId);
         if (queryMap != null && queryMap.get("code") != null) {
-            lambda.eq(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
+            lambda.like(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
         }
         if (queryMap != null && queryMap.get("reason") != null) {
-            lambda.eq(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
+            lambda.like(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
         }
 
         IPage<TkMalfunctionReasonEntity> page = baseMapper.selectPage(
@@ -51,10 +53,10 @@ public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfun
         LambdaQueryWrapper<TkMalfunctionReasonEntity> lambda = wrapper.lambda();
         lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId);
         if (queryMap != null && queryMap.get("code") != null) {
-            lambda.eq(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
+            lambda.like(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
         }
         if (queryMap != null && queryMap.get("reason") != null) {
-            lambda.eq(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
+            lambda.like(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
         }
         List<TkMalfunctionReasonEntity> entitys = baseMapper.selectList(wrapper);
         return Optional.ofNullable(entitys).map(all -> all.stream().map(item -> item.getDTO(TkMalfunctionReasonDTO.class))
@@ -63,7 +65,7 @@ public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfun
     }
 
     @Override
-    public TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO) {
+    public TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO) throws ThingsboardException {
         checkDto(tkMalfunctionReasonDTO);
         TkMalfunctionReasonEntity entity = new TkMalfunctionReasonEntity();
         if (StringUtils.isBlank(tkMalfunctionReasonDTO.getId())) {
@@ -81,9 +83,9 @@ public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfun
         return tkMalfunctionReasonDTO;
     }
 
-    private void checkDto(TkMalfunctionReasonDTO dto) {
+    private void checkDto(TkMalfunctionReasonDTO dto) throws ThingsboardException {
         if (StringUtils.isBlank(dto.getTenantId())) {
-            throw new TkDataValidationException("租户id为空！");
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
         }
     }
 

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveDetailDTO;
+import org.thingsboard.server.common.data.yunteng.enums.PreserveDetailStatusEnum;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TenantBaseEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveDetailEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkPreserveDetailMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveDetailService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkPreserveDetailServiceImpl extends AbstractBaseService<TkPreserveDetailMapper, TkPreserveDetailEntity>
+        implements TkPreserveDetailService {
+
+    private final TkDeviceService tkdeviceService;
+
+    @Override
+    public TkPageData<TkPreserveDetailDTO> page(TkPreserveDetailDTO condition) throws ThingsboardException {
+        TkPageData<TkPreserveDetailDTO> result = new TkPageData<>();
+        QueryWrapper<TkPreserveDetailEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkPreserveDetailEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkPreserveDetailEntity::getTenantId, tenantId.getId().toString());
+
+        if (StringUtils.isNotBlank(condition.getPreservePlanId())) {
+            lambda.eq(TkPreserveDetailEntity::getPreservePlanId, condition.getPreservePlanId());
+        }
+
+        lambda.orderByDesc(TenantBaseEntity::getCreateTime);
+
+        Page<TkPreserveDetailEntity> page = new Page<>();
+        page.setCurrent(condition.getPage());
+        page.setSize(condition.getPageSize());
+        page = baseMapper.selectPage(page, wrapper);
+
+        if (page != null && CollectionUtils.isNotEmpty(page.getRecords())) {
+            Map<String, DeviceDTO> deviceMap = new HashMap<>();
+            List<TkPreserveDetailDTO> dataList = page.getRecords().stream().map(item -> {
+                TkPreserveDetailDTO dto = item.getDTO(TkPreserveDetailDTO.class);
+                String deviceId = dto.getDeviceId();
+                DeviceDTO deviceDTO = deviceMap.get(deviceId);
+                if (deviceDTO == null) {
+                    deviceDTO = tkdeviceService.checkDeviceByTenantIdAndDeviceId(tenantId.getId(), UUID.fromString(dto.getDeviceId()));
+                    deviceMap.put(deviceId, deviceDTO);
+                }
+                dto.setDeviceInfo(deviceDTO);
+                return dto;
+            }).collect(Collectors.toList());
+            result.setItems(dataList);
+        }
+        result.setTotal(Long.valueOf(page.getTotal()).intValue());
+        return result;
+    }
+
+    @Override
+    public TkPreserveDetailDTO save(TkPreserveDetailDTO dto) throws ThingsboardException {
+        checkDto(dto);
+
+        TkPreserveDetailEntity entity = new TkPreserveDetailEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkPreserveDetailEntity> filter = new QueryWrapper<TkPreserveDetailEntity>().lambda()
+                    .eq(TkPreserveDetailEntity::getId, dto.getId());
+            entity = dto.getEntity(TkPreserveDetailEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    private void checkDto(TkPreserveDetailDTO dto) throws ThingsboardException {
+        if (StringUtils.isBlank(dto.getDeviceId())) {
+            throw new TkDataValidationException("设备不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getPreservePlanId())) {
+            throw new TkDataValidationException("保养计划id不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getCheckPlanId())) {
+            throw new TkDataValidationException("方案不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+
+        if (StringUtils.isBlank(dto.getDetailStatus())) {
+            dto.setDetailStatus(PreserveDetailStatusEnum.UNEXECUTED.name());
+        }
+    }
+
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    @Override
+    public boolean deleteByPlanId(String planId) {
+        Map<String, Object> params = new HashMap<>();
+        params.put("preserve_plan_id", planId);
+        int count = baseMapper.deleteByMap(params);
+        return count > 0;
+    }
+
+    @Override
+    public void deleteNotInIdEqPlanId(String planId, List<String> notinIds) {
+        baseMapper.delete(new QueryWrapper<TkPreserveDetailEntity>()
+                .lambda().eq(TkPreserveDetailEntity::getPreservePlanId, planId)
+                .notIn(TkPreserveDetailEntity::getId, notinIds)
+        );
+    }
+
+    @Override
+    public List<TkPreserveDetailDTO> listByPlanId(String planId) throws ThingsboardException {
+        if (StringUtils.isBlank(planId)) {
+            throw new TkDataValidationException("方案id不能为空！");
+        }
+        QueryWrapper<TkPreserveDetailEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkPreserveDetailEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkPreserveDetailEntity::getTenantId, tenantId.getId().toString());
+        lambda.eq(TkPreserveDetailEntity::getPreservePlanId, planId);
+        List<TkPreserveDetailEntity> entities = baseMapper.selectList(wrapper);
+        if (CollectionUtils.isNotEmpty(entities)) {
+            List<TkPreserveDetailDTO> dataList = entities.stream().map(item -> {
+                TkPreserveDetailDTO dto = item.getDTO(TkPreserveDetailDTO.class);
+                return dto;
+            }).collect(Collectors.toList());
+            return dataList;
+        } else {
+            return null;
+        }
+
+    }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.yunteng.core.exception.ThingsKitException;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveDetailDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreservePlanDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO;
+import org.thingsboard.server.common.data.yunteng.enums.PreservePlanStatusEnum;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TenantBaseEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkPreservePlanEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkPreservePlanMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveDetailService;
+import org.thingsboard.server.dao.yunteng.service.TkPreservePlanService;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveRecordServcie;
+
+import javax.transaction.Transactional;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkPreservePlanServiceImpl extends AbstractBaseService<TkPreservePlanMapper, TkPreservePlanEntity>
+        implements TkPreservePlanService {
+
+    private final TkPreserveDetailService tkPreserveDetailService;
+
+    private final TkPreserveRecordServcie tkPreserveRecordServcie;
+
+    @Override
+    public TkPageData<TkPreservePlanDTO> page(TkPreservePlanDTO condition) throws ThingsboardException {
+        QueryWrapper<TkPreservePlanEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkPreservePlanEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkPreservePlanEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isNotBlank(condition.getPreserveName())) {
+            lambda.like(TkPreservePlanEntity::getPreserveName, condition.getPreserveName());
+        }
+
+        lambda.orderByDesc(TenantBaseEntity::getCreateTime);
+
+        Page<TkPreservePlanEntity> page = new Page<>();
+        page.setCurrent(condition.getPage());
+        page.setSize(condition.getPageSize());
+        page = baseMapper.selectPage(page, wrapper);
+
+        return getPageData(page, TkPreservePlanDTO.class);
+    }
+
+    @Override
+    @Transactional
+    public TkPreservePlanDTO save(TkPreservePlanDTO dto) throws ThingsboardException {
+        checkDto(dto);
+        Boolean isAdd = false;
+        TkPreservePlanEntity entity = new TkPreservePlanEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+            isAdd = true;
+        } else {
+            LambdaQueryWrapper<TkPreservePlanEntity> filter = new QueryWrapper<TkPreservePlanEntity>().lambda()
+                    .eq(TkPreservePlanEntity::getId, dto.getId());
+            entity = dto.getEntity(TkPreservePlanEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        String id = dto.getId();
+        List<TkPreserveDetailDTO> preserveDetailList = dto.getPreserveDetailList();
+        if (CollectionUtils.isNotEmpty(preserveDetailList)) {
+            List<String> detailIds = preserveDetailList.stream().filter(e -> StringUtils.isNotBlank(e.getId()))
+                    .map(TkPreserveDetailDTO::getId).collect(Collectors.toList());
+            if (CollectionUtils.isNotEmpty(detailIds) && isAdd == false) {
+                tkPreserveDetailService.deleteNotInIdEqPlanId(id, detailIds);
+            }
+            for (TkPreserveDetailDTO detailDto : preserveDetailList) {
+                detailDto.setPreservePlanId(id);
+                tkPreserveDetailService.save(detailDto);
+            }
+        }
+
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    @Override
+    public TkPreservePlanDTO load(String id) {
+        TkPreservePlanDTO result = null;
+        TkPreservePlanEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkPreservePlanDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    private void checkDto(TkPreservePlanDTO dto) throws ThingsboardException {
+        if (StringUtils.isBlank(dto.getPreserveName())) {
+            throw new TkDataValidationException("计划名称不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getFrequency())) {
+            throw new TkDataValidationException("频率不能为空！");
+        }
+
+        if (dto.getTimes() == null) {
+            throw new TkDataValidationException("次数不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+
+        if (StringUtils.isBlank(dto.getStatus())) {
+            dto.setStatus(PreservePlanStatusEnum.NOTSTART.name());
+        }
+    }
+
+    @Override
+    public TkPreservePlanDTO detail(String id) throws ThingsboardException {
+        TkPreservePlanDTO dto = load(id);
+        List<TkPreserveDetailDTO> detailList = tkPreserveDetailService.listByPlanId(id);
+        dto.setPreserveDetailList(detailList);
+        return dto;
+    }
+
+    @Override
+    public void updateStatus(String id, String status) throws ThingsboardException {
+        TkPreservePlanEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("保养计划不存在！");
+        }
+        PreservePlanStatusEnum statusEnum = PreservePlanStatusEnum.valueOf(status);
+        if (statusEnum == null) {
+            throw new TkDataValidationException("保养计划状态不存在！");
+        }
+        entity.setStatus(statusEnum.name());
+        LambdaQueryWrapper<TkPreservePlanEntity> filter = new QueryWrapper<TkPreservePlanEntity>().lambda()
+                .eq(TkPreservePlanEntity::getId, entity.getId());
+        baseMapper.update(entity, filter);
+    }
+
+    @Override
+    @Transactional
+    public boolean delete(String id) throws ThingsboardException {
+        List<TkPreserveRecordDTO> recordList = tkPreserveRecordServcie.listByPlanId(id);
+        if (CollectionUtils.isNotEmpty(recordList)) {
+            throw new TkDataValidationException("该计划存在关联的保养记录，不能删除！");
+        }
+        tkPreserveDetailService.deleteByPlanId(id);
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.TenantId;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreservePlanDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO;
+import org.thingsboard.server.common.data.yunteng.dto.UserDTO;
+import org.thingsboard.server.common.data.yunteng.enums.PreservePlanStatusEnum;
+import org.thingsboard.server.common.data.yunteng.enums.PreserveRecordStatusEnum;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveRecordEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkPreserveRecordMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkPreservePlanService;
+import org.thingsboard.server.dao.yunteng.service.TkPreserveRecordServcie;
+import org.thingsboard.server.dao.yunteng.service.TkUserService;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkPreserveRecordServcieImpl extends AbstractBaseService<TkPreserveRecordMapper, TkPreserveRecordEntity>
+        implements TkPreserveRecordServcie {
+
+    private final TkUserService tkUserService;
+
+    @Override
+    public TkPageData<TkPreserveRecordDTO> page(Map<String, Object> params) throws ThingsboardException {
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        params.put("tenantId", tenantId.getId().toString());
+        TkPageData<TkPreserveRecordDTO> result = new TkPageData<>();
+        IPage<TkPreserveRecordEntity> page =
+                getPage(params, "create_time", false);
+
+        IPage<TkPreserveRecordDTO> pageData = baseMapper.getPreserveRecordPage(page, params);
+        if (pageData != null) {
+            result.setItems(pageData.getRecords());
+        }
+        result.setTotal(Long.valueOf(pageData.getTotal()).intValue());
+        return result;
+    }
+
+    @Override
+    public TkPreserveRecordDTO save(TkPreserveRecordDTO dto) throws ThingsboardException {
+        checkDto(dto);
+
+        TkPreserveRecordEntity entity = new TkPreserveRecordEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkPreserveRecordEntity> filter = new QueryWrapper<TkPreserveRecordEntity>().lambda()
+                    .eq(TkPreserveRecordEntity::getId, dto.getId());
+            entity = dto.getEntity(TkPreserveRecordEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    private void checkDto(TkPreserveRecordDTO dto) throws ThingsboardException {
+
+        if (StringUtils.isBlank(dto.getPreservePlanId())) {
+            throw new TkDataValidationException("保养计划id不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getPreserveBy())) {
+            throw new TkDataValidationException("保养计划id不能为空！");
+        }
+
+        if (dto.getPreserveDate() == null) {
+            throw new TkDataValidationException("保养日期不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+
+        if (StringUtils.isBlank(dto.getPreserveStatus())) {
+            dto.setPreserveStatus(PreserveRecordStatusEnum.INCOMPLETE.name());
+        }
+    }
+
+    @Override
+    public TkPreserveRecordDTO load(String id) {
+        TkPreserveRecordDTO result = null;
+        TkPreserveRecordEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkPreserveRecordDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    @Override
+    public TkPreserveRecordDTO detail(String id) throws ThingsboardException {
+        Map<String, Object> params = new HashMap<>();
+        params.put("id", id);
+        TkPageData<TkPreserveRecordDTO> page = page(params);
+        if (page != null && CollectionUtils.isNotEmpty(page.getItems())) {
+            Optional<TkPreserveRecordDTO> first = page.getItems().stream().findFirst();
+            return first.get();
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public void updateStatus(String id, String status) throws ThingsboardException {
+        TkPreserveRecordEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("保养记录不存在！");
+        }
+        PreservePlanStatusEnum statusEnum = PreservePlanStatusEnum.valueOf(status);
+        if (statusEnum == null) {
+            throw new TkDataValidationException("保养记录状态不存在！");
+        }
+        entity.setPreserveStatus(statusEnum.name());
+        LambdaQueryWrapper<TkPreserveRecordEntity> filter = new QueryWrapper<TkPreserveRecordEntity>().lambda()
+                .eq(TkPreserveRecordEntity::getId, entity.getId());
+        baseMapper.update(entity, filter);
+    }
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    @Override
+    public List<TkPreserveRecordDTO> listByPlanId(String planId) throws ThingsboardException {
+        if (StringUtils.isBlank(planId)) {
+            throw new TkDataValidationException("方案id不能为空！");
+        }
+        QueryWrapper<TkPreserveRecordEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkPreserveRecordEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkPreserveRecordEntity::getTenantId, tenantId.getId().toString());
+        lambda.eq(TkPreserveRecordEntity::getPreservePlanId, planId);
+        List<TkPreserveRecordEntity> entities = baseMapper.selectList(wrapper);
+        if (CollectionUtils.isNotEmpty(entities)) {
+            List<TkPreserveRecordDTO> dataList = entities.stream().map(item -> {
+                TkPreserveRecordDTO dto = item.getDTO(TkPreserveRecordDTO.class);
+                return dto;
+            }).collect(Collectors.toList());
+            return dataList;
+        } else {
+            return null;
+        }
+    }
+}

@@ -14,11 +14,9 @@ import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidatio
 import org.thingsboard.server.common.data.yunteng.dto.DeviceDTO;
 import org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO;
 import org.thingsboard.server.common.data.yunteng.enums.RepairOrderStatusEnum;
-import org.thingsboard.server.common.data.yunteng.utils.CopyUtils;
 import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.yunteng.entities.TenantBaseEntity;
-import org.thingsboard.server.dao.yunteng.entities.TkDeviceEntity;
 import org.thingsboard.server.dao.yunteng.entities.TkRepairOrderEntity;
 import org.thingsboard.server.dao.yunteng.mapper.TkRepairOrderMapper;
 import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
@@ -30,9 +28,6 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
-import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
-import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
-
 @Service
 @RequiredArgsConstructor
 @Slf4j
@@ -100,7 +95,7 @@ public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderM
 
 
     @Override
-    public TkRepairOrderDTO save(TkRepairOrderDTO dto) {
+    public TkRepairOrderDTO save(TkRepairOrderDTO dto) throws ThingsboardException {
         checkDto(dto);
         if (dto.getReportDate() == null) {
             dto.setReportDate(LocalDateTime.now());
@@ -143,6 +138,7 @@ public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderM
         TkRepairOrderDTO result = null;
         TkRepairOrderEntity entity = baseMapper.selectById(id);
         if (entity != null) {
+            result=new TkRepairOrderDTO();
             entity.copyToDTO(result);
         }
         return result;
@@ -157,6 +153,7 @@ public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderM
         lambda.eq(TkRepairOrderEntity::getDeviceId, deviceId);
         TkRepairOrderEntity entity = baseMapper.selectOne(queryWrapper);
         if (entity != null) {
+            result=new TkRepairOrderDTO();
             entity.copyToDTO(result);
         }
         return result;
@@ -180,7 +177,7 @@ public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderM
         baseMapper.update(entity, filter);
     }
 
-    private void checkDto(TkRepairOrderDTO dto) {
+    private void checkDto(TkRepairOrderDTO dto) throws ThingsboardException {
         if (StringUtils.isBlank(dto.getDeviceId())) {
             throw new TkDataValidationException("设备不能为空！");
         }
@@ -190,7 +187,7 @@ public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderM
         }
 
         if (StringUtils.isBlank(dto.getTenantId())) {
-            throw new TkDataValidationException("租户id为空！");
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
         }
     }
 

@@ -12,6 +12,7 @@ import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidatio
 import org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO;
 import org.thingsboard.server.common.data.yunteng.dto.TkRepairRecordDTO;
 import org.thingsboard.server.common.data.yunteng.dto.UserDTO;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.yunteng.entities.TkRepairRecordEntity;
 import org.thingsboard.server.dao.yunteng.mapper.TkRepairRecordMapper;
@@ -56,7 +57,7 @@ public class TkRepairRecordServiceImpl extends AbstractBaseService<TkRepairRecor
     }
 
     @Override
-    public TkRepairRecordDTO save(TkRepairRecordDTO dto) {
+    public TkRepairRecordDTO save(TkRepairRecordDTO dto) throws ThingsboardException {
         checkDto(dto);
         if (dto.getRepairDate() == null) {
             dto.setRepairDate(LocalDateTime.now());
@@ -76,7 +77,7 @@ public class TkRepairRecordServiceImpl extends AbstractBaseService<TkRepairRecor
         return dto;
     }
 
-    private void checkDto(TkRepairRecordDTO dto) {
+    private void checkDto(TkRepairRecordDTO dto) throws ThingsboardException {
         if (StringUtils.isBlank(dto.getOrderId())) {
             throw new TkDataValidationException("维修工单不能为空！");
         }
@@ -86,7 +87,7 @@ public class TkRepairRecordServiceImpl extends AbstractBaseService<TkRepairRecor
         }
 
         if (StringUtils.isBlank(dto.getTenantId())) {
-            throw new TkDataValidationException("租户id为空！");
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
         }
     }
 

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveDetailEntity;
+
+@Mapper
+public interface TkPreserveDetailMapper extends BaseMapper<TkPreserveDetailEntity> {
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.thingsboard.server.dao.yunteng.entities.TkPreservePlanEntity;
+
+@Mapper
+public interface TkPreservePlanMapper  extends BaseMapper<TkPreservePlanEntity> {
+}

+package org.thingsboard.server.dao.yunteng.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveRecordEntity;
+
+import java.util.Map;
+
+@Mapper
+public interface TkPreserveRecordMapper  extends BaseMapper<TkPreserveRecordEntity> {
+    IPage<TkPreserveRecordDTO> getPreserveRecordPage(IPage<?> page, @Param("queryMap") Map<String, Object> queryMap);
+
+}

 package org.thingsboard.server.dao.yunteng.service;
 
 
+import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.yunteng.dto.TkMalfunctionReasonDTO;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.yunteng.entities.TkMalfunctionReasonEntity;
@@ -14,7 +15,7 @@ public interface TkMalfunctionReasonService extends BaseService<TkMalfunctionRea
 
     List<TkMalfunctionReasonDTO> list(String tenantId, Map<String, Object> queryMap);
 
-    TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO);
+    TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO) throws ThingsboardException;
 
     boolean delete(String id);
 

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveDetailDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveDetailEntity;
+
+import java.util.List;
+
+public interface TkPreserveDetailService extends BaseService<TkPreserveDetailEntity>{
+
+    TkPageData<TkPreserveDetailDTO> page(TkPreserveDetailDTO condition) throws ThingsboardException;
+
+    TkPreserveDetailDTO save(TkPreserveDetailDTO dto) throws ThingsboardException;
+
+    boolean delete(String id);
+
+    boolean deleteByPlanId(String planId);
+
+    void deleteNotInIdEqPlanId(String planId,List<String> notinIds);
+
+    List<TkPreserveDetailDTO> listByPlanId(String planId) throws ThingsboardException;
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreservePlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkPreservePlanEntity;
+
+public interface TkPreservePlanService  extends BaseService<TkPreservePlanEntity> {
+
+    TkPageData<TkPreservePlanDTO> page(TkPreservePlanDTO condition) throws ThingsboardException;
+
+    TkPreservePlanDTO save(TkPreservePlanDTO dto) throws ThingsboardException;
+
+    TkPreservePlanDTO load(String id);
+
+    TkPreservePlanDTO detail(String id) throws ThingsboardException;
+
+    void updateStatus(String id, String status) throws ThingsboardException;
+
+    boolean delete(String id) throws ThingsboardException;
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkPreserveRecordEntity;
+
+import java.util.List;
+import java.util.Map;
+
+public interface TkPreserveRecordServcie extends BaseService<TkPreserveRecordEntity>{
+
+    TkPageData<TkPreserveRecordDTO> page(Map<String, Object> params) throws ThingsboardException;
+
+    TkPreserveRecordDTO save(TkPreserveRecordDTO dto) throws ThingsboardException;
+
+    TkPreserveRecordDTO load(String id);
+
+    TkPreserveRecordDTO detail(String id) throws ThingsboardException;
+
+    void updateStatus(String id, String status) throws ThingsboardException;
+
+    boolean delete(String id);
+
+    List<TkPreserveRecordDTO> listByPlanId(String planId) throws ThingsboardException;
+}

 package org.thingsboard.server.dao.yunteng.service;
 
-
-import com.baomidou.mybatisplus.core.metadata.IPage;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
 import org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
@@ -14,7 +12,7 @@ public interface TkRepairOrderService extends BaseService<TkRepairOrderEntity> {
 
     TkPageData<TkRepairOrderDTO> page(String tenantId,Map<String, Object> params);
 
-    TkRepairOrderDTO save(TkRepairOrderDTO dto);
+    TkRepairOrderDTO save(TkRepairOrderDTO dto) throws ThingsboardException;
 
     TkRepairOrderDTO detail(String id) throws ThingsboardException;
 

@@ -9,7 +9,7 @@ public interface TkRepairRecordService extends BaseService<TkRepairRecordEntity>
 
     TkPageData<TkRepairRecordDTO> page(String tenantId, TkRepairRecordDTO params);
 
-    TkRepairRecordDTO save(TkRepairRecordDTO dto);
+    TkRepairRecordDTO save(TkRepairRecordDTO dto) throws ThingsboardException;
 
     TkRepairRecordDTO detail(String id) throws ThingsboardException;
 

+<?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="org.thingsboard.server.dao.yunteng.mapper.TkPreserveRecordMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.TkPreserveRecordDTO" id="preserveRecordMap">
+        <result property="preserveByName" column="preserveByName"/>
+        <result property="preservePlanName" column="preserveName"/>
+    </resultMap>
+    <select id="getPreserveRecordPage" resultMap="preserveRecordMap">
+        SELECT
+        r.record_code,r.preserve_plan_id,r.preserve_date,r.preserve_by,r.preserve_status
+        ,r.tenant_id,r.create_time,r.updater,r.update_time,r.creator
+        ,su.real_name as preserveByName,p.preserve_name as preserveName
+        from qg_preserve_record r
+        inner join sys_user su on su.id=r.preserve_by
+        inner join qg_preserve_plan p on p.id=r.preserve_plan_id
+        <where>
+            <if test="queryMap.id !=null ">
+                AND r.id = #{queryMap.id}
+            </if>
+            <if test="queryMap.tenantId !=null ">
+                AND r.tenant_id = #{queryMap.tenantId}
+            </if>
+            <if test="queryMap.preserve_plan_id !=null ">
+                AND r.status = #{queryMap.preservePlanId}
+            </if>
+            <if test="queryMap.preserve_by !=null ">
+                AND r.device_id = #{queryMap.preserveBy}
+            </if>
+            <if test="queryMap.preserve_status !=null ">
+                AND r.emergency = #{queryMap.preserveStatus}
+            </if>
+            <if test="queryMap.startDate !=null ">
+                AND to_char(r.preserve_date, 'YYYY-MM-DD HH24:MI:SS') &gt;= #{queryMap.startDate}
+            </if>
+            <if test="queryMap.endDate !=null ">
+                AND to_char(r.preserve_date, 'YYYY-MM-DD HH24:MI:SS') &lt;= #{queryMap.endDate}
+            </if>
+        </where>
+    </select>
+</mapper>
\ No newline at end of file

@@ -3,12 +3,6 @@
 
 <mapper namespace="org.thingsboard.server.dao.yunteng.mapper.TkRepairOrderMapper">
     <resultMap type="org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO" id="repairOrderMap">
-        <!--        <result property="id" column="id"/>-->
-        <!--        <result property="reportDate" column="report_date"/>-->
-        <!--        <result property="deviceId" column="device_id"/>-->
-        <!--        <result property="reportBy" column="report_by"/>-->
-        <!--        <result property="emergency" column="emergency"/>-->
-        <!--        <result property="description" column="description"/>-->
         <result property="reportByName" column="reportByName"/>
     </resultMap>
     <select id="getRepairOrderPage" resultMap="repairOrderMap">