Merge branch 'test_ymk_from_0102' into test_hhl_0102

# Conflicts:
#	application/src/main/data/sql/qg.sql

@@ -103,6 +103,7 @@ CREATE TABLE "public"."qg_inspection_plan"
     "status"      varchar(50) NOT NULL,
     "start_time"  timestamp(6),
     "end_time"    timestamp(6),
+    "tenant_id"   varchar(36),
     "create_time" timestamp(6),
     "creator"     varchar(36),
     "updater"     varchar(36),
@@ -117,6 +118,7 @@ COMMENT ON COLUMN "public"."qg_inspection_plan"."name" IS '计划名称';
 COMMENT ON COLUMN "public"."qg_inspection_plan"."status" IS '计划状态';
 COMMENT ON COLUMN "public"."qg_inspection_plan"."start_time" IS '开始日期';
 COMMENT ON COLUMN "public"."qg_inspection_plan"."end_time" IS '结束日期';
+COMMENT ON COLUMN "public"."qg_inspection_plan"."tenant_id" IS '租户ID';
 COMMENT ON COLUMN "public"."qg_inspection_plan"."remark" IS '计划备注';
 
 CREATE TABLE "public"."qg_check_plan"
@@ -127,6 +129,7 @@ CREATE TABLE "public"."qg_check_plan"
     "type"         varchar(50),
     "status"       varchar(50),
     "plan_details" varchar(255),
+    "tenant_id"    varchar(36),
     "create_time"  timestamp(6),
     "creator"      varchar(36),
     "updater"      varchar(36),
@@ -140,6 +143,7 @@ COMMENT ON COLUMN "public"."qg_check_plan"."name" IS '方案名称';
 COMMENT ON COLUMN "public"."qg_check_plan"."type" IS '方案类型';
 COMMENT ON COLUMN "public"."qg_check_plan"."status" IS '状态';
 COMMENT ON COLUMN "public"."qg_check_plan"."plan_details" IS '方案明细';
+COMMENT ON COLUMN "public"."qg_check_plan"."tenant_id" IS '租户ID';
 
 CREATE TABLE "public"."qg_check_details"
 (
@@ -149,6 +153,8 @@ CREATE TABLE "public"."qg_check_details"
     "check_plan_id"      varchar(36),
     "inspection_plan_id" varchar(36),
     "plan_details"       varchar(255),
+    "show_order"         int4,
+    "tenant_id"          varchar(36),
     "create_time"        timestamp(6),
     "creator"            varchar(36),
     "updater"            varchar(36),
@@ -162,15 +168,18 @@ COMMENT ON COLUMN "public"."qg_check_details"."check_device_id" IS '巡检设备
 COMMENT ON COLUMN "public"."qg_check_details"."check_plan_id" IS '巡检方案';
 COMMENT ON COLUMN "public"."qg_check_details"."inspection_plan_id" IS '巡检计划';
 COMMENT ON COLUMN "public"."qg_check_details"."plan_details" IS '方案明细';
+COMMENT ON COLUMN "public"."qg_check_details"."show_order" IS '排序';
+COMMENT ON COLUMN "public"."qg_check_details"."tenant_id" IS '租户ID';
 
 CREATE TABLE "public"."qg_inspection_record"
 (
     "id"                 varchar(36) PRIMARY KEY,
     "code"               varchar(50) NOT NULL,
     "inspection_plan_id" varchar(36),
-    "tenant_id"          varchar(36),
+    "inspector_id"       varchar(36),
     "check_date"         timestamp(6),
     "record_result"      bool,
+    "tenant_id"          varchar(36),
     "create_time"        timestamp(6),
     "creator"            varchar(36),
     "updater"            varchar(36),
@@ -181,20 +190,24 @@ COMMENT ON TABLE "public"."qg_inspection_record" IS '巡检记录';
 COMMENT ON COLUMN "public"."qg_inspection_record"."id" IS '主键ID';
 COMMENT ON COLUMN "public"."qg_inspection_record"."code" IS '记录编号';
 COMMENT ON COLUMN "public"."qg_inspection_record"."inspection_plan_id" IS '巡检计划';
-COMMENT ON COLUMN "public"."qg_inspection_record"."tenant_id" IS '巡检人';
-COMMENT ON COLUMN "public"."qg_inspection_record"."check_date" IS '巡检结果';
+COMMENT ON COLUMN "public"."qg_inspection_record"."inspector_id" IS '巡检人';
+COMMENT ON COLUMN "public"."qg_inspection_record"."check_date" IS '巡检日期';
 COMMENT ON COLUMN "public"."qg_inspection_record"."record_result" IS '巡检结果';
+COMMENT ON COLUMN "public"."qg_inspection_record"."tenant_id" IS '租户ID';
 
 CREATE TABLE "public"."qg_inspection_details"
 (
-    "id"              varchar(36) PRIMARY KEY,
-    "check_device_id" varchar(36),
-    "plan_details"    varchar(255),
-    "record_result"   bool,
-    "create_time"     timestamp(6),
-    "creator"         varchar(36),
-    "updater"         varchar(36),
-    "update_time"     timestamp(6)
+    "id"                   varchar(36) PRIMARY KEY,
+    "check_device_id"      varchar(36),
+    "plan_details"         varchar(255),
+    "record_result"        bool,
+    "show_order"           int4,
+    "inspection_record_id" varchar(36),
+    "tenant_id"            varchar(36),
+    "create_time"          timestamp(6),
+    "creator"              varchar(36),
+    "updater"              varchar(36),
+    "update_time"          timestamp(6)
 );
 
 COMMENT ON TABLE "public"."qg_inspection_details" IS '巡检记录明细';
@@ -202,6 +215,9 @@ 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 '巡检结果';
+COMMENT ON COLUMN "public"."qg_inspection_details"."show_order" IS '排序';
+COMMENT ON COLUMN "public"."qg_inspection_details"."inspection_record_id" IS '巡检记录';
+COMMENT ON COLUMN "public"."qg_inspection_details"."tenant_id" IS '租户ID';
 
 CREATE TABLE "public"."qg_preserve_detail" (
    "id" varchar(36)  NOT NULL,

+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.apache.commons.lang3.StringUtils;
+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.dto.TkCheckPlanDTO;
+import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanStatusEnum;
+import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanTypeEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkCheckPlanService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+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/checkPlan")
+@Api(tags = {"巡检/保养方案"})
+@Slf4j
+public class TkCheckPlanController extends BaseController {
+    private final TkCheckPlanService tkCheckPlanService;
+
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    @ApiOperation("分页查询")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public TkPageData<TkCheckPlanDTO> page(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "name", required = false) String name,
+            @RequestParam(value = "type", required = false) TkCheckPlanTypeEnum type,
+            @RequestParam(value = "status", required = false) TkCheckPlanStatusEnum status
+    ) throws ThingsboardException {
+        Map<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE_SIZE, pageSize);
+        queryMap.put(PAGE, page);
+        if (StringUtils.isNotBlank(name)) {
+            queryMap.put("name", name);
+        }
+
+        if (type != null) {
+            queryMap.put("type", type);
+        }
+
+        if (status != null) {
+            queryMap.put("status", status);
+        }
+
+        return tkCheckPlanService.page(queryMap, getCurrentUser().isTenantAdmin());
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkCheckPlanDTO> save(@RequestBody TkCheckPlanDTO tkCheckPlanDTO) throws ThingsboardException {
+        tkCheckPlanDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        if (tkCheckPlanDTO.getStatus() == null) {
+            tkCheckPlanDTO.setStatus(TkCheckPlanStatusEnum.ENABLE);
+        }
+
+        TkCheckPlanDTO dto = tkCheckPlanService.save(tkCheckPlanDTO);
+        return ResponseEntity.ok(dto);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkCheckPlanService.delete(id));
+    }
+
+    @GetMapping("/get")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkCheckPlanDTO> get(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkCheckPlanService.get(id));
+    }
+}

