设备管理

故障原因管理接口
设备报修维修接口

+CREATE TABLE "public"."qg_malfunction_reason" (
+     "id" varchar(36)  NOT NULL,
+     "code" varchar(50),
+     "reason" varchar(200),
+     "tenant_id" varchar(36),
+     "create_time" timestamp(6),
+     "creator" varchar(36),
+     "updater" varchar(36),
+     "update_time" timestamp(6),
+     "remark" varchar(255),
+     CONSTRAINT "qg_malfunction_reason_pkey" PRIMARY KEY ("id")
+);
+
+ALTER TABLE "public"."qg_malfunction_reason" OWNER TO "postgres";
+
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."id" IS '主键ID';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."code" IS '故障编码';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."reason" IS '故障原因';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."tenant_id" IS '租户ID';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."create_time" IS '创建时间';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."updater" IS '更新用户';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."update_time" IS '更新时间';
+COMMENT ON COLUMN "public"."qg_malfunction_reason"."creator" IS '创建用户';
+
+
+ALTER TABLE device
+    ADD COLUMN IF NOT EXISTS director_id varchar(36);
+
+COMMENT ON COLUMN "public"."device"."director_id" IS '负责人id';
+
+
+CREATE TABLE "public"."qg_repair_order" (
+    "id" varchar(36)  NOT NULL,
+    "device_id" varchar(36),
+    "report_date" timestamp(6),
+    "report_by" varchar(36),
+    "status" varchar(50),
+    "emergency" bool,
+    "situation_img" varchar(200),
+    "description" varchar(500),
+    "tenant_id" varchar(36),
+    "create_time" timestamp(6),
+    "creator" varchar(36),
+    "updater" varchar(36),
+    "update_time" timestamp(6),
+    "remark" varchar(255),
+    CONSTRAINT "qg_repair_order_pkey" PRIMARY KEY ("id")
+);
+
+ALTER TABLE "public"."qg_repair_order" OWNER TO "postgres";
+
+COMMENT ON COLUMN "public"."qg_repair_order"."id" IS '主键ID';
+COMMENT ON COLUMN "public"."qg_repair_order"."device_id" IS '设备id';
+COMMENT ON COLUMN "public"."qg_repair_order"."report_date" IS '报修时间';
+COMMENT ON COLUMN "public"."qg_repair_order"."report_by" IS '报修人';
+COMMENT ON COLUMN "public"."qg_repair_order"."report_by" IS '报修人';
+COMMENT ON COLUMN "public"."qg_repair_order"."status" IS '工单状态';
+COMMENT ON COLUMN "public"."qg_repair_order"."emergency" IS '是否紧急';
+COMMENT ON COLUMN "public"."qg_repair_order"."situation_img" IS 'situation_img';
+COMMENT ON COLUMN "public"."qg_repair_order"."tenant_id" IS '租户ID';
+COMMENT ON COLUMN "public"."qg_repair_order"."create_time" IS '创建时间';
+COMMENT ON COLUMN "public"."qg_repair_order"."updater" IS '更新用户';
+COMMENT ON COLUMN "public"."qg_repair_order"."update_time" IS '更新时间';
+COMMENT ON COLUMN "public"."qg_repair_order"."creator" IS '创建用户';
+
+
+CREATE TABLE "public"."qg_repair_record" (
+    "id" varchar(36)  NOT NULL,
+    "order_id" varchar(36),
+    "repair_date" timestamp(6),
+    "repair_by" varchar(36),
+    "description" varchar(500),
+    "tenant_id" varchar(36),
+    "create_time" timestamp(6),
+    "creator" varchar(36),
+    "updater" varchar(36),
+    "update_time" timestamp(6),
+    "remark" varchar(255),
+    CONSTRAINT "qg_repair_record_pkey" PRIMARY KEY ("id")
+);
+
+ALTER TABLE "public"."qg_repair_record" OWNER TO "postgres";
+
+COMMENT ON COLUMN "public"."qg_repair_record"."id" IS '主键ID';
+COMMENT ON COLUMN "public"."qg_repair_record"."order_id" IS '维修工单id';
+COMMENT ON COLUMN "public"."qg_repair_record"."repair_date" IS '维修时间';
+COMMENT ON COLUMN "public"."qg_repair_record"."repair_by" IS '维修人';
+COMMENT ON COLUMN "public"."qg_repair_record"."description" IS '维修情况说明';
+COMMENT ON COLUMN "public"."qg_repair_record"."tenant_id" IS '租户ID';
+COMMENT ON COLUMN "public"."qg_repair_record"."create_time" IS '创建时间';
+COMMENT ON COLUMN "public"."qg_repair_record"."updater" IS '更新用户';
+COMMENT ON COLUMN "public"."qg_repair_record"."update_time" IS '更新时间';
+COMMENT ON COLUMN "public"."qg_repair_record"."creator" 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.dto.TkMalfunctionReasonDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkMalfunctionReasonService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.List;
+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/mr")
+@Api(tags = {"故障原因管理"})
+@Slf4j
+public class TkMalfunctionReasonController extends BaseController {
+    private final TkMalfunctionReasonService tkMalfunctionReasonService;
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("获取满足条件的所有设备")
+    public TkPageData<TkMalfunctionReasonDTO> pageMalfunctionReason(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody Map<String, Object> queryMap)
+            throws ThingsboardException {
+        queryMap.put(PAGE, page);
+        queryMap.put(PAGE_SIZE, pageSize);
+        return tkMalfunctionReasonService.page(getCurrentUser().getCurrentTenantId(), queryMap);
+    }
+
+    @PostMapping("/list")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("获取满足条件的所有设备")
+    public List<TkMalfunctionReasonDTO> list(
+            @RequestBody Map<String, Object> queryMap) throws ThingsboardException {
+
+        return tkMalfunctionReasonService.list(getCurrentUser().getCurrentTenantId(), queryMap);
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkMalfunctionReasonDTO> save(@RequestBody TkMalfunctionReasonDTO tkMalfunctionReasonDTO) throws ThingsboardException {
+        tkMalfunctionReasonDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        TkMalfunctionReasonDTO deviceDTO = tkMalfunctionReasonService.save(tkMalfunctionReasonDTO);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkMalfunctionReasonService.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.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.core.exception.TkDataValidationException;
+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.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.TkRepairOrderService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+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;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("api/yt/repairOrder")
+@Api(tags = {"维修工单管理"})
+@Slf4j
+public class TkRepairOrderController extends BaseController {
+
+    private final TkRepairOrderService tkRepairOrderService;
+
+    private final TkDeviceService tkdeviceService;
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修工单保存")
+    public ResponseEntity<TkRepairOrderDTO> save(@RequestBody TkRepairOrderDTO dto) throws ThingsboardException {
+        String currentTenantId = getCurrentUser().getCurrentTenantId();
+        dto.setTenantId(currentTenantId);
+        if (StringUtils.isNotBlank(dto.getDeviceId())) {
+            DeviceDTO deviceInfo = tkdeviceService.checkDeviceByTenantIdAndDeviceId
+                    (UUID.fromString(currentTenantId), UUID.fromString(dto.getDeviceId()));
+            if (deviceInfo == null) {
+                throw new TkDataValidationException("设备不存在！");
+            }
+        }
+
+        if (StringUtils.isBlank(dto.getId())) {
+            TkRepairOrderDTO roInfo = tkRepairOrderService.loadByDeviceId(dto.getDeviceId());
+            if (roInfo != null && RepairOrderStatusEnum.valueOf(roInfo.getStatus()) == RepairOrderStatusEnum.SCHEDULING) {
+                throw new TkDataValidationException("该设备已报修！");
+            }
+        }
+
+        if (StringUtils.isBlank(dto.getStatus())) {
+            dto.setStatus(RepairOrderStatusEnum.SCHEDULING.name());
+        }
+
+        TkRepairOrderDTO deviceDTO = tkRepairOrderService.save(dto);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修工单删除")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkRepairOrderService.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修工单详情")
+    public ResponseEntity<TkRepairOrderDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkRepairOrderDTO deviceDTO = tkRepairOrderService.detail(id);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修工单列表")
+    public TkPageData<TkRepairOrderDTO> pageMalfunctionReason(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody TkRepairOrderDTO params)
+            throws ThingsboardException {
+        params.setPage(page);
+        params.setPageSize(pageSize);
+        return tkRepairOrderService.page(getCurrentUser().getCurrentTenantId(), params);
+    }
+}

+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.core.exception.TkDataValidationException;
+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.enums.RepairOrderStatusEnum;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkRepairOrderService;
+import org.thingsboard.server.dao.yunteng.service.TkRepairRecordService;
+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/repairRecord")
+@Api(tags = {"维修记录"})
+@Slf4j
+public class TkRepairRecordController extends BaseController {
+    private final TkRepairRecordService tkRepairRecordService;
+
+    private final TkRepairOrderService tkRepairOrderService;
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修记录保存")
+    public ResponseEntity<TkRepairRecordDTO> save(@RequestBody TkRepairRecordDTO dto) throws ThingsboardException {
+        String currentTenantId = getCurrentUser().getCurrentTenantId();
+        dto.setTenantId(currentTenantId);
+        if (StringUtils.isNotBlank(dto.getOrderId())) {
+            TkRepairOrderDTO repairOrderDTO = tkRepairOrderService.load(dto.getOrderId());
+            if (repairOrderDTO == null) {
+                throw new TkDataValidationException("维修工单不存在！");
+            }
+        }
+
+
+        TkRepairRecordDTO deviceDTO = tkRepairRecordService.save(dto);
+
+        tkRepairOrderService.updateStatus(dto.getOrderId(),RepairOrderStatusEnum.REPAIRFINISH.name());
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修记录删除")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkRepairRecordService.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修记录详情")
+    public ResponseEntity<TkRepairRecordDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkRepairRecordDTO dto = tkRepairRecordService.detail(id);
+        return ResponseEntity.ok(dto);
+    }
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("维修工单列表")
+    public TkPageData<TkRepairRecordDTO> page(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody TkRepairRecordDTO params)
+            throws ThingsboardException {
+        params.setPage(page);
+        params.setPageSize(pageSize);
+        return tkRepairRecordService.page(getCurrentUser().getCurrentTenantId(), params);
+    }
+}

@@ -141,4 +141,6 @@ public class DeviceDTO extends TenantDTO {
   private String organizationName;
   private String organizationName;
   @ApiModelProperty(value = "是否来自边端")
   @ApiModelProperty(value = "是否来自边端")
   private Integer isEdge;
   private Integer isEdge;
+  @ApiModelProperty(value = "设备负责人id")
+  private String directorId;
 }
 }

+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 TkMalfunctionReasonDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "故障编码")
+    private String code;
+
+    @ApiModelProperty(value = "原因")
+    private String reason;
+}

