设备台账和供应商接口

@@ -292,6 +292,7 @@ CREATE TABLE "public"."qg_device_cagegory" (
   "name" varchar(50),
   "parent_id" varchar(36),
   "cagegory_order" int4,
+  "path_id" varchar(500),
   "tenant_id" varchar(36),
   "create_time" timestamp(6),
   "creator" varchar(36),

@@ -946,6 +946,7 @@ CREATE TABLE IF NOT EXISTS  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),
@@ -961,6 +962,7 @@ CREATE TABLE IF NOT EXISTS 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),
@@ -975,6 +977,8 @@ CREATE TABLE IF NOT EXISTS 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),
@@ -986,9 +990,10 @@ CREATE TABLE IF NOT EXISTS 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),
@@ -997,14 +1002,17 @@ CREATE TABLE IF NOT EXISTS qg_inspection_record
 
 CREATE TABLE IF NOT EXISTS  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)
 );
 
 CREATE TABLE IF NOT EXISTS  qg_preserve_detail (
@@ -1058,6 +1066,7 @@ CREATE TABLE IF NOT EXISTS  qg_device_cagegory (
   "name" varchar(50),
   "parent_id" varchar(36),
   "cagegory_order" int4,
+  "path_id" varchar(500),
   "tenant_id" varchar(36),
   "create_time" timestamp(6),
   "creator" varchar(36),

@@ -33,8 +33,8 @@ public class TkDeviceCagegoryController extends BaseController {
     @PostMapping("/getAllCagegory")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
     @ApiOperation("根据父类型获取设备类别")
-    public List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException {
-        return tkDeviceCagegoryService.getAllCagegory();
+    public List<TkDeviceCagegoryDTO> getAllCagegory(@RequestBody TkDeviceCagegoryDTO dto) throws ThingsboardException {
+        return tkDeviceCagegoryService.getAllCagegory(dto);
     }
 
     @PostMapping("/save")

+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.TkDeviceAccountDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkDeviceCagegoryDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkSupplierDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceAccountService;
+import org.thingsboard.server.dao.yunteng.service.TkDeviceCagegoryService;
+import org.thingsboard.server.dao.yunteng.service.TkSupplierService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.Map;
+
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE;
+import static org.thingsboard.server.common.data.yunteng.constant.QueryConstant.PAGE_SIZE;
+
+@RestController
+@TbCoreComponent
+@RequiredArgsConstructor
+@RequestMapping("api/yt/da")
+@Api(tags = {"设备台账管理"})
+@Slf4j
+public class TkDeviceAccountController extends BaseController {
+    private final TkDeviceAccountService tkDeviceAccountService;
+    private final TkSupplierService tkSupplierService;
+    private final TkDeviceCagegoryService tkDeviceCagegoryService;
+
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("设备台账保存")
+    public ResponseEntity<TkDeviceAccountDTO> save(@RequestBody TkDeviceAccountDTO dto) throws ThingsboardException {
+        if (StringUtils.isNotBlank(dto.getSupplierId())) {
+            TkSupplierDTO supplierDTO = tkSupplierService.detail(dto.getSupplierId());
+            if (supplierDTO == null) {
+                throw new TkDataValidationException("供应商不存在！");
+            }
+        }
+
+        if (StringUtils.isNotBlank(dto.getCategoryId())) {
+            TkDeviceCagegoryDTO cagegoryDTO = tkDeviceCagegoryService.detail(dto.getCategoryId());
+            if (cagegoryDTO == null) {
+                throw new TkDataValidationException("设备类型不存在！");
+            }
+        }
+
+        TkDeviceAccountDTO deviceAccountDTO = tkDeviceAccountService.save(dto);
+        return ResponseEntity.ok(deviceAccountDTO);
+    }
+
+    @GetMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("设备台账删除")
+    public ResponseEntity<Boolean> delete(@RequestParam("id") String id) throws ThingsboardException {
+        return ResponseEntity.ok(tkDeviceAccountService.delete(id));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("设备台账详情")
+    public ResponseEntity<TkDeviceAccountDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkDeviceAccountDTO deviceDTO = tkDeviceAccountService.detail(id);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("设备台账列表")
+    public TkPageData<TkDeviceAccountDTO> pageMalfunctionReason(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody Map<String, Object> params)
+            throws ThingsboardException {
+        params.put(PAGE, page);
+        params.put(PAGE_SIZE, pageSize);
+        return tkDeviceAccountService.page(params);
+    }
+}

@@ -31,7 +31,7 @@ public class TkMalfunctionReasonController extends BaseController {
 
     @PostMapping("/pageData")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
-    @ApiOperation("获取满足条件的所有设备")
+    @ApiOperation("故障原因分页")
     public TkPageData<TkMalfunctionReasonDTO> pageMalfunctionReason(
             @RequestParam(PAGE_SIZE) int pageSize,
             @RequestParam(PAGE) int page,
@@ -44,7 +44,7 @@ public class TkMalfunctionReasonController extends BaseController {
 
     @PostMapping("/list")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
-    @ApiOperation("获取满足条件的所有设备")
+    @ApiOperation("故障原因列表")
     public List<TkMalfunctionReasonDTO> list(
             @RequestBody TkMalfunctionReasonDTO queryMap) throws ThingsboardException {
         return tkMalfunctionReasonService.list(queryMap);
@@ -66,7 +66,7 @@ public class TkMalfunctionReasonController extends BaseController {
 
     @GetMapping("/detail")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
-    @ApiOperation("保养计划详情")
+    @ApiOperation("故障原因详情")
     public ResponseEntity<TkMalfunctionReasonDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
         TkMalfunctionReasonDTO dto = tkMalfunctionReasonService.detail(id);
         return ResponseEntity.ok(dto);
@@ -74,11 +74,11 @@ public class TkMalfunctionReasonController extends BaseController {
 
     @PostMapping("/updateStatus")
     @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
-    @ApiOperation("更新保养计划状态")
+    @ApiOperation("更新故障原因状态")
     public ResponseEntity<TkMalfunctionReasonDTO> updateStatus(@RequestBody TkMalfunctionReasonDTO dto) throws ThingsboardException {
         TkMalfunctionReasonDTO orderInfo = tkMalfunctionReasonService.detail(dto.getId());
         if (orderInfo == null) {
-            throw new TkDataValidationException("保养计划不存在！");
+            throw new TkDataValidationException("故障原因不存在！");
         }
 
         tkMalfunctionReasonService.updateStatus(dto.getId(), dto.getStatus());

+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.TkSupplierDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.controller.BaseController;
+import org.thingsboard.server.dao.yunteng.service.TkSupplierService;
+import org.thingsboard.server.queue.util.TbCoreComponent;
+
+import java.util.List;
+
+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/supplier")
+@Api(tags = {"供应商管理"})
+@Slf4j
+public class TkSupplierController extends BaseController {
+    private final TkSupplierService tkSupplierService;
+
+
+    @PostMapping("/pageData")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("供应商分页")
+    public TkPageData<TkSupplierDTO> pageMalfunctionReason(
+            @RequestParam(PAGE_SIZE) int pageSize,
+            @RequestParam(PAGE) int page,
+            @RequestBody TkSupplierDTO dto)
+            throws ThingsboardException {
+        dto.setPage(page);
+        dto.setPageSize(pageSize);
+        return tkSupplierService.page(dto);
+    }
+
+    @PostMapping("/list")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("供应商列表")
+    public List<TkSupplierDTO> list(
+            @RequestBody TkSupplierDTO queryMap) throws ThingsboardException {
+        return tkSupplierService.list(queryMap);
+    }
+
+    @PostMapping("/save")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("供应商保存")
+    public ResponseEntity<TkSupplierDTO> save(@RequestBody TkSupplierDTO param) throws ThingsboardException {
+        TkSupplierDTO deviceDTO = tkSupplierService.save(param);
+        return ResponseEntity.ok(deviceDTO);
+    }
+
+    @PostMapping("/delete")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    public ResponseEntity<Boolean> delete(@RequestBody TkSupplierDTO param) throws ThingsboardException {
+        return ResponseEntity.ok(tkSupplierService.delete(param.getIds()));
+    }
+
+    @GetMapping("/detail")
+    @PreAuthorize("hasAnyAuthority('TENANT_ADMIN','CUSTOMER_USER')")
+    @ApiOperation("供应商详情")
+    public ResponseEntity<TkSupplierDTO> detail(@RequestParam("id") String id) throws ThingsboardException {
+        TkSupplierDTO dto = tkSupplierService.detail(id);
+        return ResponseEntity.ok(dto);
+    }
+}

@@ -6,12 +6,13 @@ 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.TkDeviceAccountEnum;
 
 import java.time.LocalDateTime;
 
 @EqualsAndHashCode(callSuper = true)
 @Data
-public class TkDeviceAccountEntityDTO extends TenantDTO {
+public class TkDeviceAccountDTO extends TenantDTO {
     @ApiModelProperty(value = "设备名称")
     private String name;
 
@@ -22,7 +23,7 @@ public class TkDeviceAccountEntityDTO extends TenantDTO {
     private String categoryId;
 
     @ApiModelProperty(value = "状态(FAULT故障,NORMAL正常,SCRAP报废)")
-    private String status;
+    private TkDeviceAccountEnum status;
 
     @ApiModelProperty(value = "负责人id")
     private String directorId;
@@ -79,4 +80,7 @@ public class TkDeviceAccountEntityDTO extends TenantDTO {
 
     @ApiModelProperty(value = "类别名称")
     private String categoryName;
+
+    @ApiModelProperty(value = "供应商信息")
+    private TkSupplierDTO supplierInfo;
 }

+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 TkSupplierDTO extends TenantDTO {
+    @ApiModelProperty(value = "供应商名称")
+    private String name;
+    @ApiModelProperty(value = "供应商编号")
+    private String code;
+    @ApiModelProperty(value = "供应商联系人")
+    private String contacts;
+    @ApiModelProperty(value = "供应商联系人手机号")
+    private String contactsMobile;
+
+    @ApiModelProperty(value = "页号")
+    private Integer page;
+
+    @ApiModelProperty(value = "页码")
+    private Integer pageSize;
+
+    private List<String> ids;
+}

@@ -686,7 +686,7 @@ public class ModelConstants {
     public static final String TKDEVICECAGEGORY_TABLE_NAME = "qg_device_cagegory";//设备类别
     public static final String TKDEVICEACCOUNT_TABLE_NAME = "qg_device_account";//设备台账
     public static final String TKINSTALLLOCATION_TABLE_NAME = "qg_install_location";//设备台账
-    public static final String TKSUPPLIER_TABLE_NAME = "qg_supplier";//设备台账
+    public static final String TKSUPPLIER_TABLE_NAME = "qg_supplier";//供应商
 
     public static final String TKINSPECTIONPLAN_TABLE_NAME= "qg_inspection_plan"; // 巡检计划
     public static final String TKCHECKPLAN_TABLE_NAME= "qg_check_plan"; // 巡检/保养方案

@@ -3,6 +3,7 @@ package org.thingsboard.server.dao.yunteng.entities;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
+import org.thingsboard.server.common.data.yunteng.enums.TkDeviceAccountEnum;
 import org.thingsboard.server.dao.model.ModelConstants;
 
 import java.time.LocalDateTime;
@@ -17,7 +18,7 @@ public class TkDeviceAccountEntity extends TenantBaseEntity {
     private String name;
     private String code;
     private String categoryId;
-    private String status;
+    private TkDeviceAccountEnum status;
     private String directorId;
     private Boolean isOnline;
     private String brand;

+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.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.TkDeviceAccountDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkDeviceCagegoryDTO;
+import org.thingsboard.server.common.data.yunteng.dto.TkSupplierDTO;
+import org.thingsboard.server.common.data.yunteng.dto.UserDTO;
+import org.thingsboard.server.common.data.yunteng.utils.SpringBeanUtils;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceAccountEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkDeviceAccountMapper;
+import org.thingsboard.server.dao.yunteng.service.*;
+
+import java.util.Map;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkDeviceAccountServiceImpl extends AbstractBaseService<TkDeviceAccountMapper, TkDeviceAccountEntity>
+        implements TkDeviceAccountService {
+
+    private final TkSupplierService tkSupplierService;
+
+    private final TkDeviceCagegoryService tkDeviceCagegoryService;
+
+    private final TkUserService tkUserService;
+
+    @Override
+    public TkPageData<TkDeviceAccountDTO> page(Map<String, Object> params) {
+        TkPageData<TkDeviceAccountDTO> result = new TkPageData<>();
+        IPage<TkDeviceAccountEntity> page =
+                getPage(params, "create_time", false);
+
+        IPage<TkDeviceAccountDTO> pageData = baseMapper.getDataPage(page, params);
+        if (pageData != null) {
+            result.setItems(pageData.getRecords());
+        }
+        result.setTotal(Long.valueOf(pageData.getTotal()).intValue());
+        return result;
+    }
+
+    @Override
+    public TkDeviceAccountDTO save(TkDeviceAccountDTO dto) throws ThingsboardException {
+        checkDto(dto);
+
+        TkDeviceAccountEntity entity = new TkDeviceAccountEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkDeviceAccountEntity> filter = new QueryWrapper<TkDeviceAccountEntity>().lambda()
+                    .eq(TkDeviceAccountEntity::getId, dto.getId());
+            entity = dto.getEntity(TkDeviceAccountEntity.class);
+            baseMapper.update(entity, filter);
+        }
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    private void checkDto(TkDeviceAccountDTO dto) throws ThingsboardException {
+        if (StringUtils.isBlank(dto.getName())) {
+            throw new TkDataValidationException("名称不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getCategoryId())) {
+            throw new TkDataValidationException("设备类型不能为空！");
+        }
+
+        if (dto.getStatus() == null) {
+            throw new TkDataValidationException("状态不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getDirectorId())) {
+            throw new TkDataValidationException("负责人不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+    }
+
+    @Override
+    public TkDeviceAccountDTO detail(String id) throws ThingsboardException {
+        TkDeviceAccountDTO detail = new TkDeviceAccountDTO();
+        TkDeviceAccountEntity entity = baseMapper.selectById(id);
+        if (entity == null) {
+            throw new TkDataValidationException("数据不存在！");
+        }
+        entity.copyToDTO(detail);
+        String supplierId = entity.getSupplierId();
+        if (StringUtils.isNotBlank(supplierId)) {
+            TkSupplierDTO supplierDTO = tkSupplierService.detail(supplierId);
+            detail.setSupplierInfo(supplierDTO);
+        }
+
+        String categoryId = entity.getCategoryId();
+        if (StringUtils.isNotBlank(categoryId)) {
+            TkDeviceCagegoryDTO cagegoryDTO = tkDeviceCagegoryService.detail(categoryId);
+            detail.setCategoryName(cagegoryDTO.getName());
+        }
+
+        String directorId = entity.getDirectorId();
+        if (StringUtils.isNotBlank(directorId)) {
+            UserDTO userInfo = tkUserService.findUserInfoById(directorId);
+            detail.setDirectorName(userInfo.getRealName());
+        }
+
+        return detail;
+    }
+
+    @Override
+    public TkDeviceAccountDTO load(String id) throws ThingsboardException {
+        TkDeviceAccountDTO result = null;
+        TkDeviceAccountEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkDeviceAccountDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+}

@@ -10,6 +10,7 @@ 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.BaseDTO;
 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;
@@ -18,7 +19,9 @@ 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.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
@@ -75,14 +78,40 @@ public class TkDeviceCagegoryServiceImpl extends AbstractBaseService<TkDeviceCag
     }
 
     @Override
-    public List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException {
+    public List<TkDeviceCagegoryDTO> getAllCagegory(TkDeviceCagegoryDTO dto) throws ThingsboardException {
         List<TkDeviceCagegoryDTO> topMenuList = getCagegoryByParentid(null);
         List<TkDeviceCagegoryDTO> subMenu = getSubCategory();
+        if (CollectionUtils.isEmpty(subMenu)) {
+            return topMenuList;
+        }
+
+        if (StringUtils.isNotBlank(dto.getName())) {
+            Map<String, String> idMap = subMenu.stream().collect(Collectors.toMap(BaseDTO::getId, TkDeviceCagegoryDTO::getParentId));
+            List<String> filterIdList = subMenu.stream().filter(e -> e.getName().contains(dto.getName())).map(BaseDTO::getId).collect(Collectors.toList());
+            List<String> fullTreeIdList = getFullTreeId(filterIdList, idMap);
+            subMenu = subMenu.stream().filter(e -> fullTreeIdList.contains(e.getId())).collect(Collectors.toList());
+        }
         TkDeviceCagegoryUtil utils = new TkDeviceCagegoryUtil(topMenuList, subMenu);
         List<TkDeviceCagegoryDTO> result = utils.getTree();
         return result;
     }
 
+    private List<String> getFullTreeId(List<String> filterIdList, Map<String, String> idMap) {
+        List<String> result = new ArrayList<>();
+        for (String id : filterIdList) {
+            String parentId = idMap.get(id);
+            while (StringUtils.isNotBlank(parentId)) {
+                if (!result.contains(parentId)) {
+                    result.add(parentId);
+                }
+                parentId = idMap.get(parentId);
+            }
+        }
+        result.addAll(filterIdList);
+        return result;
+    }
+
+
     private List<TkDeviceCagegoryDTO> getSubCategory() throws ThingsboardException {
         QueryWrapper<TkDeviceCagegoryEntity> queryWrapper = new QueryWrapper();
         LambdaQueryWrapper<TkDeviceCagegoryEntity> lambda = queryWrapper.lambda();
@@ -115,4 +144,10 @@ public class TkDeviceCagegoryServiceImpl extends AbstractBaseService<TkDeviceCag
         return Optional.ofNullable(entityList).map(all -> all.stream().map(item -> item.getDTO(TkDeviceCagegoryDTO.class))
                 .collect(Collectors.toList())).orElse(null);
     }
+
+    @Override
+    public List<String> getCategoryIdParentid(String parentId) {
+        List<String> result=new ArrayList<>();
+        return null;
+    }
 }

+package org.thingsboard.server.dao.yunteng.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.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.TkSupplierDTO;
+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.TkSupplierEntity;
+import org.thingsboard.server.dao.yunteng.mapper.TkSupplierMapper;
+import org.thingsboard.server.dao.yunteng.service.AbstractBaseService;
+import org.thingsboard.server.dao.yunteng.service.TkSupplierService;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class TkSupplierServiceImpl extends AbstractBaseService<TkSupplierMapper, TkSupplierEntity>
+        implements TkSupplierService {
+    @Override
+    public TkPageData<TkSupplierDTO> page(TkSupplierDTO condition) throws ThingsboardException {
+        QueryWrapper<TkSupplierEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkSupplierEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkSupplierEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isNotBlank(condition.getCode())) {
+            lambda.like(TkSupplierEntity::getCode, condition.getCode());
+        }
+
+        if (StringUtils.isNotBlank(condition.getName())) {
+            lambda.like(TkSupplierEntity::getName, condition.getName());
+        }
+
+        lambda.orderByDesc(TenantBaseEntity::getCreateTime);
+
+        Page<TkSupplierEntity> page = new Page<>();
+        page.setCurrent(condition.getPage());
+        page.setSize(condition.getPageSize());
+        page = baseMapper.selectPage(page, wrapper);
+        return getPageData(page, TkSupplierDTO.class);
+    }
+
+    @Override
+    public List<TkSupplierDTO> list(TkSupplierDTO condition) throws ThingsboardException {
+        QueryWrapper<TkSupplierEntity> wrapper = new QueryWrapper<>();
+        LambdaQueryWrapper<TkSupplierEntity> lambda = wrapper.lambda();
+        TenantId tenantId = SpringBeanUtils.getTenantId();
+        lambda.eq(TkSupplierEntity::getTenantId, tenantId.getId().toString());
+        if (StringUtils.isNotBlank(condition.getCode())) {
+            lambda.like(TkSupplierEntity::getCode, condition.getCode());
+        }
+
+        if (StringUtils.isNotBlank(condition.getName())) {
+            lambda.like(TkSupplierEntity::getName, condition.getName());
+        }
+
+        lambda.orderByDesc(TenantBaseEntity::getCreateTime);
+
+        List<TkSupplierEntity> entitys = baseMapper.selectList(wrapper);
+        return Optional.ofNullable(entitys).map(all -> all.stream().map(item -> item.getDTO(TkSupplierDTO.class))
+                .collect(Collectors.toList())).orElse(null);
+    }
+
+    @Override
+    public TkSupplierDTO save(TkSupplierDTO dto) throws ThingsboardException {
+        checkDto(dto);
+        TkSupplierEntity entity = new TkSupplierEntity();
+        if (StringUtils.isBlank(dto.getId())) {
+            dto.copyToEntity(entity);
+            baseMapper.insert(entity);
+        } else {
+            LambdaQueryWrapper<TkSupplierEntity> filter = new QueryWrapper<TkSupplierEntity>().lambda()
+                    .eq(TkSupplierEntity::getId, dto.getId());
+            entity = dto.getEntity(TkSupplierEntity.class);
+            baseMapper.update(entity, filter);
+        }
+
+
+        entity.copyToDTO(dto);
+        return dto;
+    }
+
+    private void checkDto(TkSupplierDTO dto) throws ThingsboardException {
+        if (StringUtils.isBlank(dto.getName())) {
+            throw new TkDataValidationException("供应商名称不能为空！");
+        }
+
+        if (StringUtils.isBlank(dto.getTenantId())) {
+            dto.setTenantId(SpringBeanUtils.getTenantId().getId().toString());
+        }
+    }
+
+    @Override
+    public TkSupplierDTO detail(String id) throws ThingsboardException {
+        TkSupplierDTO result = null;
+        TkSupplierEntity entity = baseMapper.selectById(id);
+        if (entity != null) {
+            result = new TkSupplierDTO();
+            entity.copyToDTO(result);
+        }
+        return result;
+    }
+
+    @Override
+    public boolean delete(String id) {
+        int count = baseMapper.deleteById(id);
+        return count > 0;
+    }
+
+    @Override
+    public boolean delete(List<String> ids) {
+        if (CollectionUtils.isEmpty(ids)) {
+            throw new TkDataValidationException("id 不能为空！");
+        }
+        int count = baseMapper.deleteBatchIds(ids);
+        return count > 0;
+    }
+}

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

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

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkDeviceAccountDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkDeviceAccountEntity;
+
+import java.util.Map;
+
+public interface TkDeviceAccountService extends BaseService<TkDeviceAccountEntity> {
+    TkPageData<TkDeviceAccountDTO> page(Map<String, Object> params);
+
+    TkDeviceAccountDTO save(TkDeviceAccountDTO dto) throws ThingsboardException;
+
+    TkDeviceAccountDTO detail(String id) throws ThingsboardException;
+
+    TkDeviceAccountDTO load(String id) throws ThingsboardException;
+
+    boolean delete(String id);
+
+}

@@ -14,7 +14,9 @@ public interface TkDeviceCagegoryService  extends BaseService<TkDeviceCagegoryEn
 
     boolean delete(String id) throws ThingsboardException;
 
-    List<TkDeviceCagegoryDTO> getAllCagegory() throws ThingsboardException;
+    List<TkDeviceCagegoryDTO> getAllCagegory(TkDeviceCagegoryDTO condition) throws ThingsboardException;
 
     List<TkDeviceCagegoryDTO> getCagegoryByParentid(String parentId) throws ThingsboardException;
+
+    List<String> getCategoryIdParentid(String parentId);
 }

+package org.thingsboard.server.dao.yunteng.service;
+
+import org.thingsboard.server.common.data.exception.ThingsboardException;
+import org.thingsboard.server.common.data.yunteng.dto.TkSupplierDTO;
+import org.thingsboard.server.common.data.yunteng.utils.tools.TkPageData;
+import org.thingsboard.server.dao.yunteng.entities.TkSupplierEntity;
+
+import java.util.List;
+
+public interface TkSupplierService extends BaseService<TkSupplierEntity> {
+    TkPageData<TkSupplierDTO> page(TkSupplierDTO condition) throws ThingsboardException;
+
+    List<TkSupplierDTO> list(TkSupplierDTO condition) throws ThingsboardException;
+
+    TkSupplierDTO save(TkSupplierDTO tkMalfunctionReasonDTO) throws ThingsboardException;
+
+    TkSupplierDTO detail(String id) throws ThingsboardException;
+
+    boolean delete(String id);
+
+    boolean delete(List<String> ids);
+}

+<?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.TkDeviceAccountMapper">
+    <resultMap type="org.thingsboard.server.common.data.yunteng.dto.TkDeviceAccountDTO" id="deviceAccountMap">
+        <result property="id" column="id"/>
+        <result property="name" column="name"/>
+        <result property="code" column="code"/>
+        <result property="categoryId" column="category_id"/>
+        <result property="status" column="status" typeHandler="org.apache.ibatis.type.EnumTypeHandler"/>
+        <result property="directorId" column="director_id"/>
+        <result property="isOnline" column="is_online"/>
+        <result property="deviceImg" column="device_img"/>
+        <result property="brand" column="brand"/>
+        <result property="modelNum" column="model_num"/>
+        <result property="specifications" column="specifications"/>
+        <result property="manufacturer" column="manufacturer"/>
+        <result property="buyDate" column="buy_date"/>
+        <result property="price" column="price"/>
+        <result property="productDate" column="product_date"/>
+        <result property="receiveDate" column="receive_date"/>
+        <result property="registeDate" column="registe_date"/>
+        <result property="supplierId" column="supplier_id"/>
+        <result property="description" column="description"/>
+        <result property="categoryName" column="categoryName"/>
+        <result property="tenantId" column="tenant_id"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updater" column="updater"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="creator" column="creator"/>
+        <result property="directorName" column="directorName"/>
+        <association property="supplierInfo" javaType="org.thingsboard.server.common.data.yunteng.dto.TkSupplierDTO">
+            <id property="id" column="director_id"/>
+            <result property="name" column="supplierName"/>
+            <result property="code" column="supplierCode"/>
+            <result property="contacts" column="contacts"/>
+            <result property="contactsMobile" column="contactsMobile"/>
+        </association>
+    </resultMap>
+    <select id="getDataPage" resultMap="deviceAccountMap">
+        SELECT
+        o.id,o.name,o.code,o.category_id,o.status,o.director_id,o.is_online,o.device_img,o.brand,
+        o.model_num,o.specifications,o.manufacturer,o.buy_date,o.price,o.product_date,o.receive_date,
+        o.registe_date,o.supplier_id,o.description,dc.name as categoryName,
+        sp.name as supplierName,sp.code as supplierCode,sp.contacts,sp.contacts_mobile ascontactsMobile,
+        o.tenant_id,o.create_time,o.updater,o.update_time,o.creator,su.real_name as directorName
+        from qg_device_account o
+        inner join sys_user su on su.id=o.director_id
+        inner join qg_supplier sp on sp.id=o.supplier_id
+        inner join qg_device_cagegory dc on dc.id=o.category_id
+        <where>
+            <if test="queryMap.tenantId !=null ">
+                AND o.tenant_id = #{queryMap.tenantId}
+            </if>
+            <if test="queryMap.code !=null ">
+                AND o.code LIKE concat('%',#{queryMap.code}::TEXT,'%')
+            </if>
+            <if test="queryMap.status !=null ">
+                AND o.status = #{queryMap.status}
+            </if>
+            <if test="queryMap.directorId !=null ">
+                AND o.director_id = #{queryMap.directorId}
+            </if>
+            <if test="queryMap.categoryIds !=null">
+                AND o.category_id in
+                <foreach collection="categoryIds" item="item" index="index"
+                         separator="," open="(" close=")">
+                    #{item}
+                </foreach>
+            </if>
+        </where>
+    </select>
+</mapper>
\ No newline at end of file