+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.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+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.dto.TkInspectionPlanDTO;
+import org.thingsboard.server.common.data.yunteng.enums.TkInspectionPlanStatusEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionPlanService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+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/inspectionPlan")
+@Api(tags = {"巡检计划"})
+@Slf4j
+public class TkInspectionPlanController extends BaseController {
+    private final TkInspectionPlanService tkInspectionPlanService;
+
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    @ApiOperation("分页查询")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public TkPageData<TkInspectionPlanDTO> page(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "name", required = false) String name,
+            @RequestParam(value = "type", required = false) TkInspectionPlanStatusEnum status,
+            @RequestParam(value = "startTime", required = false) Long startTime,
+            @RequestParam(value = "endTime", required = false) Long endTime
+    ) throws ThingsboardException {
+        Map<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE_SIZE, pageSize);
+        queryMap.put(PAGE, page);
+        if (StringUtils.isNotBlank(name)) {
+            queryMap.put("name", name);
+        }
+
+        if (status != null) {
+            queryMap.put("status", status);
+        }
+
+        checkTimeAndPut(queryMap, startTime, endTime);
+        return tkInspectionPlanService.page(queryMap, getCurrentUser().isTenantAdmin());
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkInspectionPlanDTO> save(@RequestBody TkInspectionPlanDTO tkInspectionPlanDTO) throws ThingsboardException {
+        tkInspectionPlanDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        if (tkInspectionPlanDTO.getStatus() == null) {
+            tkInspectionPlanDTO.setStatus(TkInspectionPlanStatusEnum.NOT_START);
+        }
+
+        if (CollectionUtils.isNotEmpty(tkInspectionPlanDTO.getTkCheckDetailsDTOList())) {
+            tkInspectionPlanDTO.getTkCheckDetailsDTOList()
+                    .forEach(tkCheckDetailsDTO -> tkCheckDetailsDTO.setTenantId(tkCheckDetailsDTO.getTenantId()));
+        }
+
+        TkInspectionPlanDTO dto = tkInspectionPlanService.save(tkInspectionPlanDTO);
+        return ResponseEntity.ok(dto);
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkInspectionPlanDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkInspectionPlanService.get(id));
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkInspectionPlanService.delete(id));
+    }
+}