+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 TkRepairOrderDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "设备id")
+    private String deviceId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "报修时间")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime reportDate;
+
+    @ApiModelProperty(value = "报修人")
+    private String reportBy;
+
+    @ApiModelProperty(value = "状态(RepairOrderStatusEnum) SCHEDULING排期中 REPAIRFINISH维修完成 ACCEPTANCEPASSED验收通过")
+    private String status;
+
+    @ApiModelProperty(value = "是否紧急")
+    private Boolean emergency;
+
+    @ApiModelProperty(value = "故障情况拍照")
+    private String situationImg;
+
+    @ApiModelProperty(value = "故障描述")
+    private String description;
+
+    @ApiModelProperty(value = "关联设备")
+    private DeviceDTO deviceInfo;
+
+    @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.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 TkRepairRecordDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "维修工单id")
+    private String orderId;
+
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
+    @ApiModelProperty(value = "维修时间")
+    @JsonSerialize(using = LocalDateTimeSerializer.class)
+    private LocalDateTime repairDate;
+
+    @ApiModelProperty(value = "维修人id")
+    private String repairBy;
+
+    @ApiModelProperty(value = "维修人姓名")
+    private String repairName;
+
+    @ApiModelProperty(value = "维修情况说明")
+    private String description;
+
+    @ApiModelProperty(value = "维修工单")
+    private TkRepairOrderDTO tkRepairOrderDTO;
+
+    @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 RepairOrderStatusEnum {
+    //排期中
+    SCHEDULING,
+    //维修完成
+    REPAIRFINISH,
+    //验收通过
+    ACCEPTANCEPASSED
+}

