设备类别接口

故障原因优化
租户子账号接口修改

@@ -2,6 +2,7 @@ CREATE TABLE "public"."qg_malfunction_reason" (
      "id" varchar(36)  NOT NULL,
      "code" varchar(50),
      "reason" varchar(200),
+     "status" varchar(50),
      "tenant_id" varchar(36),
      "create_time" timestamp(6),
      "creator" varchar(36),
@@ -15,6 +16,7 @@ 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"."status" 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 '更新用户';
@@ -24,8 +26,11 @@ COMMENT ON COLUMN "public"."qg_malfunction_reason"."creator" IS '创建用户';
 
 ALTER TABLE device
     ADD COLUMN IF NOT EXISTS director_id varchar(36);
+ALTER TABLE device
+    ADD COLUMN IF NOT EXISTS category_id varchar(36);
 
 COMMENT ON COLUMN "public"."device"."director_id" IS '负责人id';
+COMMENT ON COLUMN "public"."device"."category_id" IS '设备类别id';
 
 
 CREATE TABLE "public"."qg_repair_order" (
@@ -265,3 +270,21 @@ COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_plan_id" IS '保养计
 COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_date" IS '保养日期';
 COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_by" IS '保养日期';
 COMMENT ON COLUMN "public"."qg_preserve_record"."preserve_status" IS '状态';
+
+CREATE TABLE "public"."qg_device_cagegory" (
+  "id" varchar(36)  NOT NULL,
+  "name" varchar(50),
+  "parent_id" varchar(36),
+  "cagegory_order" int4,
+  "tenant_id" varchar(36),
+  "create_time" timestamp(6),
+  "creator" varchar(36),
+  "updater" varchar(36),
+  "update_time" timestamp(6)
+CONSTRAINT "qg_device_cagegory_pkey" PRIMARY KEY ("id")
+);
+
+COMMENT ON TABLE "public"."qg_device_cagegory" IS '设备分类';
+COMMENT ON COLUMN "public"."qg_device_cagegory"."name" IS '保养记录编码';
+COMMENT ON COLUMN "public"."qg_device_cagegory"."parent_id" IS '保养计划id';
+COMMENT ON COLUMN "public"."qg_device_cagegory"."order" IS '排序';

+package org.thingsboard.server.controller;
+
+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.TkDeviceCagegoryDTO;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceCagegoryService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.List;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("api/yt/deviceCagegory")
+@Api(tags = {"设备类型管理"})
+@Slf4j
+public class TkDeviceCagegoryController extends BaseController {
+    private final TkDeviceCagegoryService tkDeviceCagegoryService;
+
+    @PostMapping("/getCagegoryByParentid")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("根据父类型获取设备类别")
+    public List<TkDeviceCagegoryDTO> getCagegoryByParentid(@RequestBody TkDeviceCagegoryDTO dto) throws ThingsboardException {
+        return tkDeviceCagegoryService.getCagegoryByParentid(dto.getParentId());
+    }
+
+    @PostMapping("/getAllCagegory")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("根据父类型获取设备类别")
+    public List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException {
+        return tkDeviceCagegoryService.getAllCagegory();
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<TkDeviceCagegoryDTO> save(@RequestBody TkDeviceCagegoryDTO tkMalfunctionReasonDTO) throws ThingsboardException {
+        tkMalfunctionReasonDTO.setTenantId(getCurrentUser().getCurrentTenantId());
+        TkDeviceCagegoryDTO deviceDTO = tkDeviceCagegoryService.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(tkDeviceCagegoryService.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划详情")
+    public ResponseEntity<TkDeviceCagegoryDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkDeviceCagegoryDTO dto = tkDeviceCagegoryService.detail(id);
+        return ResponseEntity.ok(dto);
+    }
+
+}

@@ -8,6 +8,7 @@ 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.TkMalfunctionReasonDTO;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.controller.BaseController;
@@ -15,7 +16,6 @@ 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;
@@ -35,20 +35,19 @@ public class TkMalfunctionReasonController extends BaseController {
     public TkPageData<TkMalfunctionReasonDTO> pageMalfunctionReason(
             @RequestParam(PAGE_SIZE) int pageSize,
             @RequestParam(PAGE) int page,
-            @RequestBody Map<String, Object> queryMap)
+            @RequestBody TkMalfunctionReasonDTO dto)
             throws ThingsboardException {
-        queryMap.put(PAGE, page);
-        queryMap.put(PAGE_SIZE, pageSize);
-        return tkMalfunctionReasonService.page(getCurrentUser().getCurrentTenantId(), queryMap);
+        dto.setPage(page);
+        dto.setPageSize(pageSize);
+        return tkMalfunctionReasonService.page(dto);
     }
 
     @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);
+            @RequestBody TkMalfunctionReasonDTO queryMap) throws ThingsboardException {
+        return tkMalfunctionReasonService.list(queryMap);
     }
 
     @PostMapping("/save")
@@ -65,5 +64,26 @@ public class TkMalfunctionReasonController extends BaseController {
         return ResponseEntity.ok(tkMalfunctionReasonService.delete(id));
     }
 
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("保养计划详情")
+    public ResponseEntity<TkMalfunctionReasonDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkMalfunctionReasonDTO dto = tkMalfunctionReasonService.detail(id);
+        return ResponseEntity.ok(dto);
+    }
+
+    @PostMapping("/updateStatus")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("更新保养计划状态")
+    public ResponseEntity<TkMalfunctionReasonDTO> updateStatus(@RequestBody TkMalfunctionReasonDTO dto) throws ThingsboardException {
+        TkMalfunctionReasonDTO orderInfo = tkMalfunctionReasonService.detail(dto.getId());
+        if (orderInfo == null) {
+            throw new TkDataValidationException("保养计划不存在！");
+        }
+
+        tkMalfunctionReasonService.updateStatus(dto.getId(), dto.getStatus());
+        return ResponseEntity.ok(orderInfo);
+    }
+
 
 }