+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.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+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.dto.TkInspectionRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionRecordService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.HashMap;
+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/inspectionRecord")
+@Api(tags = {"巡检记录"})
+@Slf4j
+public class TkInspectionRecordController extends BaseController {
+    private final TkInspectionRecordService tkInspectionRecordService;
+
+    @GetMapping(params = {PAGE_SIZE, PAGE})
+    @ApiOperation("分页查询")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public TkPageData<TkInspectionRecordDTO> page(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestParam(value = "inspectionPlanId", required = false) String inspectionPlanId,
+            @RequestParam(value = "inspectorId", required = false) String inspectorId,
+            @RequestParam(value = "startTime", required = false) Long startTime,
+            @RequestParam(value = "endTime", required = false) Long endTime,
+            @RequestParam(value = "recordResult", required = false) Boolean recordResult
+    ) throws ThingsboardException {
+        Map<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE_SIZE, pageSize);
+        queryMap.put(PAGE, page);
+        if (StringUtils.isNotBlank(inspectionPlanId)) {
+            queryMap.put("inspectionPlanId", inspectionPlanId);
+        }
+
+        if (StringUtils.isNotBlank(inspectorId)) {
+            queryMap.put("inspectorId", inspectorId);
+        }
+
+        if (recordResult != null) {
+            queryMap.put("recordResult", recordResult);
+        }
+
+        checkTimeAndPut(queryMap, startTime, endTime);
+        return tkInspectionRecordService.page(queryMap, getCurrentUser().isTenantAdmin());
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkInspectionRecordDTO> save(@RequestBody TkInspectionRecordDTO tkInspectionRecordDTO) throws ThingsboardException {
+        tkInspectionRecordDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        if (CollectionUtils.isNotEmpty(tkInspectionRecordDTO.getTkInspectionDetailsDTOList())) {
+            tkInspectionRecordDTO.getTkInspectionDetailsDTOList()
+                    .forEach(tkInspectionDetailsDTO -> tkInspectionDetailsDTO.setTenantId(tkInspectionRecordDTO.getTenantId()));
+        }
+
+        TkInspectionRecordDTO dto = tkInspectionRecordService.save(tkInspectionRecordDTO);
+        return ResponseEntity.ok(dto);
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkInspectionRecordDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkInspectionRecordService.get(id));
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkInspectionRecordService.delete(id));
+    }
+
+}

+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 TkCheckDetailsDTO extends TenantDTO {
+
+    @ApiModelProperty("明细编号")
+    private String code;
+
+    @ApiModelProperty("巡检设备")
+    private String checkDeviceId;
+
+    @ApiModelProperty("巡检方案")
+    private String checkPlanId;
+
+    @ApiModelProperty("巡检计划")
+    private String inspectionPlanId;
+
+    @ApiModelProperty("方案明细")
+    private String planDetails;
+
+    @ApiModelProperty("排序")
+    private int showOrder;
+}

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanStatusEnum;
+import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanTypeEnum;
+
+/**
+ * 巡检/保养方案
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkCheckPlanDTO extends TenantDTO {
+
+    @ApiModelProperty("方案编号")
+    private String code;
+
+    @ApiModelProperty("方案名称")
+    private String name;
+
+    @ApiModelProperty("方案类型")
+    private TkCheckPlanTypeEnum type;
+
+    @ApiModelProperty("状态")
+    private TkCheckPlanStatusEnum status;
+
+    @ApiModelProperty("方案明细")
+    private String planDetails;
+}

+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 TkInspectionDetailsDTO extends TenantDTO {
+
+    @ApiModelProperty("巡检设备")
+    private String checkDeviceId;
+
+    @ApiModelProperty("巡检内容")
+    private String planDetails;
+
+    @ApiModelProperty("巡检结果")
+    private boolean recordResult;
+
+    @ApiModelProperty("巡检记录")
+    private String inspectionRecordId;
+
+    @ApiModelProperty("排序")
+    private int showOrder;
+}

+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 org.thingsboard.server.common.data.yunteng.enums.TkInspectionPlanStatusEnum;
+
+import java.time.LocalDateTime;
+import java.util.List;
+
+/**
+ * 巡检计划
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkInspectionPlanDTO extends TenantDTO {
+
+    @ApiModelProperty("计划编号")
+    private String code;
+
+    @ApiModelProperty("计划名称")
+    private String name;
+
+    @ApiModelProperty("计划状态")
+    private TkInspectionPlanStatusEnum status;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty("开始日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime startTime;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty("结束日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime endTime;
+
+    @ApiModelProperty("计划备注")
+    private String remark;
+
+    @ApiModelProperty("巡检明细")
+    private List<TkCheckDetailsDTO> tkCheckDetailsDTOList;
+}

+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;
+import java.util.List;
+
+/**
+ * 巡检记录
+ */
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkInspectionRecordDTO extends TenantDTO {
+
+    @ApiModelProperty("记录编号")
+    private String code;
+
+    @ApiModelProperty("巡检计划")
+    private String inspectionPlanId;
+
+    @ApiModelProperty("巡检人")
+    private String inspectorId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "巡检日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime checkDate;
+
+    @ApiModelProperty("巡检结果")
+    private boolean recordResult;
+
+    @ApiModelProperty("巡检记录明细")
+    private List<TkInspectionDetailsDTO> tkInspectionDetailsDTOList;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "巡检日期-筛选开始日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime startTime;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "巡检日期-筛选结束日期")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime endTime;
+}

+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.TKCHECKDETAILS_TABLE_NAME, autoResultMap = true)
+public class TkCheckDetailsEntity extends TenantBaseEntity {
+
+    /**
+     * 明细编号
+     */
+    private String code;
+
+    /**
+     * 巡检设备
+     */
+    private String checkDeviceId;
+
+    /**
+     * 巡检方案
+     */
+    private String checkPlanId;
+
+    /**
+     * 巡检计划
+     */
+    private String inspectionPlanId;
+
+    /**
+     * 方案明细
+     */
+    private String planDetails;
+
+    /**
+     * 排序
+     */
+    private int showOrder;
+}

 package org.thingsboard.server.dao.yunteng.entities;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import org.apache.ibatis.type.EnumTypeHandler;
 import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanStatusEnum;
 import org.thingsboard.server.common.data.yunteng.enums.TkCheckPlanTypeEnum;
 import org.thingsboard.server.dao.model.ModelConstants;