@@ -666,6 +666,21 @@ public class ModelConstants {
     public static final String NOTIFICATION_TEMPLATE_NOTIFICATION_TYPE_PROPERTY = "notification_type";
     public static final String NOTIFICATION_TEMPLATE_NOTIFICATION_TYPE_PROPERTY = "notification_type";
     public static final String NOTIFICATION_TEMPLATE_CONFIGURATION_PROPERTY = "configuration";
     public static final String NOTIFICATION_TEMPLATE_CONFIGURATION_PROPERTY = "configuration";
 
 
+    /**
+     * 故障原因.
+     */
+    public static final String MALFUNCTIONREASON_TABLE_NAME = "qg_malfunction_reason";
+
+    /**
+     * 维修工单
+     */
+    public static final String TKREPAIRORDER_TABLE_NAME = "qg_repair_order";
+
+    /**
+     * 维修记录
+     */
+    public static final String TKREPAIRRECORD_TABLE_NAME = "qg_repair_record";
+
     protected static final String[] NONE_AGGREGATION_COLUMNS = new String[]{LONG_VALUE_COLUMN, DOUBLE_VALUE_COLUMN, BOOLEAN_VALUE_COLUMN, STRING_VALUE_COLUMN, JSON_VALUE_COLUMN, KEY_COLUMN, TS_COLUMN};
     protected static final String[] NONE_AGGREGATION_COLUMNS = new String[]{LONG_VALUE_COLUMN, DOUBLE_VALUE_COLUMN, BOOLEAN_VALUE_COLUMN, STRING_VALUE_COLUMN, JSON_VALUE_COLUMN, KEY_COLUMN, TS_COLUMN};
 
 
     protected static final String[] COUNT_AGGREGATION_COLUMNS = new String[]{count(LONG_VALUE_COLUMN), count(DOUBLE_VALUE_COLUMN), count(BOOLEAN_VALUE_COLUMN), count(STRING_VALUE_COLUMN), count(JSON_VALUE_COLUMN), max(TS_COLUMN)};
     protected static final String[] COUNT_AGGREGATION_COLUMNS = new String[]{count(LONG_VALUE_COLUMN), count(DOUBLE_VALUE_COLUMN), count(BOOLEAN_VALUE_COLUMN), count(STRING_VALUE_COLUMN), count(JSON_VALUE_COLUMN), max(TS_COLUMN)};

@@ -88,5 +88,6 @@ public class TkDeviceEntity extends TbTenantBaseEntity {
   @TableField(exist = false)
   @TableField(exist = false)
   private Integer isEdge;
   private Integer isEdge;
 
 
+  private String directorId;
 
 
 }
 }