+package org.thingsboard.server.common.data.yunteng.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.util.List;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TkDeviceCagegoryDTO extends TenantDTO {
+
+    @ApiModelProperty(value = "类别名称")
+    private String name;
+    @ApiModelProperty(value = "父级id")
+    private String parentId;
+    @ApiModelProperty(value = "排序")
+    private Integer cagegoryOrder;
+    @ApiModelProperty(value = "子类别")
+    private List<TkDeviceCagegoryDTO> children;
+}

@@ -13,4 +13,13 @@ public class TkMalfunctionReasonDTO extends TenantDTO {
 
     @ApiModelProperty(value = "原因")
     private String reason;
+
+    @ApiModelProperty(value = "状态(ENABLE启用,DISABLE停用)")
+    private String status;
+
+    @ApiModelProperty(value = "页号")
+    private Integer page;
+
+    @ApiModelProperty(value = "页码")
+    private Integer pageSize;
 }

+package org.thingsboard.server.common.data.yunteng.enums;
+
+public enum MalfunctionReasonStatusEnum {
+    //启用
+    ENABLE,
+    //停用
+    DISABLE
+}

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

+package org.thingsboard.server.dao.util;
+
+import com.google.common.collect.Lists;
+import org.thingsboard.server.common.data.yunteng.dto.TkDeviceCagegoryDTO;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 用于获取树形结构
+ */
+public class TkDeviceCagegoryUtil {
+
+    private List<TkDeviceCagegoryDTO> rootList; // 根节点对象存放到这里
+
+    private List<TkDeviceCagegoryDTO> bodyList; // 其他节点存放到这里，可以包含根节点
+
+    public TkDeviceCagegoryUtil(List<TkDeviceCagegoryDTO> rootList, List<TkDeviceCagegoryDTO> bodyList) {
+        this.rootList = rootList;
+        this.bodyList = bodyList;
+    }
+
+    public List<TkDeviceCagegoryDTO> getTree() {
+        if (bodyList != null && !bodyList.isEmpty()) {
+            // 声明一个map，用来过滤已操作过的数据
+            Map<String, String> map = new HashMap<>();
+            rootList.forEach(beanTree -> getChild(beanTree, map));
+            return rootList;
+        }
+        return null;
+    }
+
+    public void getChild(TkDeviceCagegoryDTO beanTree, Map<String, String> map) {
+        List<TkDeviceCagegoryDTO> childList = Lists.newArrayList();
+        bodyList.stream().filter(c -> !map.containsKey(c.getId())).filter(c -> c.getParentId().equals(beanTree.getId()))
+                .forEach(c -> {
+                    map.put(c.getId(), c.getParentId());
+                    getChild(c, map);
+                    childList.add(c);
+                });
+        beanTree.setChildren(childList);
+    }
+
+}