@@ -14,9 +16,31 @@ import org.thingsboard.server.dao.model.ModelConstants;
 @EqualsAndHashCode(callSuper = true)
 @TableName(value = ModelConstants.TKCHECKPLAN_TABLE_NAME, autoResultMap = true)
 public class TkCheckPlanEntity extends TenantBaseEntity {
+
+    /**
+     * 方案编号
+     */
     private String code;
+
+    /**
+     * 方案名称
+     */
     private String name;
+
+    /**
+     * 方案类型
+     */
+    @TableField(typeHandler = EnumTypeHandler.class)
     private TkCheckPlanTypeEnum type;
+
+    /**
+     * 状态
+     */
+    @TableField(typeHandler = EnumTypeHandler.class)
     private TkCheckPlanStatusEnum status;
+
+    /**
+     * 方案明细
+     */
     private String planDetails;
 }

+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.TKINSPECTIONDETAILS_TABLE_NAME, autoResultMap = true)
+public class TkInspectionDetailsEntity extends TenantBaseEntity {
+
+    /**
+     * 巡检设备
+     */
+    private String checkDeviceId;
+
+    /**
+     * 巡检内容
+     */
+    private String planDetails;
+
+    /**
+     * 巡检结果
+     */
+    private boolean recordResult;
+
+    /**
+     * 巡检记录
+     */
+    private String inspectionRecordId;
+
+    /**
+     * 排序
+     */
+    private int showOrder;
+}

 package org.thingsboard.server.dao.yunteng.entities;
 
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import org.apache.ibatis.type.EnumTypeHandler;
 import org.thingsboard.server.common.data.yunteng.enums.TkInspectionPlanStatusEnum;
 import org.thingsboard.server.dao.model.ModelConstants;
 
@@ -15,9 +17,35 @@ import java.time.LocalDateTime;
 @EqualsAndHashCode(callSuper = true)
 @TableName(value = ModelConstants.TKINSPECTIONPLAN_TABLE_NAME, autoResultMap = true)
 public class TkInspectionPlanEntity extends TenantBaseEntity {
+
+    /**
+     * 计划编号
+     */
     private String code;
+
+    /**
+     * 计划名称
+     */
     private String name;
+
+    /**
+     * 计划状态
+     */
+    @TableField(typeHandler = EnumTypeHandler.class)
     private TkInspectionPlanStatusEnum status;
+
+    /**
+     * 开始日期
+     */
     private LocalDateTime startTime;
+
+    /**
+     * 结束日期
+     */
     private LocalDateTime endTime;
+
+    /**
+     * 计划备注
+     */
+    private String remark;
 }