+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.MALFUNCTIONREASON_TABLE_NAME, autoResultMap = true)
+public class TkMalfunctionReasonEntity extends TenantBaseEntity {
+    private String code;
+    private String reason;
+
+}

+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.TKREPAIRORDER_TABLE_NAME, autoResultMap = true)
+public class TkRepairOrderEntity extends TenantBaseEntity {
+
+    private String deviceId;
+
+    private LocalDateTime reportDate;
+
+    private String reportBy;
+
+    private String status;
+
+    private Boolean emergency;
+
+    private String situationImg;
+
+    private String description;
+
+}

+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.TKREPAIRRECORD_TABLE_NAME, autoResultMap = true)
+public class TkRepairRecordEntity  extends TenantBaseEntity {
+
+    private String orderId;
+
+    private LocalDateTime repairDate;
+
+    private String repairBy;
+
+    private String description;
+
+}

+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.TkMalfunctionReasonDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkRepairOrderDTO;
+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;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkMalfunctionReasonService;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfunctionReasonMapper, TkMalfunctionReasonEntity>
+        implements TkMalfunctionReasonService {
+    @Override
+    public TkPageData<TkMalfunctionReasonDTO> page(String tenantId, Map<String, Object> queryMap) {
+
+        QueryWrapper<TkMalfunctionReasonEntity> wrapper = new QueryWrapper<>();
+        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());
+        }
+        if (queryMap != null && queryMap.get("reason") != null) {
+            lambda.eq(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
+        }
+
+        IPage<TkMalfunctionReasonEntity> page = baseMapper.selectPage(
+                getPage(queryMap, "create_time", false), wrapper);
+
+        return getPageData(page, TkMalfunctionReasonDTO.class);
+    }
+
+    @Override
+    public List<TkMalfunctionReasonDTO> list(String tenantId, Map<String, Object> queryMap) {
+        QueryWrapper<TkMalfunctionReasonEntity> wrapper = new QueryWrapper<>();
+        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());
+        }
+        if (queryMap != null && queryMap.get("reason") != null) {
+            lambda.eq(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))
+                .collect(Collectors.toList())).orElse(null);
+
+    }
+
+    @Override
+    public TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO) {
+        checkDto(tkMalfunctionReasonDTO);
+        TkMalfunctionReasonEntity entity = new TkMalfunctionReasonEntity();
+        if (StringUtils.isBlank(tkMalfunctionReasonDTO.getId())) {
+            tkMalfunctionReasonDTO.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkMalfunctionReasonEntity> filter = new QueryWrapper<TkMalfunctionReasonEntity>().lambda()
+                    .eq(TkMalfunctionReasonEntity::getId, tkMalfunctionReasonDTO.getId());
+            entity = tkMalfunctionReasonDTO.getEntity(TkMalfunctionReasonEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+
+        entity.copyToDTO(tkMalfunctionReasonDTO);
+        return tkMalfunctionReasonDTO;
+    }
+
+    private void checkDto(TkMalfunctionReasonDTO dto) {
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+
+    @Override
+    public boolean delete(String 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.User;
+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.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.TkRepairOrderEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkRepairOrderMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceService;
+import org.thingsboard.server.dao.yunteng.service.TkRepairOrderService;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+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
+public class TkRepairOrderServiceImpl extends AbstractBaseService<TkRepairOrderMapper, TkRepairOrderEntity>
+        implements TkRepairOrderService {
+
+    private final TkDeviceService tkdeviceService;
+
+    @Override
+    public TkPageData<TkRepairOrderDTO> page(String tenantId, TkRepairOrderDTO params) {
+        QueryWrapper<TkRepairOrderEntity> queryWrapper = getCondition(tenantId, params);
+        getCondition(tenantId, params);
+        Map<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE, params.getPage());
+        queryMap.put(PAGE_SIZE, params.getPageSize());
+        IPage<TkRepairOrderEntity> page = baseMapper.selectPage(
+                getPage(queryMap, "create_time", false), queryWrapper);
+
+        TkPageData<TkRepairOrderDTO> pageData = getPageData(page, TkRepairOrderDTO.class);
+        if (pageData != null && CollectionUtils.isNotEmpty(pageData.getItems())) {
+            pageData.getItems().forEach(item -> {
+                String deviceId = item.getDeviceId();
+                if (StringUtils.isNotBlank(deviceId)) {
+                    DeviceDTO deviceDTO = tkdeviceService.checkDeviceByTenantIdAndDeviceId(UUID.fromString(tenantId), UUID.fromString(deviceId));
+                    item.setDeviceInfo(deviceDTO);
+                }
+            });
+        }
+        return pageData;
+    }
+
+    private QueryWrapper<TkRepairOrderEntity> getCondition(String tenantId, TkRepairOrderDTO params) {
+        QueryWrapper<TkRepairOrderEntity> queryWrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkRepairOrderEntity> lambda = queryWrapper.lambda();
+        lambda.eq(TenantBaseEntity::getTenantId, tenantId);
+        if (StringUtils.isNotBlank(params.getDeviceId())) {
+            lambda.eq(TkRepairOrderEntity::getDeviceId, params.getDeviceId());
+        }
+        if (params.getStartDate() != null) {
+            lambda.ge(TkRepairOrderEntity::getReportDate, params.getStartDate());
+        }
+        if (params.getEndDate() != null) {
+            lambda.le(TkRepairOrderEntity::getReportDate, params.getEndDate());
+        }
+
+        if (StringUtils.isNotBlank(params.getReportBy())) {
+            lambda.eq(TkRepairOrderEntity::getReportBy, params.getReportBy());
+        }
+
+        if (StringUtils.isNotBlank(params.getStatus())) {
+            lambda.eq(TkRepairOrderEntity::getStatus, params.getStatus());
+        }
+
+        if (params.getEmergency() != null) {
+            lambda.eq(TkRepairOrderEntity::getEmergency, params.getEmergency());
+        }
+        return queryWrapper;
+    }
+
+
+    @Override
+    public TkRepairOrderDTO save(TkRepairOrderDTO dto) {
+        checkDto(dto);
+        if (dto.getReportDate() == null) {
+            dto.setReportDate(LocalDateTime.now());
+        }
+
+        TkRepairOrderEntity entity = new TkRepairOrderEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkRepairOrderEntity> filter = new QueryWrapper<TkRepairOrderEntity>().lambda()
+                    .eq(TkRepairOrderEntity::getId, dto.getId());
+            entity = dto.getEntity(TkRepairOrderEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    @Override
+    public TkRepairOrderDTO detail(String id) throws ThingsboardException {
+        TkRepairOrderDTO detail = new TkRepairOrderDTO();
+        TkRepairOrderEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("数据不存在！");
+        }
+        entity.copyToDTO(detail);
+        String deviceId = entity.getDeviceId();
+        if (StringUtils.isNotBlank(deviceId)) {
+            TenantId tenantInfo = SpringBeanUtils.getTenantId();
+            DeviceDTO deviceDTO = tkdeviceService.checkDeviceByTenantIdAndDeviceId(tenantInfo.getId(), UUID.fromString(deviceId));
+            detail.setDeviceInfo(deviceDTO);
+        }
+
+        return detail;
+    }
+
+    @Override
+    public TkRepairOrderDTO load(String id) throws ThingsboardException {
+        TkRepairOrderDTO result = new TkRepairOrderDTO();
+        TkRepairOrderEntity entity = baseMapper.selectById(id);
+        entity.copyToDTO(result);
+        return result;
+    }
+
+    @Override
+    public TkRepairOrderDTO loadByDeviceId(String deviceId) throws ThingsboardException {
+        TkRepairOrderDTO result = new TkRepairOrderDTO();
+        QueryWrapper<TkRepairOrderEntity> queryWrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkRepairOrderEntity> lambda = queryWrapper.lambda();
+        lambda.eq(TenantBaseEntity::getTenantId, SpringBeanUtils.getTenantId().toString());
+        lambda.eq(TkRepairOrderEntity::getDeviceId, deviceId);
+        TkRepairOrderEntity entity = baseMapper.selectOne(queryWrapper);
+        entity.copyToDTO(result);
+        return result;
+    }
+
+    @Override
+    public void updateStatus(String id, String status) throws ThingsboardException {
+        TkRepairOrderDTO orderDTO = load(id);
+        if (orderDTO == null) {
+            throw new TkDataValidationException("工单不存在！");
+        }
+        RepairOrderStatusEnum statusEnum = RepairOrderStatusEnum.valueOf(status);
+        if (statusEnum == null) {
+            throw new TkDataValidationException("工单状态不存在！");
+        }
+        TkRepairOrderEntity entity = new TkRepairOrderEntity();
+        orderDTO.copyToEntity(entity);
+        entity.setStatus(statusEnum.name());
+        LambdaQueryWrapper<TkRepairOrderEntity> filter = new QueryWrapper<TkRepairOrderEntity>().lambda()
+                .eq(TkRepairOrderEntity::getId, entity.getId());
+        baseMapper.update(entity, filter);
+    }
+
+    private void checkDto(TkRepairOrderDTO dto) {
+        if (StringUtils.isBlank(dto.getDeviceId())) {
+            throw new TkDataValidationException("设备不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getReportBy())) {
+            throw new TkDataValidationException("报修人不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+
+    @Override
+    public boolean delete(String 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.User;
+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.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.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.TkDeviceEntity;
+import org.thingsboard.server.dao.yunteng.entities.TkRepairRecordEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkRepairRecordMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkRepairOrderService;
+import org.thingsboard.server.dao.yunteng.service.TkRepairRecordService;
+import org.thingsboard.server.dao.yunteng.service.TkUserService;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+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
+public class TkRepairRecordServiceImpl extends AbstractBaseService<TkRepairRecordMapper, TkRepairRecordEntity>
+        implements TkRepairRecordService {
+
+    private final TkRepairOrderService tkRepairOrderService;
+
+
+    private final TkUserService tkUserService;
+
+    @Override
+    public TkPageData<TkRepairRecordDTO> page(String tenantId, TkRepairRecordDTO params) {
+        TkPageData<TkRepairRecordDTO> result = new TkPageData<>();
+        Map<String, Object> queryMap = new HashMap<>();
+        queryMap.put(PAGE, params.getPage());
+        queryMap.put(PAGE_SIZE, params.getPageSize());
+        IPage<TkRepairRecordEntity> page =
+                getPage(queryMap, "rr.create_time", false);
+        IPage<TkRepairRecordDTO> pageData = baseMapper.getRepairRecordPage(page, queryMap);
+        if (pageData != null && CollectionUtils.isNotEmpty(pageData.getRecords())) {
+            List<TkRepairRecordDTO> dataList = pageData.getRecords().stream().map(item -> {
+                TkRepairRecordDTO dto = new TkRepairRecordDTO();
+                CopyUtils.copyProperties(item, dto);
+                return dto;
+
+            }).collect(Collectors.toList());
+            result.setItems(dataList);
+        }
+        result.setTotal(Long.valueOf(pageData.getTotal()).intValue());
+
+        return result;
+    }
+
+    @Override
+    public TkRepairRecordDTO save(TkRepairRecordDTO dto) {
+        checkDto(dto);
+        if (dto.getRepairDate() == null) {
+            dto.setRepairDate(LocalDateTime.now());
+        }
+
+        TkRepairRecordEntity entity = new TkRepairRecordEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkRepairRecordEntity> filter = new QueryWrapper<TkRepairRecordEntity>().lambda()
+                    .eq(TkRepairRecordEntity::getId, dto.getId());
+            entity = dto.getEntity(TkRepairRecordEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    private void checkDto(TkRepairRecordDTO dto) {
+        if (StringUtils.isBlank(dto.getOrderId())) {
+            throw new TkDataValidationException("维修工单不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getRepairBy())) {
+            throw new TkDataValidationException("维修人不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            throw new TkDataValidationException("租户id为空！");
+        }
+    }
+
+
+    @Override
+    public TkRepairRecordDTO detail(String id) throws ThingsboardException {
+        TkRepairRecordDTO detail = new TkRepairRecordDTO();
+        TkRepairRecordEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("数据不存在！");
+        }
+        entity.copyToDTO(detail);
+        String orderId = entity.getOrderId();
+        if (StringUtils.isNotBlank(orderId)) {
+            TkRepairOrderDTO repairOrderDTO = tkRepairOrderService.load(orderId);
+            detail.setTkRepairOrderDTO(repairOrderDTO);
+        }
+        UserDTO userInfo = tkUserService.findUserInfoById(detail.getRepairBy());
+        detail.setRepairName(userInfo.getRealName());
+
+        return detail;
+    }
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+}
+

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

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

+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.TkRepairRecordDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkRepairRecordEntity;
+
+import java.util.Map;
+
+@Mapper
+public interface TkRepairRecordMapper extends BaseMapper<TkRepairRecordEntity> {
+
+  IPage<TkRepairRecordDTO> getRepairRecordPage(IPage<?> page, @Param("queryMap") Map<String, Object> queryMap);
+
+}

+package org.thingsboard.server.dao.yunteng.service;
+
+
+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;
+
+import java.util.List;
+import java.util.Map;
+
+public interface TkMalfunctionReasonService extends BaseService<TkMalfunctionReasonEntity> {
+
+    TkPageData<TkMalfunctionReasonDTO> page(String tenantId, Map<String, Object> queryMap);
+
+    List<TkMalfunctionReasonDTO> list(String tenantId, Map<String, Object> queryMap);
+
+    TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO);
+
+    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.TkRepairOrderDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkRepairOrderEntity;
+
+import java.util.Map;
+
+public interface TkRepairOrderService extends BaseService<TkRepairOrderEntity> {
+
+    TkPageData<TkRepairOrderDTO> page(String tenantId, TkRepairOrderDTO params);
+
+    TkRepairOrderDTO save(TkRepairOrderDTO dto);
+
+    TkRepairOrderDTO detail(String id) throws ThingsboardException;
+
+    TkRepairOrderDTO load(String id) throws ThingsboardException;
+
+    TkRepairOrderDTO loadByDeviceId(String deviceId) throws ThingsboardException;
+
+    void updateStatus(String id, String status) 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.TkRepairRecordDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkRepairRecordEntity;
+
+public interface TkRepairRecordService extends BaseService<TkRepairRecordEntity>{
+
+    TkPageData<TkRepairRecordDTO> page(String tenantId, TkRepairRecordDTO params);
+
+    TkRepairRecordDTO save(TkRepairRecordDTO dto);
+
+    TkRepairRecordDTO detail(String id) throws ThingsboardException;
+
+    boolean delete(String id);
+
+}

+<?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.TkRepairRecordMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.TkRepairRecordDTO" id="repairRecordMap">
+        <result property="id" column="id" />
+        <result property="repairDate" column="repair_date" />
+        <result property="orderId" column="order_id" />
+        <result property="repairBy" column="repair_by" />
+        <result property="description" column="description" />
+        <result property="repairName" column="repairName" />
+    </resultMap>
+    <select id="getRepairRecordPage"  resultMap="repairRecordMap">
+        SELECT rr.id,rr.order_id,rr.repair_date,rr.repair_by,rr.description
+             ,rr.tenant_id,rr.create_time,rr.updater,rr.update_time,rr.creator,su.real_name as repairName
+        from qg_repair_record rr
+        inner join sys_user su on su.id=rr.repair_by
+    </select>
+</mapper>