+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.TKDEVICECAGEGORY_TABLE_NAME, autoResultMap = true)
+public class TkDeviceCagegoryEntity extends TenantBaseEntity {
+    private String name;
+    private String parentId;
+    private Integer cagegoryOrder;
+}

@@ -14,5 +14,6 @@ import org.thingsboard.server.dao.model.ModelConstants;
 public class TkMalfunctionReasonEntity extends TenantBaseEntity {
     private String code;
     private String reason;
+    private String status;
 
 }

@@ -446,7 +446,7 @@ public class SysUserServiceImpl extends AbstractBaseService<UserMapper, SysUserE
               organizationIds.toArray(new String[organizationIds.size()]));
     }
     //过滤当前组织的上级组织的账号
-    userIds = filterParentUserId(tenantId,organizationId,userIds);
+   //userIds = filterParentUserId(tenantId,organizationId,userIds);
     return userIds;
   }
 
@@ -466,7 +466,7 @@ public class SysUserServiceImpl extends AbstractBaseService<UserMapper, SysUserE
         }
       }
       if(!filterUserIds.isEmpty()){
-        filterUserIds.remove(currentUserId);
+//        filterUserIds.remove(currentUserId);
         userIds = new ArrayList<>();
         userIds.addAll(filterUserIds);
       }