+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.TKINSPECTIONRECORD_TABLE_NAME, autoResultMap = true)
+public class TkInspectionRecordEntity extends TenantBaseEntity {
+
+    /**
+     * 记录编号
+     */
+    private String code;
+
+    /**
+     * 巡检计划
+     */
+    private String inspectionPlanId;
+
+    /**
+     * 巡检人
+     */
+    private String inspectorId;
+
+    /**
+     * 巡检日期
+     */
+    private LocalDateTime checkDate;
+
+    /**
+     * 巡检结果
+     */
+    private boolean recordResult;
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+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.yunteng.dto.TkCheckDetailsDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkCheckDetailsEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkCheckDetailsMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkCheckDetailsService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkCheckDetailsServiceImpl extends AbstractBaseService<TkCheckDetailsMapper, TkCheckDetailsEntity>
+        implements TkCheckDetailsService {
+    @Override
+    public List<TkCheckDetailsDTO> batchSave(List<TkCheckDetailsDTO> checkDetailsDTOList, String inspectionPlanId) {
+        List<TkCheckDetailsDTO> oldTkCheckDetailsDTOList = listByInspectionPlanId(inspectionPlanId);
+        if (CollectionUtils.isEmpty(checkDetailsDTOList) && CollectionUtils.isNotEmpty(oldTkCheckDetailsDTOList)) {
+            List<String> checkDetailsIdList = oldTkCheckDetailsDTOList.stream()
+                    .map(TkCheckDetailsDTO::getId)
+                    .collect(Collectors.toList());
+            baseMapper.deleteBatchIds(checkDetailsIdList);
+            return new ArrayList<>(0);
+        }
+
+        if (CollectionUtils.isEmpty(oldTkCheckDetailsDTOList) && CollectionUtils.isNotEmpty(checkDetailsDTOList)) {
+            List<TkCheckDetailsEntity> tkCheckDetailsEntityList = checkDetailsDTOList.stream().map(checkDetailsDTO -> {
+                TkCheckDetailsEntity entity = new TkCheckDetailsEntity();
+                checkDetailsDTO.copyToEntity(entity);
+                return entity;
+            }).collect(Collectors.toList());
+
+            insertBatch(tkCheckDetailsEntityList, TkCheckDetailsEntity.class);
+            return listByInspectionPlanId(inspectionPlanId);
+        }
+
+        List<TkCheckDetailsEntity> addEntityList = new ArrayList<>(checkDetailsDTOList.size());
+        List<TkCheckDetailsEntity> updateEntityList = new ArrayList<>(checkDetailsDTOList.size());
+        List<String> needDeleteIdList = new ArrayList<>(checkDetailsDTOList.size());
+        List<String> checkDetailsIdList = CollectionUtils.emptyIfNull(oldTkCheckDetailsDTOList).stream()
+                .map(TkCheckDetailsDTO::getId)
+                .collect(Collectors.toList());
+        for (TkCheckDetailsDTO tkCheckDetailsDTO : checkDetailsDTOList) {
+            TkCheckDetailsEntity entity = new TkCheckDetailsEntity();
+            tkCheckDetailsDTO.copyToEntity(entity);
+            if (StringUtils.isBlank(entity.getId())) {
+                addEntityList.add(entity);
+                continue;
+            }
+
+            if (checkDetailsIdList.contains(entity.getId())) {
+                updateEntityList.add(entity);
+            }
+        }
+
+
+        if (CollectionUtils.isNotEmpty(addEntityList)) {
+            insertBatch(addEntityList, TkCheckDetailsEntity.class);
+        }
+
+        if (CollectionUtils.isNotEmpty(updateEntityList)) {
+            updateEntityList.forEach(tkCheckDetailsEntity -> baseMapper.updateById(tkCheckDetailsEntity));
+            List<String> updateIdList = updateEntityList.stream().map(TkCheckDetailsEntity::getId).collect(Collectors.toList());
+            checkDetailsIdList.removeAll(updateIdList);
+            needDeleteIdList.addAll(checkDetailsIdList);
+        } else {
+            needDeleteIdList = checkDetailsIdList;
+        }
+
+        if (CollectionUtils.isNotEmpty(needDeleteIdList)) {
+            baseMapper.deleteBatchIds(needDeleteIdList);
+        }
+
+        return listByInspectionPlanId(inspectionPlanId);
+    }
+
+    @Override
+    public List<TkCheckDetailsDTO> listByInspectionPlanId(String inspectionPlanId) {
+        if (StringUtils.isBlank(inspectionPlanId)) {
+            return new ArrayList<>(0);
+        }
+
+        QueryWrapper<TkCheckDetailsEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkCheckDetailsEntity> lambda = wrapper.lambda();
+        lambda.eq(TkCheckDetailsEntity::getInspectionPlanId, inspectionPlanId);
+        lambda.orderByAsc(TkCheckDetailsEntity::getShowOrder);
+        List<TkCheckDetailsEntity> tkCheckDetailsEntitieList = baseMapper.selectList(wrapper);
+        return CollectionUtils.emptyIfNull(tkCheckDetailsEntitieList).stream().map(entity -> {
+            TkCheckDetailsDTO tkCheckDetailsDTO = new TkCheckDetailsDTO();
+            entity.copyToDTO(tkCheckDetailsDTO);
+            return tkCheckDetailsDTO;
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public void deleteByInspectionPlanId(String inspectionPlanId) {
+        if (StringUtils.isBlank(inspectionPlanId)) {
+            return;
+        }
+
+        QueryWrapper<TkCheckDetailsEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkCheckDetailsEntity> lambda = wrapper.lambda();
+        lambda.eq(TkCheckDetailsEntity::getInspectionPlanId, inspectionPlanId);
+        baseMapper.delete(wrapper);
+    }
+}

+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.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+import org.thingsboard.server.common.data.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkCheckPlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkCheckPlanEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkCheckPlanMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkCheckPlanService;
+
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkCheckPlanServiceImpl extends AbstractBaseService<TkCheckPlanMapper, TkCheckPlanEntity>
+        implements TkCheckPlanService {
+    @Override
+    public TkPageData<TkCheckPlanDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin) {
+        QueryWrapper<TkCheckPlanEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkCheckPlanEntity> lambda = wrapper.lambda();
+        if (queryMap != null && queryMap.get("name") != null) {
+            lambda.eq(TkCheckPlanEntity::getName, queryMap.get("name").toString());
+        }
+
+        if (queryMap != null && queryMap.get("type") != null) {
+            lambda.eq(TkCheckPlanEntity::getType, queryMap.get("type").toString());
+        }
+
+        if (queryMap != null && queryMap.get("status") != null) {
+            lambda.eq(TkCheckPlanEntity::getStatus, queryMap.get("status").toString());
+        }
+
+        IPage<TkCheckPlanEntity> page = baseMapper.selectPage(getPage(queryMap, "create_time", false),
+                wrapper);
+
+        return getPageData(page, TkCheckPlanDTO.class);
+    }
+
+    @Override
+    public TkCheckPlanDTO save(TkCheckPlanDTO tkCheckPlanDTO) {
+        checkDto(tkCheckPlanDTO);
+        TkCheckPlanEntity entity = new TkCheckPlanEntity();
+        if (StringUtils.isBlank(tkCheckPlanDTO.getId())) {
+            tkCheckPlanDTO.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkCheckPlanEntity> filter = new QueryWrapper<TkCheckPlanEntity>().lambda()
+                    .eq(TkCheckPlanEntity::getId, tkCheckPlanDTO.getId());
+            entity = tkCheckPlanDTO.getEntity(TkCheckPlanEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+        entity.copyToDTO(tkCheckPlanDTO);
+        return tkCheckPlanDTO;
+    }
+
+    private void checkDto(TkCheckPlanDTO dto) {
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    @Override
+    public TkCheckPlanDTO get(String id) {
+        if (StringUtils.isBlank(id)) {
+            return new TkCheckPlanDTO();
+        }
+
+        TkCheckPlanEntity entity = baseMapper.selectById(id);
+        TkCheckPlanDTO tkCheckPlanDTO = new TkCheckPlanDTO();
+        entity.copyToDTO(tkCheckPlanDTO);
+        return tkCheckPlanDTO;
+    }
+}

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+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.yunteng.dto.TkInspectionDetailsDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionDetailsEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkInspectionDetailsMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionDetailsService;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkInspectionDetailsServiceImpl extends AbstractBaseService<TkInspectionDetailsMapper, TkInspectionDetailsEntity>
+        implements TkInspectionDetailsService {
+    @Override
+    public List<TkInspectionDetailsDTO> batchSave(List<TkInspectionDetailsDTO> tkInspectionDetailsDTOList, String inspectionRecordId) {
+        List<TkInspectionDetailsDTO> oldTkInspectionDetailsDTOList = listByInspectionRecordId(inspectionRecordId);
+        if (CollectionUtils.isEmpty(tkInspectionDetailsDTOList) && CollectionUtils.isNotEmpty(oldTkInspectionDetailsDTOList)) {
+            List<String> inspectionDetailsIdList = oldTkInspectionDetailsDTOList.stream()
+                    .map(TkInspectionDetailsDTO::getId)
+                    .collect(Collectors.toList());
+            baseMapper.deleteBatchIds(inspectionDetailsIdList);
+            return new ArrayList<>(0);
+        }
+
+        if (CollectionUtils.isEmpty(oldTkInspectionDetailsDTOList) && CollectionUtils.isNotEmpty(tkInspectionDetailsDTOList)) {
+            List<TkInspectionDetailsEntity> tkInspectionDetailsEntityList = tkInspectionDetailsDTOList.stream().map(tkInspectionDetailsDTO -> {
+                TkInspectionDetailsEntity entity = new TkInspectionDetailsEntity();
+                tkInspectionDetailsDTO.copyToEntity(entity);
+                return entity;
+            }).collect(Collectors.toList());
+
+            insertBatch(tkInspectionDetailsEntityList, TkInspectionDetailsEntity.class);
+            return listByInspectionRecordId(inspectionRecordId);
+        }
+
+        List<TkInspectionDetailsEntity> addEntityList = new ArrayList<>(tkInspectionDetailsDTOList.size());
+        List<TkInspectionDetailsEntity> updateEntityList = new ArrayList<>(tkInspectionDetailsDTOList.size());
+        List<String> needDeleteIdList = new ArrayList<>(tkInspectionDetailsDTOList.size());
+        List<String> inspectionDetailsIdList = CollectionUtils.emptyIfNull(oldTkInspectionDetailsDTOList).stream()
+                .map(TkInspectionDetailsDTO::getId)
+                .collect(Collectors.toList());
+        for (TkInspectionDetailsDTO tkInspectionDetailsDTO : tkInspectionDetailsDTOList) {
+            TkInspectionDetailsEntity entity = new TkInspectionDetailsEntity();
+            tkInspectionDetailsDTO.copyToEntity(entity);
+            if (StringUtils.isBlank(entity.getId())) {
+                addEntityList.add(entity);
+                continue;
+            }
+
+            if (inspectionDetailsIdList.contains(entity.getId())) {
+                updateEntityList.add(entity);
+            }
+        }
+
+        if (CollectionUtils.isNotEmpty(addEntityList)) {
+            insertBatch(addEntityList, TkInspectionDetailsEntity.class);
+        }
+
+        if (CollectionUtils.isNotEmpty(updateEntityList)) {
+            updateEntityList.forEach(tkInspectionDetailsEntity -> baseMapper.updateById(tkInspectionDetailsEntity));
+            List<String> updateIdList = updateEntityList.stream().map(TkInspectionDetailsEntity::getId).collect(Collectors.toList());
+            inspectionDetailsIdList.retainAll(updateIdList);
+            needDeleteIdList.addAll(inspectionDetailsIdList);
+        } else {
+            needDeleteIdList = inspectionDetailsIdList;
+        }
+
+        if (CollectionUtils.isNotEmpty(needDeleteIdList)) {
+            baseMapper.deleteBatchIds(needDeleteIdList);
+        }
+
+        return listByInspectionRecordId(inspectionRecordId);
+    }
+
+    @Override
+    public List<TkInspectionDetailsDTO> listByInspectionRecordId(String inspectionRecordId) {
+        if (StringUtils.isBlank(inspectionRecordId)) {
+            return new ArrayList<>(0);
+        }
+
+        QueryWrapper<TkInspectionDetailsEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkInspectionDetailsEntity> lambda = wrapper.lambda();
+        lambda.eq(TkInspectionDetailsEntity::getInspectionRecordId, inspectionRecordId);
+        lambda.orderByAsc(TkInspectionDetailsEntity::getShowOrder);
+        List<TkInspectionDetailsEntity> tkInspectionDetailsEntityList = baseMapper.selectList(wrapper);
+        return CollectionUtils.emptyIfNull(tkInspectionDetailsEntityList).stream().map(entity -> {
+            TkInspectionDetailsDTO tkInspectionDetailsDTO = new TkInspectionDetailsDTO();
+            entity.copyToDTO(tkInspectionDetailsDTO);
+            return tkInspectionDetailsDTO;
+        }).collect(Collectors.toList());
+    }
+
+    @Override
+    public void deleteByInspectionRecordId(String inspectionRecordId) {
+        if (StringUtils.isBlank(inspectionRecordId)) {
+            return;
+        }
+
+        QueryWrapper<TkInspectionDetailsEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkInspectionDetailsEntity> lambda = wrapper.lambda();
+        lambda.eq(TkInspectionDetailsEntity::getInspectionRecordId, inspectionRecordId);
+        baseMapper.delete(wrapper);
+    }
+}

+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.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkCheckDetailsDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionPlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionPlanEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkInspectionPlanMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkCheckDetailsService;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionPlanService;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionRecordService;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkInspectionPlanServiceImpl extends AbstractBaseService<TkInspectionPlanMapper, TkInspectionPlanEntity>
+        implements TkInspectionPlanService {
+    private final TkCheckDetailsService tkCheckDetailsService;
+    private final TkInspectionRecordService tkInspectionRecordService;
+
+    @Override
+    public TkPageData<TkInspectionPlanDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin) {
+        QueryWrapper<TkInspectionPlanEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkInspectionPlanEntity> lambda = wrapper.lambda();
+        if (queryMap != null && queryMap.get("name") != null) {
+            lambda.eq(TkInspectionPlanEntity::getName, queryMap.get("name").toString());
+        }
+
+        if (queryMap != null && queryMap.get("status") != null) {
+            lambda.eq(TkInspectionPlanEntity::getStatus, queryMap.get("status").toString());
+        }
+
+        if (queryMap != null && queryMap.get("startTime") != null && queryMap.get("endTime") != null) {
+            LocalDateTime startTime = (LocalDateTime) queryMap.get("startTime");
+            LocalDateTime endTime = (LocalDateTime) queryMap.get("endTime");
+            lambda.ge(TkInspectionPlanEntity::getStartTime, startTime);
+            lambda.le(TkInspectionPlanEntity::getEndTime, endTime);
+        }
+
+        IPage<TkInspectionPlanEntity> page = baseMapper.selectPage(getPage(queryMap, "create_time", false),
+                wrapper);
+
+        return getPageData(page, TkInspectionPlanDTO.class);
+    }
+
+    @Override
+    public TkInspectionPlanDTO save(TkInspectionPlanDTO tkInspectionPlanDTO) {
+        List<TkCheckDetailsDTO> checkDetailsDTOList = new ArrayList<>(tkInspectionPlanDTO.getTkCheckDetailsDTOList());
+        checkDto(tkInspectionPlanDTO);
+        TkInspectionPlanEntity entity = new TkInspectionPlanEntity();
+        if (StringUtils.isBlank(tkInspectionPlanDTO.getId())) {
+            tkInspectionPlanDTO.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkInspectionPlanEntity> filter = new QueryWrapper<TkInspectionPlanEntity>().lambda()
+                    .eq(TkInspectionPlanEntity::getId, tkInspectionPlanDTO.getId());
+            entity = tkInspectionPlanDTO.getEntity(TkInspectionPlanEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+        entity.copyToDTO(tkInspectionPlanDTO);
+        String id = tkInspectionPlanDTO.getId();
+        for (int index = 0; index < checkDetailsDTOList.size(); index++) {
+            if (CollectionUtils.isEmpty(checkDetailsDTOList)) {
+                continue;
+            }
+
+            TkCheckDetailsDTO checkDetailsDTO = checkDetailsDTOList.get(index);
+            checkDetailsDTO.setInspectionPlanId(id);
+            checkDetailsDTO.setShowOrder(index);
+        }
+
+        List<TkCheckDetailsDTO> tkCheckDetailsDTOList = tkCheckDetailsService.batchSave(checkDetailsDTOList, id);
+        tkInspectionPlanDTO.setTkCheckDetailsDTOList(tkCheckDetailsDTOList);
+        return tkInspectionPlanDTO;
+    }
+
+    @Override
+    public TkInspectionPlanDTO get(String id) {
+        if (StringUtils.isBlank(id)) {
+            return new TkInspectionPlanDTO();
+        }
+
+        TkInspectionPlanEntity entity = baseMapper.selectById(id);
+        TkInspectionPlanDTO tkInspectionPlanDTO = new TkInspectionPlanDTO();
+        entity.copyToDTO(tkInspectionPlanDTO);
+        List<TkCheckDetailsDTO> checkDetailsDTOList = tkCheckDetailsService.listByInspectionPlanId(id);
+        tkInspectionPlanDTO.setTkCheckDetailsDTOList(checkDetailsDTOList);
+        return tkInspectionPlanDTO;
+    }
+
+    @Override
+    public boolean delete(String id) {
+        tkCheckDetailsService.deleteByInspectionPlanId(id);
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    private void checkDto(TkInspectionPlanDTO dto) {
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+}

+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.yunteng.core.exception.TkDataValidationException;
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionDetailsDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionRecordEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkInspectionRecordMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionDetailsService;
+import org.thingsboard.server.dao.yunteng.service.TkInspectionRecordService;
+
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkInspectionRecordServiceImpl extends AbstractBaseService<TkInspectionRecordMapper, TkInspectionRecordEntity>
+        implements TkInspectionRecordService {
+    private final TkInspectionDetailsService tkInspectionDetailsService;
+
+    @Override
+    public TkPageData<TkInspectionRecordDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin) {
+        QueryWrapper<TkInspectionRecordEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkInspectionRecordEntity> lambda = wrapper.lambda();
+        if (queryMap != null && queryMap.get("inspectionPlanId") != null) {
+            lambda.eq(TkInspectionRecordEntity::getInspectionPlanId, queryMap.get("inspectionPlanId").toString());
+        }
+
+        if (queryMap != null && queryMap.get("inspectorId") != null) {
+            lambda.eq(TkInspectionRecordEntity::getInspectorId, queryMap.get("inspectorId").toString());
+        }
+
+        if (queryMap != null && queryMap.get("recordResult") != null) {
+            lambda.eq(TkInspectionRecordEntity::isRecordResult, queryMap.get("recordResult").toString());
+        }
+
+        if (queryMap != null && queryMap.get("startTime") != null && queryMap.get("endTime") != null) {
+            LocalDateTime startTime = (LocalDateTime) queryMap.get("startTime");
+            LocalDateTime endTime = (LocalDateTime) queryMap.get("endTime");
+            lambda.ge(TkInspectionRecordEntity::getCheckDate, startTime);
+            lambda.le(TkInspectionRecordEntity::getCheckDate, endTime);
+        }
+
+        IPage<TkInspectionRecordEntity> page = baseMapper.selectPage(getPage(queryMap, "create_time", false),
+                wrapper);
+
+        return getPageData(page, TkInspectionRecordDTO.class);
+    }
+
+    @Override
+    public TkInspectionRecordDTO save(TkInspectionRecordDTO tkInspectionRecordDTO) {
+        List<TkInspectionDetailsDTO> tkInspectionDetailsDTOList = new ArrayList<>(tkInspectionRecordDTO.getTkInspectionDetailsDTOList());
+        checkDto(tkInspectionRecordDTO);
+        TkInspectionRecordEntity entity = new TkInspectionRecordEntity();
+        if (StringUtils.isBlank(tkInspectionRecordDTO.getId())) {
+            tkInspectionRecordDTO.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkInspectionRecordEntity> filter = new QueryWrapper<TkInspectionRecordEntity>().lambda()
+                    .eq(TkInspectionRecordEntity::getId, tkInspectionRecordDTO.getId());
+            entity = tkInspectionRecordDTO.getEntity(TkInspectionRecordEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+        entity.copyToDTO(tkInspectionRecordDTO);
+        String id = tkInspectionRecordDTO.getId();
+        for (int index = 0; index < tkInspectionDetailsDTOList.size(); index++) {
+            if (CollectionUtils.isEmpty(tkInspectionDetailsDTOList)) {
+                continue;
+            }
+
+            TkInspectionDetailsDTO tkInspectionDetailsDTO = tkInspectionDetailsDTOList.get(index);
+            tkInspectionDetailsDTO.setInspectionRecordId(id);
+            tkInspectionDetailsDTO.setShowOrder(index);
+        }
+
+        List<TkInspectionDetailsDTO> detailsDTOList = tkInspectionDetailsService.batchSave(tkInspectionDetailsDTOList, id);
+        tkInspectionRecordDTO.setTkInspectionDetailsDTOList(detailsDTOList);
+        return tkInspectionRecordDTO;
+    }
+
+    @Override
+    public TkInspectionRecordDTO get(String id) {
+        if (StringUtils.isBlank(id)) {
+            return new TkInspectionRecordDTO();
+        }
+
+        TkInspectionRecordEntity entity = baseMapper.selectById(id);
+        TkInspectionRecordDTO tkInspectionRecordDTO = new TkInspectionRecordDTO();
+        entity.copyToDTO(tkInspectionRecordDTO);
+        List<TkInspectionDetailsDTO> tkInspectionDetailsDTOList = tkInspectionDetailsService.listByInspectionRecordId(id);
+        tkInspectionRecordDTO.setTkInspectionDetailsDTOList(tkInspectionDetailsDTOList);
+        return tkInspectionRecordDTO;
+    }
+
+    @Override
+    public boolean delete(String id) {
+        tkInspectionDetailsService.deleteByInspectionRecordId(id);
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    private void checkDto(TkInspectionRecordDTO dto) {
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+}

+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.TkCheckDetailsEntity;
+
+@Mapper
+public interface TkCheckDetailsMapper extends BaseMapper<TkCheckDetailsEntity> {
+}

+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.TkCheckPlanEntity;
+
+@Mapper
+public interface TkCheckPlanMapper extends BaseMapper<TkCheckPlanEntity> {
+}

+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.TkInspectionDetailsEntity;
+
+@Mapper
+public interface TkInspectionDetailsMapper extends BaseMapper<TkInspectionDetailsEntity> {
+}

+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.TkInspectionPlanEntity;
+
+@Mapper
+public interface TkInspectionPlanMapper extends BaseMapper<TkInspectionPlanEntity> {
+}

+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.TkInspectionRecordEntity;
+
+@Mapper
+public interface TkInspectionRecordMapper extends BaseMapper<TkInspectionRecordEntity> {
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.TkCheckDetailsDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkCheckDetailsEntity;
+
+import java.util.List;
+
+public interface TkCheckDetailsService extends BaseService<TkCheckDetailsEntity> {
+
+    List<TkCheckDetailsDTO> batchSave(List<TkCheckDetailsDTO> checkDetailsDTOList, String inspectionPlanId);
+
+    List<TkCheckDetailsDTO> listByInspectionPlanId(String inspectionPlanId);
+
+    void deleteByInspectionPlanId(String inspectionPlanId);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.TkCheckPlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkCheckPlanEntity;
+
+import java.util.Map;
+
+public interface TkCheckPlanService extends BaseService<TkCheckPlanEntity> {
+    TkPageData<TkCheckPlanDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin);
+
+    TkCheckPlanDTO save(TkCheckPlanDTO tkCheckPlanDTO);
+
+    boolean delete(String id);
+
+    TkCheckPlanDTO get(String id);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionDetailsDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionDetailsEntity;
+
+import java.util.List;
+
+public interface TkInspectionDetailsService extends BaseService<TkInspectionDetailsEntity> {
+
+    List<TkInspectionDetailsDTO> batchSave(List<TkInspectionDetailsDTO> tkInspectionDetailsDTOList, String inspectionRecordId);
+
+    List<TkInspectionDetailsDTO> listByInspectionRecordId(String inspectionRecordId);
+
+    void deleteByInspectionRecordId(String inspectionRecordId);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionPlanDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionPlanEntity;
+
+import java.util.Map;
+
+public interface TkInspectionPlanService extends BaseService<TkInspectionPlanEntity> {
+
+    TkPageData<TkInspectionPlanDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin);
+
+    TkInspectionPlanDTO save(TkInspectionPlanDTO tkInspectionPlanDTO);
+
+    TkInspectionPlanDTO get(String id);
+
+    boolean delete(String id);
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.yunteng.dto.TkInspectionRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkInspectionRecordEntity;
+
+import java.util.Map;
+
+public interface TkInspectionRecordService extends BaseService<TkInspectionRecordEntity> {
+
+    TkPageData<TkInspectionRecordDTO> page(Map<String, Object> queryMap, boolean isTenantAdmin);
+
+    TkInspectionRecordDTO save(TkInspectionRecordDTO tkInspectionRecordDTO);
+
+    TkInspectionRecordDTO get(String id);
+
+    boolean delete(String id);
+}