+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.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.TkDeviceCagegoryDTO;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
+import org.thingsboard.server.dao.util.TkDeviceCagegoryUtil;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceCagegoryEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkDeviceCagegoryMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceCagegoryService;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkDeviceCagegoryServiceImpl extends AbstractBaseService<TkDeviceCagegoryMapper, TkDeviceCagegoryEntity>
+        implements TkDeviceCagegoryService {
+
+    @Override
+    public TkDeviceCagegoryDTO save(TkDeviceCagegoryDTO tkDeviceCagegoryDTO) throws ThingsboardException {
+        checkDto(tkDeviceCagegoryDTO);
+        TkDeviceCagegoryEntity entity = new TkDeviceCagegoryEntity();
+        if (StringUtils.isBlank(tkDeviceCagegoryDTO.getId())) {
+            tkDeviceCagegoryDTO.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkDeviceCagegoryEntity> filter = new QueryWrapper<TkDeviceCagegoryEntity>().lambda()
+                    .eq(TkDeviceCagegoryEntity::getId, tkDeviceCagegoryDTO.getId());
+            entity = tkDeviceCagegoryDTO.getEntity(TkDeviceCagegoryEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+
+        entity.copyToDTO(tkDeviceCagegoryDTO);
+        return tkDeviceCagegoryDTO;
+    }
+
+    private void checkDto(TkDeviceCagegoryDTO dto) throws ThingsboardException {
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+    }
+
+    @Override
+    public TkDeviceCagegoryDTO detail(String id) throws ThingsboardException {
+        TkDeviceCagegoryDTO result = null;
+        TkDeviceCagegoryEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkDeviceCagegoryDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    @Override
+    public boolean delete(String id) throws ThingsboardException {
+        List<TkDeviceCagegoryDTO> cagegoryList = getCagegoryByParentid(id);
+        if (CollectionUtils.isNotEmpty(cagegoryList)) {
+            throw new TkDataValidationException("类别下还有子项不能删除不存在！");
+        }
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    @Override
+    public List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException {
+        List<TkDeviceCagegoryDTO> topMenuList = getCagegoryByParentid(null);
+        List<TkDeviceCagegoryDTO> subMenu = getSubCategory();
+        TkDeviceCagegoryUtil utils = new TkDeviceCagegoryUtil(topMenuList, subMenu);
+        List<TkDeviceCagegoryDTO> result = utils.getTree();
+        return result;
+    }
+
+    private List<TkDeviceCagegoryDTO> getSubCategory() throws ThingsboardException {
+        QueryWrapper<TkDeviceCagegoryEntity> queryWrapper = new QueryWrapper();
+        LambdaQueryWrapper<TkDeviceCagegoryEntity> lambda = queryWrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkDeviceCagegoryEntity::getTenantId, tenantId.getId().toString());
+        lambda.isNotNull(TkDeviceCagegoryEntity::getParentId);
+        lambda.orderByAsc(TkDeviceCagegoryEntity::getCagegoryOrder);
+
+        List<TkDeviceCagegoryEntity> entityList = baseMapper.selectList(queryWrapper);
+        return Optional.ofNullable(entityList).map(all -> all.stream().map(item -> item.getDTO(TkDeviceCagegoryDTO.class))
+                .collect(Collectors.toList())).orElse(null);
+    }
+
+
+    @Override
+    public List<TkDeviceCagegoryDTO> getCagegoryByParentid(String parentId) throws ThingsboardException {
+        QueryWrapper<TkDeviceCagegoryEntity> queryWrapper = new QueryWrapper();
+        LambdaQueryWrapper<TkDeviceCagegoryEntity> lambda = queryWrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkDeviceCagegoryEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isBlank(parentId)) {
+            lambda.isNull(TkDeviceCagegoryEntity::getParentId);
+        } else {
+            lambda.eq(TkDeviceCagegoryEntity::getParentId, parentId);
+        }
+
+        lambda.orderByAsc(TkDeviceCagegoryEntity::getCagegoryOrder);
+
+        List<TkDeviceCagegoryEntity> entityList = baseMapper.selectList(queryWrapper);
+        return Optional.ofNullable(entityList).map(all -> all.stream().map(item -> item.getDTO(TkDeviceCagegoryDTO.class))
+                .collect(Collectors.toList())).orElse(null);
+    }
+}

@@ -2,15 +2,16 @@ 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 com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.stereotype.Service;
 import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.id.TenantId;
 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.enums.MalfunctionReasonStatusEnum;
 import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
 import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
 import org.thingsboard.server.dao.yunteng.entities.TkMalfunctionReasonEntity;
@@ -19,7 +20,6 @@ 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;
 
@@ -29,35 +29,49 @@ import java.util.stream.Collectors;
 public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfunctionReasonMapper, TkMalfunctionReasonEntity>
         implements TkMalfunctionReasonService {
     @Override
-    public TkPageData<TkMalfunctionReasonDTO> page(String tenantId, Map<String, Object> queryMap) {
+    public TkPageData<TkMalfunctionReasonDTO> page(TkMalfunctionReasonDTO condition) throws ThingsboardException {
 
         QueryWrapper<TkMalfunctionReasonEntity> wrapper = new QueryWrapper<>();
         LambdaQueryWrapper<TkMalfunctionReasonEntity> lambda = wrapper.lambda();
-        lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId);
-        if (queryMap != null && queryMap.get("code") != null) {
-            lambda.like(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isNotBlank(condition.getCode())) {
+            lambda.like(TkMalfunctionReasonEntity::getCode, condition.getCode());
         }
-        if (queryMap != null && queryMap.get("reason") != null) {
-            lambda.like(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
+
+        if (StringUtils.isNotBlank(condition.getReason())) {
+            lambda.like(TkMalfunctionReasonEntity::getReason, condition.getReason());
         }
 
-        IPage<TkMalfunctionReasonEntity> page = baseMapper.selectPage(
-                getPage(queryMap, "create_time", false), wrapper);
+        if (StringUtils.isNotBlank(condition.getStatus())) {
+            lambda.eq(TkMalfunctionReasonEntity::getStatus, condition.getStatus());
+        }
 
+        Page<TkMalfunctionReasonEntity> page = new Page<>();
+        page.setCurrent(condition.getPage());
+        page.setSize(condition.getPageSize());
+        page = baseMapper.selectPage(page, wrapper);
         return getPageData(page, TkMalfunctionReasonDTO.class);
     }
 
     @Override
-    public List<TkMalfunctionReasonDTO> list(String tenantId, Map<String, Object> queryMap) {
+    public List<TkMalfunctionReasonDTO> list(TkMalfunctionReasonDTO condition) throws ThingsboardException {
         QueryWrapper<TkMalfunctionReasonEntity> wrapper = new QueryWrapper<>();
         LambdaQueryWrapper<TkMalfunctionReasonEntity> lambda = wrapper.lambda();
-        lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId);
-        if (queryMap != null && queryMap.get("code") != null) {
-            lambda.like(TkMalfunctionReasonEntity::getCode, queryMap.get("code").toString());
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkMalfunctionReasonEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isNotBlank(condition.getCode())) {
+            lambda.like(TkMalfunctionReasonEntity::getCode, condition.getCode());
+        }
+
+        if (StringUtils.isNotBlank(condition.getReason())) {
+            lambda.like(TkMalfunctionReasonEntity::getReason, condition.getReason());
         }
-        if (queryMap != null && queryMap.get("reason") != null) {
-            lambda.like(TkMalfunctionReasonEntity::getReason, queryMap.get("reason").toString());
+
+        if (StringUtils.isNotBlank(condition.getStatus())) {
+            lambda.eq(TkMalfunctionReasonEntity::getStatus, condition.getStatus());
         }
+
         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);
@@ -83,6 +97,33 @@ public class TkMalfunctionReasonServiceImpl extends AbstractBaseService<TkMalfun
         return tkMalfunctionReasonDTO;
     }
 
+    @Override
+    public TkMalfunctionReasonDTO detail(String id) throws ThingsboardException {
+        TkMalfunctionReasonDTO result = null;
+        TkMalfunctionReasonEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkMalfunctionReasonDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    @Override
+    public void updateStatus(String id, String status) throws ThingsboardException {
+        TkMalfunctionReasonEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("故障原因不存在！");
+        }
+        MalfunctionReasonStatusEnum statusEnum = MalfunctionReasonStatusEnum.valueOf(status);
+        if (statusEnum == null) {
+            throw new TkDataValidationException("故障原因状态不存在！");
+        }
+        entity.setStatus(statusEnum.name());
+        LambdaQueryWrapper<TkMalfunctionReasonEntity> filter = new QueryWrapper<TkMalfunctionReasonEntity>().lambda()
+                .eq(TkMalfunctionReasonEntity::getId, entity.getId());
+        baseMapper.update(entity, filter);
+    }
+
     private void checkDto(TkMalfunctionReasonDTO dto) throws ThingsboardException {
         if (StringUtils.isBlank(dto.getTenantId())) {
             dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());

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

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkDeviceCagegoryDTO;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceCagegoryEntity;
+
+import java.util.List;
+
+public interface TkDeviceCagegoryService  extends BaseService<TkDeviceCagegoryEntity> {
+
+    TkDeviceCagegoryDTO save(TkDeviceCagegoryDTO tkDeviceCagegoryDTO) throws ThingsboardException;
+
+    TkDeviceCagegoryDTO detail(String id) throws ThingsboardException;
+
+    boolean delete(String id) throws ThingsboardException;
+
+    List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException;
+
+    List<TkDeviceCagegoryDTO> getCagegoryByParentid(String parentId) throws ThingsboardException;
+}

@@ -7,16 +7,19 @@ 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);
+    TkPageData<TkMalfunctionReasonDTO> page(TkMalfunctionReasonDTO condition) throws ThingsboardException;
 
-    List<TkMalfunctionReasonDTO> list(String tenantId, Map<String, Object> queryMap);
+    List<TkMalfunctionReasonDTO> list(TkMalfunctionReasonDTO condition) throws ThingsboardException;
 
     TkMalfunctionReasonDTO save(TkMalfunctionReasonDTO tkMalfunctionReasonDTO) throws ThingsboardException;
 
+    TkMalfunctionReasonDTO detail(String id) throws ThingsboardException;
+
+    void updateStatus(String id, String status) throws ThingsboardException;
+
     boolean delete(String id);
 
 

@@ -96,7 +96,7 @@
         profile_id,ifd.device_profile_id
         ,ifd.sn,ifd.brand,ifd.name,ifd.alias,ifd.device_info,ifd.tenant_id
         ,ifd.label,ifd.device_type,ifd.created_time,ifd.update_time,ifd.creator,
-        ifd.updater,ifd.organization_id,ifd.alarm_status,ifd.description
+        ifd.updater,ifd.organization_id,ifd.alarm_status,ifd.description,ifd.director_id,ifd.category_id
         <!--        ,attrAt.long_v last_activity_time,attrCt.long_v last_connect_time-->
     </sql>
     <sql id="detailColumns">