国动办平台数据推送

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/controller/AlarmDataController.java

@@ -0,0 +1,2 @@
+package com.usky.cdi.controller;public class AlarmDataController {
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/controller/web/BaseBuildFacilityController.java

@@ -0,0 +1,21 @@
+package com.usky.cdi.controller.web;
+
+
+import org.springframework.web.bind.annotation.RequestMapping;
+
+import org.springframework.stereotype.Controller;
+
+/**
+ * <p>
+ * 建筑设施 前端控制器
+ * </p>
+ *
+ * @author fu
+ * @since 2025-12-02
+ */
+@Controller
+@RequestMapping("/baseBuildFacility")
+public class BaseBuildFacilityController {
+
+}
+

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/controller/web/DmpDeviceInfoController.java

@@ -0,0 +1,229 @@
+package com.usky.iot.controller.web;
+
+import com.usky.backend.domain.*;
+import com.usky.common.core.bean.ApiResult;
+import com.usky.common.core.bean.CommonPage;
+import com.usky.common.core.utils.poi.ExcelUtil;
+import com.usky.demo.domain.LastInnerQueryVO;
+import com.usky.iot.domain.DmpDeviceInfo;
+import com.usky.iot.service.DmpDeviceInfoService;
+import com.usky.iot.service.vo.*;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 设备信息表
+ *
+ * @author ya
+ * @since 2022-10-08
+ */
+@RestController
+@RequestMapping("/dmpDeviceInfo")
+public class DmpDeviceInfoController {
+
+    @Autowired
+    private DmpDeviceInfoService dmpDeviceInfoService;
+
+    /**
+     * 新增
+     * @param dmpDeviceInfo
+     * @return
+     */
+    @PostMapping
+    public ApiResult<Void> add(@RequestBody DmpDeviceInfo dmpDeviceInfo) {
+        dmpDeviceInfoService.add(dmpDeviceInfo);
+        return ApiResult.success();
+    }
+
+    /**
+     * 修改
+     * @param dmpDeviceInfo
+     * @return
+     */
+    @PutMapping
+    public ApiResult<Void> edit(@RequestBody DmpDeviceInfo dmpDeviceInfo) {
+        dmpDeviceInfoService.update(dmpDeviceInfo);
+        return ApiResult.success();
+    }
+
+    /**
+     * 更新设备列表状态
+     * @param queryVO
+     * @return
+     */
+    @PostMapping("updateDeviceStatus")
+    public ApiResult<Void> updateDeviceStatus(@RequestBody LastInnerQueryVO queryVO){
+        dmpDeviceInfoService.updateDeviceStatus(queryVO);
+        return ApiResult.success();
+    }
+
+    /**
+     * 分页
+     * @param dmpDeviceInfoRequest
+     * @return
+     */
+    @PostMapping("/page")
+    public ApiResult<CommonPage<DmpDeviceInfo>> page(@RequestBody DmpDeviceInfoRequest dmpDeviceInfoRequest) {
+        return ApiResult.success(dmpDeviceInfoService.page(dmpDeviceInfoRequest));
+    }
+
+
+    /**
+     * 分页-白名单
+     * @param dmpDeviceInfoRequest
+     * @return
+     */
+    @PostMapping("/pageWhite")
+    public ApiResult<CommonPage<DmpDeviceInfo>> pageWhite(@RequestBody DmpDeviceInfoRequest dmpDeviceInfoRequest) {
+        return ApiResult.success(dmpDeviceInfoService.pageWhite(dmpDeviceInfoRequest));
+    }
+
+    /**
+     * 删除记录
+     */
+    @DeleteMapping("/{id}")
+    public ApiResult<Void> remove(@PathVariable("id") Integer id) {
+        dmpDeviceInfoService.remove(id);
+        return ApiResult.success();
+    }
+
+    /**
+     * 批量导入
+     * @param multipartFiles
+     * @return
+     */
+    @PostMapping("/addByFile")
+    public ApiResult<Void> addByFile(@RequestParam(value = "file") MultipartFile multipartFiles) {
+        dmpDeviceInfoService.addByFile(multipartFiles);
+        return ApiResult.success();
+    }
+
+    /**
+     * 批量导入-对接客户
+     *
+     * @param list
+     * @return
+     */
+    @PostMapping("/importDeviceInfo")
+    public ApiResult<Void> importDeviceInfo(@RequestBody List<DmpDeviceInfo> list) {
+        dmpDeviceInfoService.importDeviceInfo(list);
+        return ApiResult.success();
+    }
+
+    /**
+     * 导出
+     * @param dmpDeviceInfoRequest
+     * @param response
+     * @return
+     */
+    @PostMapping("/export")
+    public void export(@RequestBody DmpDeviceInfoRequest dmpDeviceInfoRequest, HttpServletResponse response) {
+        dmpDeviceInfoService.export(dmpDeviceInfoRequest, response);
+    }
+
+    /**
+     * 数据中心-设备实时心跳数据接口
+     *
+     * @param deviceName 设备名称
+     * @param installAddress 设备安装位置
+     * @param productCode   产品编码
+     * @param pageNum  当前页
+     * @param pageSize  每页条数
+     * @return
+     */
+    @GetMapping("deviceCurrentDataList")
+    public ApiResult<CommonPage<Object>> deviceCurrentDataList(@RequestParam(value = "deviceName", required = false) String deviceName,
+                                                               @RequestParam(value = "installAddress", required = false) String installAddress,
+                                                               @RequestParam(value = "productCode", required = false) String productCode,
+                                                               @RequestParam(value = "pageNum", required = false, defaultValue = "1") Integer pageNum,
+                                                               @RequestParam(value = "pageSize", required = false, defaultValue = "10") Integer pageSize) {
+        return ApiResult.success(dmpDeviceInfoService.deviceCurrentDataList(deviceName, installAddress, productCode, pageNum, pageSize));
+    }
+
+    /**
+     * 监控电视墙实时数据
+     *
+     * @param requestVO
+     * @return
+     */
+    @PostMapping("dataTVList")
+    public ApiResult<CommonPage<DataTVResponseVO>> dataTVList(@RequestBody DataTVRequestVO requestVO) {
+        return ApiResult.success(dmpDeviceInfoService.dataTVList(requestVO));
+    }
+
+    /**
+     * 监控电视墙设备（告警、离线）统计
+     *
+     * @param requestVO
+     * @return
+     */
+    @PostMapping("dataTVStatistic")
+    public ApiResult<List<DataTVStatisticResponseVO>> dataTVStatistic(@RequestBody DataTVRequestVO requestVO) {
+        return ApiResult.success(dmpDeviceInfoService.dataTVStatistic(requestVO));
+    }
+
+    /**
+     * 获取设备某个时间端内的汇总值
+     * @param requestVO
+     * @return
+     */
+    @PostMapping("deviceDataTotal")
+    @ApiOperation("获取设备某个时间端内的汇总值")
+    public ApiResult<List<Map<String, Object>>> deviceDataTotal(@RequestBody DataTotalRequestVO requestVO) {
+        return ApiResult.success(dmpDeviceInfoService.deviceDataTotal(requestVO));
+    }
+
+    /**
+     * 设备日平均值、月平均值、年平均值
+     * @param requestVO
+     * @return
+     */
+    @PostMapping("deviceDataAverage")
+    @ApiOperation("获取设备日平均、月平均、年平均值")
+    public ApiResult<List<DataAverageResponseVO>> deviceDataAverage(@RequestBody DataAverageRequestVO requestVO) {
+        return ApiResult.success(dmpDeviceInfoService.deviceDataAverage(requestVO));
+    }
+
+    /**
+     * 设备日平均值、月平均值、年平均值导出
+     * @param requestVO
+     * @param response
+     * @throws IOException
+     */
+    @PostMapping("deviceDataAverageExport")
+    public void export(@RequestBody DataAverageRequestVO requestVO, HttpServletResponse response) throws IOException {
+        List<DataAverageExportVO> list = dmpDeviceInfoService.DataAverageExport(requestVO);
+        ExcelUtil<DataAverageExportVO> util = new ExcelUtil<DataAverageExportVO>(DataAverageExportVO.class);
+        util.exportExcel(response, list, requestVO.getSheetName(), requestVO.getTitleName());
+    }
+
+    /**
+     * 获取设备topic列表
+     * @param requestVO
+     * @return
+     */
+    @PostMapping("topic")
+    public ApiResult<CommonPage<DmpTopicResponseVO>> topic(@RequestBody DmpTopicRequestVO requestVO) {
+        return ApiResult.success(dmpDeviceInfoService.topic(requestVO));
+    }
+
+    /**
+     * 获取设备告警请求信息
+     * @param deviceId 设备id
+     * @param productCode 产品编码
+     * @return
+     */
+    @GetMapping("alarmResponse")
+    public ApiResult<DmpHttpAlarmResponseVO> alarmResponse(@RequestParam(value = "deviceId") String deviceId,
+                                                           @RequestParam(value = "productCode") String productCode){
+        return ApiResult.success(dmpDeviceInfoService.alarmResponse(deviceId, productCode));
+    }
+}
+

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/domain/BaseBuildFacility.java

@@ -0,0 +1,162 @@
+package com.usky.cdi.domain;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import java.time.LocalDateTime;
+import java.io.Serializable;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+/**
+ * <p>
+ * 建筑设施
+ * </p>
+ *
+ * @author fu
+ * @since 2025-12-02
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+public class BaseBuildFacility implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    /**
+     * 设施编号
+     */
+    private String facilityNum;
+
+    /**
+     * 设施名称
+     */
+    private String facilityName;
+
+    /**
+     * 设施类型
+     */
+    private String facilityType;
+
+    /**
+     * 所属楼层
+     */
+    private String floor;
+
+    /**
+     * 安装位置
+     */
+    private String address;
+
+    /**
+     * 图⽚地址URL
+     */
+    private String imagesUrl;
+
+    /**
+     * 设备ID
+     */
+    private String deviceId;
+
+    /**
+     * 联系人
+     */
+    private String contact;
+
+    /**
+     * 联系方式
+     */
+    private String contactPhone;
+
+    /**
+     * 平面X轴坐标
+     */
+    private String planeX;
+
+    /**
+     * 平面Y轴坐标
+     */
+    private String planeY;
+
+    private String coordinateX;
+
+    private String coordinateY;
+
+    private String coordinateZ;
+
+    /**
+     * 删除标识
+     */
+    private Integer deleteFlag;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime;
+
+    /**
+     * 更新人
+     */
+    private String updateBy;
+
+    /**
+     * 创建人
+     */
+    private String createBy;
+
+    /**
+     * 组织结构ID
+     */
+    private Integer deptId;
+
+    /**
+     * 租户ID
+     */
+    private Integer tenantId;
+
+    /**
+     * 建筑设施备注
+     */
+    private String facilityDesc;
+
+    /**
+     * 三维角度X
+     */
+    private Double anglesX;
+
+    /**
+     * 三维角度y
+     */
+    private Double anglesY;
+
+    /**
+     * 三维角度z
+     */
+    private Double anglesZ;
+
+    /**
+     * 三维图标大小
+     */
+    private Double scaleL;
+
+    /**
+     * 三维图标大小
+     */
+    private Double scaleW;
+
+    /**
+     * 三维图标大小
+     */
+    private Double scaleH;
+
+
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/mapper/BaseBuildFacilityMapper.java

@@ -0,0 +1,16 @@
+package com.usky.cdi.mapper;
+
+import com.usky.cdi.domain.BaseBuildFacility;
+import com.usky.common.mybatis.core.CrudMapper;
+
+/**
+ * <p>
+ * 建筑设施 Mapper 接口
+ * </p>
+ *
+ * @author fu
+ * @since 2025-12-02
+ */
+public interface BaseBuildFacilityMapper extends CrudMapper<BaseBuildFacility> {
+
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/BaseBuildFacilityService.java

@@ -0,0 +1,16 @@
+package com.usky.cdi.service;
+
+import com.usky.cdi.domain.BaseBuildFacility;
+import com.usky.common.mybatis.core.CrudService;
+
+/**
+ * <p>
+ * 建筑设施 服务类
+ * </p>
+ *
+ * @author fu
+ * @since 2025-12-02
+ */
+public interface BaseBuildFacilityService extends CrudService<BaseBuildFacility> {
+
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/DmpDeviceInfoService.java

@@ -0,0 +1,100 @@
+package com.usky.iot.service;
+
+import com.usky.backend.domain.*;
+import com.usky.common.core.bean.CommonPage;
+import com.usky.common.mybatis.core.CrudService;
+import com.usky.demo.domain.LastInnerQueryVO;
+import com.usky.iot.domain.DmpDeviceInfo;
+import com.usky.iot.service.vo.*;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.servlet.http.HttpServletResponse;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * <p>
+ * 设备信息表
+ * </p>
+ *
+ * @author ya
+ * @since 2022-10-08
+ */
+public interface DmpDeviceInfoService extends CrudService<DmpDeviceInfo> {
+
+    void add(DmpDeviceInfo dmpDeviceInfo);
+
+    void update(DmpDeviceInfo dmpDeviceInfo);
+
+    boolean checkNameUnique(DmpDeviceInfo dmpDeviceInfo);
+
+    boolean checkNameUnique1(DmpDeviceInfo dmpDeviceInfo,Integer tenantId);
+
+    void deviceStatus();
+
+    void updateDeviceStatus(LastInnerQueryVO queryVO);
+
+    CommonPage<DmpDeviceInfo> page(DmpDeviceInfoRequest dmpDeviceInfoRequest);
+
+    CommonPage<DmpDeviceInfo> pageWhite(DmpDeviceInfoRequest dmpDeviceInfoRequest);
+
+    boolean remove(Integer id);
+
+    /**
+     * 设备状态统计
+     * @return
+     */
+    List<Map<String,Object>> deviceCollect(List<Integer> productIds);
+
+    /**
+     * 设备总数
+     * @param productId
+     * @return
+     */
+    int deviceCountByProductId(Integer productId);
+
+    void addByFile(MultipartFile multipartFiles);
+
+    void importDeviceInfo(List<DmpDeviceInfo> list);
+
+    /**
+     * 导出
+     * @param dmpDeviceInfoRequest
+     */
+    void export(DmpDeviceInfoRequest dmpDeviceInfoRequest, HttpServletResponse response);
+
+    CommonPage<Object> deviceCurrentDataList(String deviceName,String installAddress,String productCode,Integer pageNum,Integer pageSize);
+
+    CommonPage<DataTVResponseVO> dataTVList(DataTVRequestVO requestVO);
+
+    List<DataTVStatisticResponseVO> dataTVStatistic(DataTVRequestVO requestVO);
+
+    List<Map<String,Object>> deviceDataTotal(DataTotalRequestVO requestVO);
+    List<DataAverageResponseVO> deviceDataAverage(DataAverageRequestVO requestVO);
+    List<DataAverageExportVO> DataAverageExport(DataAverageRequestVO requestVO);
+
+    Map<String,Object> control(String productCode, String deviceUuid, String commandCode, String commandValue, String domain, Long userId, String userName);
+
+    /**
+     * @description: 获取设备topic列表
+     * @author: fyc
+     * @email yuchuan.fu@chinausky.com
+     * @date: 2025/2/7 17:49
+     * @param: [pageNum, pageSize]
+     * @return: java.util.List<com.usky.iot.service.vo.DmpTopicResponseVO>
+     **/
+    CommonPage<DmpTopicResponseVO> topic(DmpTopicRequestVO requestVO);
+
+    /**
+     * @description: 获取设备告警请求信息
+     * @author: fyc
+     * @email yuchuan.fu@chinausky.com
+     * @date: 2025/2/7 17:49
+     * @param: [deviceId, productCode]
+     * @return: com.usky.iot.service.vo.DmpHttpAlarmResponseVO
+     **/
+    DmpHttpAlarmResponseVO alarmResponse(String deviceId, String productCode);
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/impl/AlarmDataTransferService.java

@@ -0,0 +1,2 @@
+package com.usky.cdi.service.impl;public class AlarmDataTransferService {
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/impl/BaseBuildFacilityServiceImpl.java

@@ -0,0 +1,20 @@
+package com.usky.cdi.service.impl;
+
+import com.usky.cdi.domain.BaseBuildFacility;
+import com.usky.cdi.mapper.BaseBuildFacilityMapper;
+import com.usky.cdi.service.BaseBuildFacilityService;
+import com.usky.common.mybatis.core.AbstractCrudService;
+import org.springframework.stereotype.Service;
+
+/**
+ * <p>
+ * 建筑设施 服务实现类
+ * </p>
+ *
+ * @author fu
+ * @since 2025-12-02
+ */
+@Service
+public class BaseBuildFacilityServiceImpl extends AbstractCrudService<BaseBuildFacilityMapper, BaseBuildFacility> implements BaseBuildFacilityService {
+
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/impl/DmpDeviceInfoServiceImpl.java

@@ -0,0 +1,1384 @@
+package com.usky.iot.service.impl;
+
+
+import cn.afterturn.easypoi.excel.ExcelExportUtil;
+import cn.afterturn.easypoi.excel.ExcelImportUtil;
+import cn.afterturn.easypoi.excel.entity.ExportParams;
+import cn.afterturn.easypoi.excel.entity.ImportParams;
+import cn.hutool.core.collection.CollectionUtil;
+import cn.hutool.core.date.DateTime;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.ArrayUtils;
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.mysql.cj.x.protobuf.MysqlxDatatypes;
+import com.usky.backend.client.DataQueryClient;
+import com.usky.backend.client.DeviceDataClient;
+import com.usky.backend.domain.*;
+import com.usky.backend.domain.response.DataRealTimeResponseVO;
+import com.usky.common.core.bean.ApiResult;
+import com.usky.common.core.bean.CommonPage;
+import com.usky.common.core.exception.BusinessException;
+import com.usky.common.core.util.BeanMapperUtils;
+import com.usky.common.core.util.UUIDUtils;
+import com.usky.common.mybatis.core.AbstractCrudService;
+import com.usky.demo.RemoteTsdbProxyService;
+import com.usky.demo.domain.LastInnerQueryVO;
+import com.usky.demo.domain.LastInnerResultVO;
+import com.usky.iot.domain.*;
+import com.usky.common.security.utils.SecurityUtils;
+import com.usky.iot.mapper.DmpDeviceInfoMapper;
+import com.usky.iot.mapper.DmpProductAttributeMapper;
+import com.usky.iot.service.BaseFacilityDeviceService;
+import com.usky.iot.service.DmpDeviceInfoService;
+import com.usky.iot.service.DmpDeviceStatusService;
+import com.usky.iot.service.DmpProductAttributeService;
+import com.usky.iot.service.enums.TopicInfo;
+import com.usky.iot.service.vo.*;
+import com.usky.transfer.RemoteTransferService;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.poi.ss.usermodel.Workbook;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.interceptor.TransactionAspectSupport;
+import org.springframework.web.multipart.MultipartFile;
+import sun.net.dns.ResolverConfiguration;
+
+import javax.servlet.ServletOutputStream;
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneOffset;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * <p>
+ * 设备信息表 服务实现类
+ * </p>
+ *
+ * @author ya
+ * @since 2022-10-08
+ */
+@Slf4j
+@Service
+public class DmpDeviceInfoServiceImpl extends AbstractCrudService<DmpDeviceInfoMapper, DmpDeviceInfo> implements DmpDeviceInfoService {
+    @Autowired
+    private DmpDeviceStatusService dmpDeviceStatusService;
+
+    @Autowired
+    private DmpProductAttributeService dmpProductAttributeService;
+
+    @Autowired
+    private BaseFacilityDeviceService baseFacilityDeviceService;
+
+    @Autowired
+    private DeviceDataClient deviceDataClient;
+
+    @Autowired
+    private DataQueryClient dataQueryClient;
+
+    @Autowired
+    private RemoteTransferService remoteTransferService;
+
+    @Autowired
+    private DmpProductAttributeMapper dmpProductAttributeMapper;
+
+    private static final String ALARM_HTTP_URL = "/service-alarm/baseAlarm/alarmInfo";
+
+    private RemoteTsdbProxyService remoteTsdbProxyService;
+
+
+    @Override
+    public Map<String, Object> control(String productCode, String deviceUuid, String commandCode, String commandValue, String domain, Long userId, String userName) {
+        Integer tenantId;
+        long commandUserId;
+        String commandUserName;
+        if (StringUtils.isNotBlank(domain)) {
+            tenantId = baseMapper.sysTenantId(domain);
+            commandUserId = userId;
+            commandUserName = userName;
+        } else {
+            tenantId = SecurityUtils.getTenantId();
+            commandUserId = SecurityUtils.getUserId();
+            commandUserName = SecurityUtils.getUsername();
+        }
+//
+//        //人员设备权限校验，校验通过，可以下发命令控制设备
+//        Integer fid = baseMapper.getMeetingFaceData(commandUserId);
+//        if(fid == null){
+//            throw new BusinessException("人脸卡号信息未注册");
+//        }
+//        Integer[] deviceFid = baseMapper.getMeetingFaceDeviceList(fid);
+//        if(deviceFid.length == 0){
+//            throw new BusinessException("人员未绑定设备，请检查");
+//        }
+//
+//        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+//        queryWrapper.select(DmpDeviceInfo::getId)
+//                .eq(DmpDeviceInfo::getDeviceId,deviceUuid)
+//                .eq(DmpDeviceInfo::getDeleteFlag,0);
+//        DmpDeviceInfo one = this.getOne(queryWrapper);
+//        if(one != null){
+//            boolean exist = Arrays.asList(deviceFid).contains(one.getId());
+//            if(!exist){
+//                throw new BusinessException("暂无权限");
+//            }
+//        }else{
+//            throw new BusinessException("设备未注册，请先注册");
+//        }
+
+
+        Map<String, Object> map = new HashMap<>();
+        map.put("method", "control");
+        Map<String, Object> map1 = new HashMap<>();
+        map1.put("commandCode", commandCode);
+        map1.put("commandValue", commandValue);
+        map.put("params", map1);
+
+        return remoteTransferService.deviceControl(productCode, deviceUuid, JSON.toJSONString(map), tenantId, commandUserId, commandUserName);
+    }
+
+    @Override
+    public CommonPage<DmpTopicResponseVO> topic(DmpTopicRequestVO requestVO) {
+
+        String productCode = requestVO.getProductCode();
+        String deviceId = requestVO.getDeviceId();
+        String deviceUuid = requestVO.getDeviceUuid();
+        String deviceName = requestVO.getDeviceName();
+        String simCode = requestVO.getSimCode();
+        String installAddress = requestVO.getInstallAddress();
+        Integer productId = requestVO.getProductId();
+        Integer pageNum = requestVO.getPageNum();
+        Integer pageSize = requestVO.getPageSize();
+
+        pageNum = (pageNum != null) ? pageNum : 1;
+        pageSize = (pageSize != null) ? pageSize : 10;
+
+        List<DmpTopicResponseVO> responseVOList = new ArrayList<>();
+        String topicType = requestVO.getTopicType();
+
+        if (topicType == null) {
+            if (StringUtils.isBlank(productCode)) {
+                throw new BusinessException("产品编码“productCode”不能为空！");
+            } else if (StringUtils.isBlank(deviceId)) {
+                throw new BusinessException("设备编号“deviceId”不能为空！");
+            } else if (StringUtils.isBlank(deviceUuid)) {
+                throw new BusinessException("设备uuid“deviceUuid“不能为空！");
+            }
+
+            DmpTopicResponseVO add = new DmpTopicResponseVO();
+            add.setTopic("/" + productCode + "/" + deviceId + "/" + TopicInfo.ADD_REMARKS.getLetter());
+            add.setPublisher(TopicInfo.GATEWAY_DEVICE.getValue());
+            add.setSubscriber(TopicInfo.IOT_PLATFORM.getValue());
+            add.setRemarks(TopicInfo.ADD_REMARKS.getValue());
+            responseVOList.add(add);
+
+            DmpTopicResponseVO info = new DmpTopicResponseVO();
+            info.setTopic("/" + productCode + "/" + deviceId + "/" + TopicInfo.INFO_REMARKS.getLetter());
+            info.setPublisher(TopicInfo.GATEWAY_DEVICE.getValue());
+            info.setSubscriber(TopicInfo.IOT_PLATFORM.getValue());
+            info.setRemarks(TopicInfo.INFO_REMARKS.getValue());
+            responseVOList.add(info);
+
+            DmpTopicResponseVO control = new DmpTopicResponseVO();
+            control.setTopic("/" + deviceUuid + "/" + TopicInfo.CONTROL_REMARKS.getLetter());
+            control.setSubscriber(TopicInfo.GATEWAY_DEVICE.getValue());
+            control.setPublisher(TopicInfo.IOT_PLATFORM.getValue());
+            control.setRemarks(TopicInfo.CONTROL_REMARKS.getValue());
+            responseVOList.add(control);
+
+            DmpTopicResponseVO controlResponse = new DmpTopicResponseVO();
+            controlResponse.setTopic("/" + deviceUuid + "/" + TopicInfo.CONTROL_RESPONSE_REMARKS.getLetter());
+            controlResponse.setPublisher(TopicInfo.GATEWAY_DEVICE.getValue());
+            controlResponse.setSubscriber(TopicInfo.IOT_PLATFORM.getValue());
+            controlResponse.setRemarks(TopicInfo.CONTROL_RESPONSE_REMARKS.getValue());
+            responseVOList.add(controlResponse);
+
+        } else {
+            switch (topicType) {
+                case "add":
+                    /*if (StringUtils.isBlank(productCode)) {
+                        throw new BusinessException("产品编码“productCode”不能为空！");
+                    } else if (StringUtils.isBlank(deviceId)) {
+                        throw new BusinessException("设备编号“deviceId”不能为空！");
+                    } else if (StringUtils.isBlank(deviceName)) {
+                        throw new BusinessException("设备名“deviceName“不能为空！");
+                    }
+
+                    DmpTopicResponseVO add = new DmpTopicResponseVO();
+                    add.setTopic("/" + productCode + "/" + deviceId + "/" + TopicInfo.ADD_REMARKS.getLetter());
+                    add.setPublisher(TopicInfo.GATEWAY_DEVICE.getValue());
+                    add.setSubscriber(TopicInfo.IOT_PLATFORM.getValue());
+                    add.setRemarks(TopicInfo.ADD_REMARKS.getValue());
+
+                    // 组装topicPayload
+                    JSONObject topicPayloadJson = new JSONObject();
+                    topicPayloadJson.put("productCode", productCode);
+                    topicPayloadJson.put("deviceId", deviceId);
+                    topicPayloadJson.put("deviceName", deviceName);
+                    if (!StringUtils.isBlank(simCode)) {
+                        topicPayloadJson.put("simCode", simCode);
+                    }
+                    if (!StringUtils.isBlank(installAddress)) {
+                        topicPayloadJson.put("installAddress", installAddress);
+                    }
+                    String topicPayload = topicPayloadJson.toString();
+                    add.setTopicPayload(topicPayload);
+                    responseVOList.add(add);*/
+                    break;
+                case "info":
+                    if (StringUtils.isBlank(productCode)) {
+                        throw new BusinessException("产品编码“productCode”不能为空！");
+                    } else if (productId == null) {
+                        throw new BusinessException("产品ID“productId“不能为空！");
+                    } else if (StringUtils.isBlank(deviceId)) {
+                        throw new BusinessException("设备编号“deviceId”不能为空！");
+                    }
+
+                    DmpTopicResponseVO info = new DmpTopicResponseVO();
+                    info.setTopic("/" + productCode + "/" + deviceId + "/" + TopicInfo.INFO_REMARKS.getLetter());
+                    info.setPublisher(TopicInfo.GATEWAY_DEVICE.getValue());
+                    info.setSubscriber(TopicInfo.IOT_PLATFORM.getValue());
+                    info.setRemarks(TopicInfo.INFO_REMARKS.getValue());
+
+                    // 组装topicPayload
+                    JSONObject infoPayloadJson = new JSONObject();
+                    infoPayloadJson.put("productCode", productCode);
+                    Long timestamp = System.currentTimeMillis();
+                    infoPayloadJson.put("timestamp", timestamp);
+
+                    JSONObject metricsJson = new JSONObject();
+                    List<DmpProductAttribute> productAttributeList = getProductAttributeList(productId);
+                    for (DmpProductAttribute productAttribute : productAttributeList) {
+                        metricsJson.put(productAttribute.getAttributeCode(), productAttribute.getMaximum());
+                    }
+                    infoPayloadJson.put("metrics", metricsJson);
+
+                    JSONObject tagsJson = new JSONObject();
+                    tagsJson.put("device_id", deviceId);
+                    infoPayloadJson.put("tags", tagsJson);
+                    String infoPayload = infoPayloadJson.toString();
+                    info.setTopicPayload(infoPayload);
+                    info.setProductAttributeList(productAttributeList);
+                    responseVOList.add(info);
+                    break;
+                case "control":
+                    /*if (StringUtils.isBlank(deviceUuid)) {
+                        throw new BusinessException("设备uuid“deviceUuid“不能为空！");
+                    }else if (StringUtils.isBlank(productCode)){
+                        throw new BusinessException("产品编码“productCode”不能为空！");
+                    }
+
+                    DmpTopicResponseVO control = new DmpTopicResponseVO();
+                    control.setTopic("/" + deviceUuid + "/" + TopicInfo.CONTROL_REMARKS.getLetter());
+                    control.setPublisher(TopicInfo.IOT_PLATFORM.getValue());
+                    control.setSubscriber(TopicInfo.GATEWAY_DEVICE.getValue());
+                    control.setRemarks(TopicInfo.CONTROL_REMARKS.getValue());
+
+                    // 组装topicPayload
+                    JSONObject controlPayloadJson = new JSONObject();
+
+                    responseVOList.add(control);*/
+                    break;
+                case "controlResponse":
+                    break;
+                default:
+                    throw new BusinessException("topicType参数错误！");
+            }
+        }
+
+        int fromIndex = (pageNum - 1) * pageSize;
+        int toIndex = Math.min(fromIndex + pageSize, responseVOList.size());
+        List<DmpTopicResponseVO> paginatedList = responseVOList.subList(fromIndex, toIndex);
+
+        IPage<DmpTopicResponseVO> page = new Page<>(pageNum, pageSize);
+        page.setRecords(paginatedList);
+        page.setTotal(responseVOList.size());
+        return ToCommonPage(page);
+    }
+
+    /**
+     * 获取产品属性列表
+     *
+     * @param productId
+     * @return
+     */
+    private List<DmpProductAttribute> getProductAttributeList(Integer productId) {
+        LambdaQueryWrapper<DmpProductAttribute> queryWrapper = new LambdaQueryWrapper<>();
+        queryWrapper.eq(DmpProductAttribute::getProductId, productId);
+        return dmpProductAttributeMapper.selectList(queryWrapper);
+    }
+
+    /**
+     * 获取设备告警信息
+     *
+     * @param deviceId
+     * @param productCode
+     * @return
+     */
+    @Override
+    public DmpHttpAlarmResponseVO alarmResponse(String deviceId, String productCode) {
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+        LocalDateTime now = LocalDateTime.now();
+        String alarmTime = now.format(formatter);
+
+        DmpHttpAlarmResponseVO responseVO = new DmpHttpAlarmResponseVO();
+        JSONObject alarmPayloadJson = new JSONObject();
+        alarmPayloadJson.put("productCode", productCode);
+        alarmPayloadJson.put("deviceId", deviceId);
+        alarmPayloadJson.put("alarmTime", alarmTime);
+        alarmPayloadJson.put("alarmType", "311");
+        alarmPayloadJson.put("alarmObject", "烟雾报警");
+        alarmPayloadJson.put("alarmData", "0");
+        alarmPayloadJson.put("alarmAttribute", "烟雾报警");
+        alarmPayloadJson.put("alarmContent", "烟感");
+        alarmPayloadJson.put("alarmGrade", 1);
+        alarmPayloadJson.put("alarmAddress", "上海市青浦区华徐公路628号C幢");
+        String alarmPayload = alarmPayloadJson.toString();
+        responseVO.setAlarmPayload(alarmPayload);
+        responseVO.setAlarmHttpUrl(ALARM_HTTP_URL);
+        return responseVO;
+    }
+
+    @Override
+    public void add(DmpDeviceInfo dmpDeviceInfo) {
+        if (checkNameUnique(dmpDeviceInfo)) {
+            throw new BusinessException("新增设备信息'" + dmpDeviceInfo.getDeviceId() + "'失败，设备信息已存在");
+        }
+        List<DmpProductInfo> list = baseMapper.getProductInfo(dmpDeviceInfo.getProductCode());
+        if (CollectionUtils.isNotEmpty(list)) {
+            dmpDeviceInfo.setDeviceType(list.get(0).getDeviceType());
+            dmpDeviceInfo.setProductId(list.get(0).getId());
+            dmpDeviceInfo.setCreatedBy(SecurityUtils.getUsername());
+            dmpDeviceInfo.setCreatedTime(LocalDateTime.now());
+            dmpDeviceInfo.setTenantId(SecurityUtils.getTenantId());
+//            dmpDeviceInfo.setServiceStatus(1);
+            if (StringUtils.isBlank(dmpDeviceInfo.getDeviceUuid())) {
+                dmpDeviceInfo.setDeviceUuid(UUIDUtils.uuid());
+            }
+            this.save(dmpDeviceInfo);
+
+            DmpDeviceStatus dmpDeviceStatus = new DmpDeviceStatus();
+            dmpDeviceStatus.setDeviceId(dmpDeviceInfo.getDeviceId());
+            dmpDeviceStatus.setProductId(dmpDeviceInfo.getProductId());
+            dmpDeviceStatus.setDeviceStatus(2);
+            dmpDeviceStatus.setLastOfflineTime(LocalDateTime.now());
+            dmpDeviceStatus.setProductCode(dmpDeviceInfo.getProductCode());
+            dmpDeviceStatus.setDeviceUuid(dmpDeviceInfo.getDeviceUuid());
+            dmpDeviceStatusService.save(dmpDeviceStatus);
+        } else {
+            throw new BusinessException("新增设备信息'" + dmpDeviceInfo.getDeviceId() + "'失败，无对应产品信息");
+        }
+    }
+
+    @Override
+    public void update(DmpDeviceInfo dmpDeviceInfo) {
+        dmpDeviceInfo.setUpdatedBy(SecurityUtils.getUsername());
+        dmpDeviceInfo.setUpdatedTime(LocalDateTime.now());
+        if (checkNameUnique(dmpDeviceInfo)) {
+            throw new BusinessException("修改设备信息'" + dmpDeviceInfo.getDeviceId() + "'失败，设备信息已存在");
+        }
+        this.updateById(dmpDeviceInfo);
+
+    }
+
+    @Override
+    public boolean checkNameUnique(DmpDeviceInfo dmpDeviceInfo) {
+        Integer id = null == dmpDeviceInfo.getId() ? -1 : dmpDeviceInfo.getId();
+        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper
+                .eq(DmpDeviceInfo::getDeviceId, dmpDeviceInfo.getDeviceId())
+                .eq(DmpDeviceInfo::getProductCode, dmpDeviceInfo.getProductCode())
+                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId());
+        DmpDeviceInfo one = this.getOne(queryWrapper);
+        return null != one && !Objects.equals(one.getId(), id);
+    }
+
+    @Override
+    public boolean checkNameUnique1(DmpDeviceInfo dmpDeviceInfo, Integer tenantId) {
+        Integer id = null == dmpDeviceInfo.getId() ? -1 : dmpDeviceInfo.getId();
+        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper
+                .eq(DmpDeviceInfo::getDeviceId, dmpDeviceInfo.getDeviceId())
+                .eq(DmpDeviceInfo::getProductCode, dmpDeviceInfo.getProductCode())
+                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                .eq(DmpDeviceInfo::getTenantId, tenantId);
+        DmpDeviceInfo one = this.getOne(queryWrapper);
+        return null != one && !Objects.equals(one.getId(), id);
+    }
+
+    @Override
+    public void deviceStatus(){
+//        log.info("定时同步设备状态和设备告警数据 start");
+//        ApiResult<List<StatusVO>> resultList = dataQueryClient.status();
+//        List<StatusVO> list = resultList.getData();
+//        if(CollectionUtils.isNotEmpty(list)){
+//            List<String> devList = new ArrayList<>();
+//            for(int i=0;i<list.size();i++){
+//                devList.add(list.get(i).getDeviceId());
+//            }
+//
+//            List<DmpDeviceInfo> devInfoList = new ArrayList<>();
+//            List<BaseAlarm> baseUnAlarmList = new ArrayList<>();
+////            List<BaseAlarm> baseAlarmList = new ArrayList<>();
+//            if(devList.size() > 0) {
+//                devInfoList = baseMapper.getDeviceInfoList(devList);
+//                baseUnAlarmList = baseMapper.getUnDeviceAlarmList(devList);
+////                baseAlarmList = baseMapper.getDeviceAlarmList(devList);
+//            }
+//
+//            if(CollectionUtils.isNotEmpty(devInfoList)){
+//                for(int i=0;i<list.size();i++){
+//                    String date =  list.get(i).getTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+//                    String currentDate = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+//                    LambdaUpdateWrapper<DmpDeviceStatus> updateWrapper = Wrappers.lambdaUpdate();
+//                    if(date.equals(currentDate)){
+//                        updateWrapper.set(DmpDeviceStatus::getDeviceStatus,1)  //设备在线
+//                                .set(DmpDeviceStatus::getLastOnlineTime,list.get(i).getTime())
+//                                .eq(DmpDeviceStatus::getDeviceId,list.get(i).getDeviceId())
+//                                .eq(DmpDeviceStatus::getProductCode,list.get(i).getProductCode());
+//                        //设备离线告警恢复在线自动默认处理
+//                        if(CollectionUtils.isNotEmpty(baseUnAlarmList)){
+//                            for(int j=0;j<baseUnAlarmList.size();j++){
+//                                if(list.get(i).getDeviceId().equals(baseUnAlarmList.get(j).getDeviceId()) && list.get(i).getProductCode().equals(baseUnAlarmList.get(j).getProductCode())){
+//                                    LambdaUpdateWrapper<BaseAlarm> updateWrapper1 = Wrappers.lambdaUpdate();
+//                                    updateWrapper1.set(BaseAlarm::getHandleStatus,1)
+//                                            .set(BaseAlarm::getHandleBy,"YT_admin")
+//                                            .set(BaseAlarm::getHandleTime,LocalDateTime.now())
+//                                            .eq(BaseAlarm::getDeviceId,list.get(i).getDeviceId())
+//                                            .eq(BaseAlarm::getHandleStatus,0)
+//                                            .eq(BaseAlarm::getProductCode,list.get(i).getProductCode());
+//                                    this.update(updateWrapper1);
+//                                    break;
+//                                }
+//                            }
+//                        }
+//
+//                    }else{
+//                        updateWrapper.set(DmpDeviceStatus::getDeviceStatus,2)  //设备离线
+//                                .set(DmpDeviceStatus::getLastOfflineTime,list.get(i).getTime())
+//                                .eq(DmpDeviceStatus::getDeviceId,list.get(i).getDeviceId())
+//                                .eq(DmpDeviceStatus::getProductCode,list.get(i).getProductCode());
+//
+//                        for(int j=0;j<devInfoList.size();j++){
+//                            if(list.get(i).getDeviceId().equals(devInfoList.get(j).getDeviceId()) && list.get(i).getProductCode().equals(devInfoList.get(j).getProductCode())){
+//                                int count = 0;
+//                                for(int k=0;k<baseUnAlarmList.size();k++){
+//                                    if(list.get(i).getDeviceId().equals(baseUnAlarmList.get(k).getDeviceId()) && list.get(i).getProductCode().equals(baseUnAlarmList.get(k).getProductCode())){
+//                                        count++;
+//                                    }
+//                                }
+//                                if(count == 0){
+//                                    BaseAlarm baseAlarm = new BaseAlarm();
+//                                    baseAlarm.setDeviceId(list.get(i).getDeviceId());
+//                                    baseAlarm.setAlarmTime(LocalDateTime.parse(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH"))+":00:00",DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+//                                    baseAlarm.setAlarmType("001");
+//                                    baseAlarm.setAlarmObject(devInfoList.get(j).getDeviceName());
+//                                    baseAlarm.setAlarmData("");
+//                                    baseAlarm.setAlarmAttribute("离线告警");
+//                                    baseAlarm.setAlarmContent("设备离线告警");
+//                                    baseAlarm.setAlarmGrade(1);
+//
+//                                    baseAlarm.setAlarmAddress(devInfoList.get(j).getInstallAddress());
+//                                    baseAlarm.setProductCode(devInfoList.get(j).getProductCode());
+//                                    this.add(baseAlarm);
+//                                }
+//                                break;
+//                            }
+//                        }
+//
+//                    }
+//                    dmpDeviceStatusService.update(updateWrapper);
+//                }
+//            }
+//
+//        }
+//        log.info("定时同步设备状态和设备告警数据 end");
+    }
+
+    @Override
+    public void updateDeviceStatus(LastInnerQueryVO queryVO){
+        List<LastInnerResultVO> list = remoteTsdbProxyService.last(queryVO);
+        if(CollectionUtils.isNotEmpty(list)){
+            for(int i=0;i<list.size();i++){
+                String deviceuuid = list.get(i).getDeviceuuid();
+                LocalDateTime lTime = Instant.ofEpochMilli(Long.valueOf(list.get(i).getMetrics().get("time").toString())).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
+                String date =  lTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+                String currentDate = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+                LambdaUpdateWrapper<DmpDeviceStatus> updateWrapper = Wrappers.lambdaUpdate();
+                if(date.equals(currentDate)){
+                    updateWrapper.set(DmpDeviceStatus::getDeviceStatus,1)  //设备在线
+                            .set(DmpDeviceStatus::getLastOnlineTime,lTime)
+                            .eq(DmpDeviceStatus::getDeviceUuid,deviceuuid);
+
+                }else{
+                    updateWrapper.set(DmpDeviceStatus::getDeviceStatus,2)  //设备离线
+                            .set(DmpDeviceStatus::getLastOnlineTime,lTime)
+                            .eq(DmpDeviceStatus::getDeviceUuid,deviceuuid);
+
+                }
+                dmpDeviceStatusService.update(updateWrapper);
+            }
+
+        }
+    }
+
+    @Override
+    public CommonPage<DmpDeviceInfo> page(DmpDeviceInfoRequest diRequest) {
+        List<DmpDeviceInfo> list = new ArrayList<>();
+        Integer total = 0;
+        Integer pageCurrent = diRequest.getCurrent();
+        Integer pageSize = diRequest.getSize();
+        IPage<DmpDeviceInfo> page = new Page<>(pageCurrent, pageSize);
+
+        if (diRequest.getDeviceStatus() != null) {
+            if (StringUtils.isNotBlank(diRequest.getDeviceId()) || StringUtils.isNotBlank(diRequest.getDeviceUuid()) || StringUtils.isNotBlank(diRequest.getDeviceName()) || diRequest.getProductId() != null || StringUtils.isNotBlank(diRequest.getProductCode()) || diRequest.getServiceStatus() != null) {
+                LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.eq(StringUtils.isNotBlank(diRequest.getDeviceId()), DmpDeviceInfo::getDeviceId, diRequest.getDeviceId())
+                        .eq(StringUtils.isNotBlank(diRequest.getDeviceUuid()), DmpDeviceInfo::getDeviceUuid, diRequest.getDeviceUuid())
+                        .like(StringUtils.isNotBlank(diRequest.getDeviceName()), DmpDeviceInfo::getDeviceName, diRequest.getDeviceName())
+                        .eq(diRequest.getProductId() != null, DmpDeviceInfo::getProductId, diRequest.getProductId())
+                        .like(StringUtils.isNotBlank(diRequest.getProductCode()), DmpDeviceInfo::getProductCode, diRequest.getProductCode())
+                        .eq(diRequest.getServiceStatus() != null, DmpDeviceInfo::getServiceStatus, diRequest.getServiceStatus())
+                        .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                        .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId())
+                        .orderByDesc(DmpDeviceInfo::getId);
+                List<DmpDeviceInfo> list1 = this.list(queryWrapper);
+
+                if (CollectionUtils.isNotEmpty(list1)) {
+                    List<String> devList = new ArrayList<>();
+                    List<Integer> productIdList = new ArrayList<>();
+                    for (int i = 0; i < list1.size(); i++) {
+                        if (!devList.contains(list1.get(i).getDeviceId())) {
+                            devList.add(list1.get(i).getDeviceId());
+                        }
+                        if (!productIdList.contains(list1.get(i).getProductId())) {
+                            productIdList.add(list1.get(i).getProductId());
+                        }
+                    }
+
+                    if (devList.size() > 0) {
+                        LambdaQueryWrapper<DmpDeviceStatus> queryWrapper1 = Wrappers.lambdaQuery();
+                        queryWrapper1.in(DmpDeviceStatus::getDeviceId, devList)
+                                .in(DmpDeviceStatus::getProductId, productIdList)
+                                .eq(DmpDeviceStatus::getDeviceStatus, diRequest.getDeviceStatus());
+                        List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper1);
+                        if (statusList.size() > 0) {
+                            for (int i = 0; i < list1.size(); i++) {
+                                for (int j = 0; j < statusList.size(); j++) {
+                                    if (list1.get(i).getProductId().equals(statusList.get(j).getProductId()) && list1.get(i).getDeviceId().equals(statusList.get(j).getDeviceId())) {
+                                        list1.get(i).setDeviceStatus(statusList.get(j).getDeviceStatus());
+                                        list1.get(i).setLastOnlineTime(statusList.get(j).getLastOnlineTime());
+                                        list1.get(i).setLastOfflineTime(statusList.get(j).getLastOfflineTime());
+                                        list.add(list1.get(i));
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                }
+
+                if (list.size() > 0) {
+                    total = list.size();
+                    page.setTotal(total);
+                }
+
+                Integer current = 0;
+                if (pageCurrent != null && pageSize > 0) {
+                    current = (pageCurrent - 1) * pageSize;
+                }
+
+                page.setRecords(list.stream().skip(current).limit(pageSize).collect(Collectors.toList()));
+            } else {
+                LambdaQueryWrapper<DmpDeviceStatus> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.eq(DmpDeviceStatus::getDeviceStatus, diRequest.getDeviceStatus());
+                List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper);
+                if (statusList.size() > 0) {
+                    List<String> devList = new ArrayList<>();
+                    List<Integer> productIdList = new ArrayList<>();
+                    for (int i = 0; i < statusList.size(); i++) {
+                        if (!devList.contains(statusList.get(i).getDeviceId())) {
+                            devList.add(statusList.get(i).getDeviceId());
+                        }
+                        if (!productIdList.contains(statusList.get(i).getProductId())) {
+                            productIdList.add(statusList.get(i).getProductId());
+                        }
+                    }
+
+                    if (devList.size() > 0) {
+                        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper1 = Wrappers.lambdaQuery();
+                        queryWrapper1.in(DmpDeviceInfo::getDeviceId, devList)
+                                .in(DmpDeviceInfo::getProductId, productIdList)
+                                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                                .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId())
+                                .orderByDesc(DmpDeviceInfo::getId);
+                        List<DmpDeviceInfo> list1 = this.list(queryWrapper1);
+                        if (list1.size() > 0) {
+                            for (int i = 0; i < list1.size(); i++) {
+                                for (int j = 0; j < statusList.size(); j++) {
+                                    if (list1.get(i).getProductId().equals(statusList.get(j).getProductId()) && list1.get(i).getDeviceId().equals(statusList.get(j).getDeviceId())) {
+                                        list1.get(i).setDeviceStatus(statusList.get(j).getDeviceStatus());
+                                        list1.get(i).setLastOnlineTime(statusList.get(j).getLastOnlineTime());
+                                        list1.get(i).setLastOfflineTime(statusList.get(j).getLastOfflineTime());
+                                        list.add(list1.get(i));
+                                        break;
+                                    }
+                                }
+                            }
+                            if (list.size() > 0) {
+                                total = list.size();
+                                page.setTotal(total);
+                            }
+
+                            Integer current = 0;
+                            if (pageCurrent != null && pageSize > 0) {
+                                current = (pageCurrent - 1) * pageSize;
+                            }
+
+                            page.setRecords(list.stream().skip(current).limit(pageSize).collect(Collectors.toList()));
+                        }
+                    }
+                }
+            }
+        } else {
+            LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+            queryWrapper.eq(StringUtils.isNotBlank(diRequest.getDeviceId()), DmpDeviceInfo::getDeviceId, diRequest.getDeviceId())
+                    .eq(StringUtils.isNotBlank(diRequest.getDeviceUuid()), DmpDeviceInfo::getDeviceUuid, diRequest.getDeviceUuid())
+                    .like(StringUtils.isNotBlank(diRequest.getDeviceName()), DmpDeviceInfo::getDeviceName, diRequest.getDeviceName())
+                    .eq(diRequest.getProductId() != null, DmpDeviceInfo::getProductId, diRequest.getProductId())
+                    .like(StringUtils.isNotBlank(diRequest.getProductCode()), DmpDeviceInfo::getProductCode, diRequest.getProductCode())
+                    .eq(diRequest.getServiceStatus() != null, DmpDeviceInfo::getServiceStatus, diRequest.getServiceStatus())
+                    .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                    .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId());
+
+            List<DmpDeviceInfo> allRecords = this.list(queryWrapper);
+
+            if (!allRecords.isEmpty()) {
+                List<String> devList = allRecords.stream().map(DmpDeviceInfo::getDeviceId).distinct().collect(Collectors.toList());
+                List<Integer> productIdList = allRecords.stream().map(DmpDeviceInfo::getProductId).distinct().collect(Collectors.toList());
+
+                LambdaQueryWrapper<DmpDeviceStatus> queryWrapper1 = Wrappers.lambdaQuery();
+                queryWrapper1.in(DmpDeviceStatus::getDeviceId, devList)
+                        .in(DmpDeviceStatus::getProductId, productIdList);
+
+                List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper1);
+
+                // 创建一个Map，用于快速查找设备状态
+                Map<String, DmpDeviceStatus> statusMap = new HashMap<>();
+                for (DmpDeviceStatus status : statusList) {
+                    statusMap.put(status.getDeviceId(), status);
+                }
+
+                // 重新排序设备信息，优先显示在线设备
+                allRecords.sort((d1, d2) -> {
+                    DmpDeviceStatus status1 = statusMap.get(d1.getDeviceId());
+                    DmpDeviceStatus status2 = statusMap.get(d2.getDeviceId());
+                    Integer deviceStatus1 = status1 != null ? status1.getDeviceStatus() : 2; // 默认离线
+                    Integer deviceStatus2 = status2 != null ? status2.getDeviceStatus() : 2; // 默认离线
+                    // 在线设备优先（1 < 2），如果状态相同，则按id降序
+                    return deviceStatus1.compareTo(deviceStatus2) != 0 ? deviceStatus1.compareTo(deviceStatus2) : d2.getId().compareTo(d1.getId());
+                });
+
+                // 填充设备状态信息
+                for (DmpDeviceInfo deviceInfo : allRecords) {
+                    DmpDeviceStatus status = statusMap.get(deviceInfo.getDeviceId());
+                    if (status != null) {
+                        deviceInfo.setDeviceStatus(status.getDeviceStatus()); // 填充设备状态
+                    } else {
+                        deviceInfo.setDeviceStatus(2); // 默认离线
+                    }
+                }
+            }
+
+            // 分页处理
+            int start = (pageCurrent - 1) * pageSize;
+            int end = Math.min(start + pageSize, allRecords.size());
+
+            // 确保 start 不超过 allRecords 的大小
+            if (start >= allRecords.size()) {
+                start = 0; // 如果 start 超出范围，重置为 0
+                end = Math.min(pageSize, allRecords.size()); // 重新计算 end
+            }
+
+            List<DmpDeviceInfo> pageRecords = allRecords.subList(start, end);
+            total = allRecords.size();
+
+            page.setRecords(pageRecords);
+            page.setTotal(total);
+        }
+
+
+        return new CommonPage<>(page.getRecords(), page.getTotal(), pageSize, pageCurrent);
+    }
+
+    @Override
+    public CommonPage<DmpDeviceInfo> pageWhite(DmpDeviceInfoRequest diRequest) {
+        List<DmpDeviceInfo> list = new ArrayList<>();
+        Integer total = 0;
+        Integer pageCurrent = diRequest.getCurrent();
+        Integer pageSize = diRequest.getSize();
+        IPage<DmpDeviceInfo> page = new Page<>(pageCurrent, pageSize);
+        Integer tenantId = 0;
+        String domain = diRequest.getDomain();
+        if (StringUtils.isNotBlank(domain)) {
+            tenantId = baseMapper.sysTenantId(domain);
+        }
+
+        if (diRequest.getDeviceStatus() != null) {
+            if (StringUtils.isNotBlank(diRequest.getDeviceId()) || StringUtils.isNotBlank(diRequest.getDeviceName()) || diRequest.getProductId() != null || StringUtils.isNotBlank(diRequest.getProductCode()) || diRequest.getServiceStatus() != null) {
+                LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.eq(StringUtils.isNotBlank(diRequest.getDeviceId()), DmpDeviceInfo::getDeviceId, diRequest.getDeviceId())
+                        .like(StringUtils.isNotBlank(diRequest.getDeviceName()), DmpDeviceInfo::getDeviceName, diRequest.getDeviceName())
+                        .eq(diRequest.getProductId() != null, DmpDeviceInfo::getProductId, diRequest.getProductId())
+                        .like(StringUtils.isNotBlank(diRequest.getProductCode()), DmpDeviceInfo::getProductCode, diRequest.getProductCode())
+                        .eq(diRequest.getServiceStatus() != null, DmpDeviceInfo::getServiceStatus, diRequest.getServiceStatus())
+                        .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                        .eq(DmpDeviceInfo::getTenantId, tenantId)
+                        .orderByDesc(DmpDeviceInfo::getId);
+                List<DmpDeviceInfo> list1 = this.list(queryWrapper);
+
+                if (CollectionUtils.isNotEmpty(list1)) {
+                    List<String> devList = new ArrayList<>();
+                    List<Integer> productIdList = new ArrayList<>();
+                    for (int i = 0; i < list1.size(); i++) {
+                        if (!devList.contains(list1.get(i).getDeviceId())) {
+                            devList.add(list1.get(i).getDeviceId());
+                        }
+                        if (!productIdList.contains(list1.get(i).getProductId())) {
+                            productIdList.add(list1.get(i).getProductId());
+                        }
+                    }
+
+                    if (devList.size() > 0) {
+                        LambdaQueryWrapper<DmpDeviceStatus> queryWrapper1 = Wrappers.lambdaQuery();
+                        queryWrapper1.in(DmpDeviceStatus::getDeviceId, devList)
+                                .in(DmpDeviceStatus::getProductId, productIdList)
+                                .eq(DmpDeviceStatus::getDeviceStatus, diRequest.getDeviceStatus());
+                        List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper1);
+                        if (statusList.size() > 0) {
+                            for (int i = 0; i < list1.size(); i++) {
+                                for (int j = 0; j < statusList.size(); j++) {
+                                    if (list1.get(i).getProductId().equals(statusList.get(j).getProductId()) && list1.get(i).getDeviceId().equals(statusList.get(j).getDeviceId())) {
+                                        list1.get(i).setDeviceStatus(statusList.get(j).getDeviceStatus());
+                                        list1.get(i).setLastOnlineTime(statusList.get(j).getLastOnlineTime());
+                                        list1.get(i).setLastOfflineTime(statusList.get(j).getLastOfflineTime());
+                                        list.add(list1.get(i));
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                }
+
+                if (list.size() > 0) {
+                    total = list.size();
+                    page.setTotal(total);
+                }
+
+                Integer current = 0;
+                if (pageCurrent != null && pageSize > 0) {
+                    current = (pageCurrent - 1) * pageSize;
+                }
+
+                page.setRecords(list.stream().skip(current).limit(pageSize).collect(Collectors.toList()));
+            } else {
+                LambdaQueryWrapper<DmpDeviceStatus> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.eq(DmpDeviceStatus::getDeviceStatus, diRequest.getDeviceStatus());
+                List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper);
+                if (statusList.size() > 0) {
+                    List<String> devList = new ArrayList<>();
+                    List<Integer> productIdList = new ArrayList<>();
+                    for (int i = 0; i < statusList.size(); i++) {
+                        if (!devList.contains(statusList.get(i).getDeviceId())) {
+                            devList.add(statusList.get(i).getDeviceId());
+                        }
+                        if (!productIdList.contains(statusList.get(i).getProductId())) {
+                            productIdList.add(statusList.get(i).getProductId());
+                        }
+                    }
+
+                    if (devList.size() > 0) {
+                        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper1 = Wrappers.lambdaQuery();
+                        queryWrapper1.in(DmpDeviceInfo::getDeviceId, devList)
+                                .in(DmpDeviceInfo::getProductId, productIdList)
+                                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                                .eq(DmpDeviceInfo::getTenantId, tenantId)
+                                .orderByDesc(DmpDeviceInfo::getId);
+                        List<DmpDeviceInfo> list1 = this.list(queryWrapper1);
+                        if (list1.size() > 0) {
+                            for (int i = 0; i < list1.size(); i++) {
+                                for (int j = 0; j < statusList.size(); j++) {
+                                    if (list1.get(i).getProductId().equals(statusList.get(j).getProductId()) && list1.get(i).getDeviceId().equals(statusList.get(j).getDeviceId())) {
+                                        list1.get(i).setDeviceStatus(statusList.get(j).getDeviceStatus());
+                                        list1.get(i).setLastOnlineTime(statusList.get(j).getLastOnlineTime());
+                                        list1.get(i).setLastOfflineTime(statusList.get(j).getLastOfflineTime());
+                                        list.add(list1.get(i));
+                                        break;
+                                    }
+                                }
+                            }
+                            if (list.size() > 0) {
+                                total = list.size();
+                                page.setTotal(total);
+                            }
+
+                            Integer current = 0;
+                            if (pageCurrent != null && pageSize > 0) {
+                                current = (pageCurrent - 1) * pageSize;
+                            }
+
+                            page.setRecords(list.stream().skip(current).limit(pageSize).collect(Collectors.toList()));
+                        }
+                    }
+                }
+            }
+        } else {
+            LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+            queryWrapper.eq(StringUtils.isNotBlank(diRequest.getDeviceId()), DmpDeviceInfo::getDeviceId, diRequest.getDeviceId())
+                    .like(StringUtils.isNotBlank(diRequest.getDeviceName()), DmpDeviceInfo::getDeviceName, diRequest.getDeviceName())
+                    .eq(diRequest.getProductId() != null, DmpDeviceInfo::getProductId, diRequest.getProductId())
+                    .like(StringUtils.isNotBlank(diRequest.getProductCode()), DmpDeviceInfo::getProductCode, diRequest.getProductCode())
+                    .eq(diRequest.getServiceStatus() != null, DmpDeviceInfo::getServiceStatus, diRequest.getServiceStatus())
+                    .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                    .eq(DmpDeviceInfo::getTenantId, tenantId)
+                    .orderByDesc(DmpDeviceInfo::getId);
+            page = this.page(page, queryWrapper);
+            if (page.getTotal() > 0) {
+                List<String> devList = new ArrayList<>();
+                List<Integer> productIdList = new ArrayList<>();
+                for (int i = 0; i < page.getRecords().size(); i++) {
+                    if (!devList.contains(page.getRecords().get(i).getDeviceId())) {
+                        devList.add(page.getRecords().get(i).getDeviceId());
+                    }
+                    if (!productIdList.contains(page.getRecords().get(i).getProductId())) {
+                        productIdList.add(page.getRecords().get(i).getProductId());
+                    }
+                }
+
+                if (devList.size() > 0) {
+                    LambdaQueryWrapper<DmpDeviceStatus> queryWrapper1 = Wrappers.lambdaQuery();
+                    queryWrapper1.in(DmpDeviceStatus::getDeviceId, devList)
+                            .in(DmpDeviceStatus::getProductId, productIdList);
+                    List<DmpDeviceStatus> statusList = dmpDeviceStatusService.list(queryWrapper1);
+                    if (statusList.size() > 0) {
+                        for (int i = 0; i < page.getRecords().size(); i++) {
+                            for (int j = 0; j < statusList.size(); j++) {
+                                if (page.getRecords().get(i).getProductId().equals(statusList.get(j).getProductId()) && page.getRecords().get(i).getDeviceId().equals(statusList.get(j).getDeviceId())) {
+                                    page.getRecords().get(i).setDeviceStatus(statusList.get(j).getDeviceStatus());
+                                    page.getRecords().get(i).setLastOnlineTime(statusList.get(j).getLastOnlineTime());
+                                    page.getRecords().get(i).setLastOfflineTime(statusList.get(j).getLastOfflineTime());
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+
+        return new CommonPage<>(page.getRecords(), page.getTotal(), pageSize, pageCurrent);
+    }
+
+    @Override
+    public boolean remove(Integer id) {
+        DmpDeviceInfo dmpDeviceInfo = this.getById(id);
+        Optional.ofNullable(dmpDeviceInfo).orElseThrow(() -> new BusinessException("设备不存在"));
+
+        // 已关联设施的不能删除
+        LambdaQueryWrapper<BaseFacilityDevice> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.eq(BaseFacilityDevice::getDeviceId, dmpDeviceInfo.getDeviceId());
+        int count = baseFacilityDeviceService.count(queryWrapper);
+        if (count > 0) {
+            throw new BusinessException("已关联设施的不能删除");
+        }
+
+        dmpDeviceInfo.setDeleteFlag(1);
+        return this.updateById(dmpDeviceInfo);
+    }
+
+    @Override
+    public List<Map<String, Object>> deviceCollect(List<Integer> productIds) {
+        QueryWrapper<DmpDeviceInfo> query = Wrappers.query();
+        query.select("product_id as productId", "count(*) as count", "count(service_status != 1 or null) as serviceCount")
+                .in(CollectionUtil.isNotEmpty(productIds), "product_id", productIds)
+                .eq("delete_flag", 0)
+                .eq("tenant_id", SecurityUtils.getTenantId())
+                .groupBy("product_id");
+        return this.listMaps(query);
+    }
+
+    @Override
+    public int deviceCountByProductId(Integer productId) {
+        LambdaQueryWrapper<DmpDeviceInfo> lambdaQuery = Wrappers.lambdaQuery();
+        lambdaQuery.eq(DmpDeviceInfo::getProductId, productId)
+                .eq(DmpDeviceInfo::getDeleteFlag, 0);
+        return this.count(lambdaQuery);
+    }
+
+    @Override
+    public void addByFile(MultipartFile multipartFiles) {
+        ImportParams params = new ImportParams();
+        params.setHeadRows(1);
+        params.setTitleRows(1);
+        String err = "文件导入失败";
+        try {
+            List<DeviceImportVo> deviceImportVos = ExcelImportUtil.importExcel(multipartFiles.getInputStream(),
+                    DeviceImportVo.class, params);
+            if (CollectionUtils.isNotEmpty(deviceImportVos)) {
+                int rot = 0;
+                for (DeviceImportVo deviceImportVo : deviceImportVos) {
+                    DmpDeviceInfo dmpDeviceInfo = BeanMapperUtils.map(deviceImportVo, DmpDeviceInfo.class);
+                    if (StringUtils.isBlank(dmpDeviceInfo.getDeviceId()) || StringUtils.isBlank(dmpDeviceInfo.getProductCode()) || StringUtils.isBlank(dmpDeviceInfo.getDeviceName()) || StringUtils.isBlank(dmpDeviceInfo.getInstallAddress())) {
+                        int h = rot + 3;
+                        err = "文件导入失败，第" + h + "行数据导入失败,必填字段不能为空";
+                        throw new BusinessException(err);
+                    }
+                    try {
+                        this.add(dmpDeviceInfo);
+                    } catch (Exception e) {
+                        int h = rot + 3;
+                        err = "文件导入失败，第" + h + "行数据导入失败";
+                        throw new BusinessException(err);
+                    }
+                    rot++;
+                }
+            } else {
+                err = "文件不能为空";
+                throw new BusinessException(err);
+            }
+        } catch (Exception e) {
+            throw new BusinessException(err);
+        }
+    }
+
+    @Override
+    public void importDeviceInfo(List<DmpDeviceInfo> devList) {
+        List<DmpDeviceStatus> dmpDeviceStatusList = new ArrayList<>();
+        if (CollectionUtils.isEmpty(devList)) {
+            throw new BusinessException("数据不能为空");
+        }
+        for (int i = 0; i < devList.size(); i++) {
+            List<DmpProductInfo> list = baseMapper.getProductInfo(devList.get(i).getProductCode());
+            if (CollectionUtils.isNotEmpty(list)) {
+
+                if (checkNameUnique1(devList.get(i), list.get(0).getTenantId())) {
+                    throw new BusinessException("新增设备信息'" + devList.get(i).getDeviceId() + "'失败，设备信息已存在");
+                }
+
+                devList.get(i).setDeviceType(list.get(0).getDeviceType());
+                devList.get(i).setProductId(list.get(0).getId());
+                devList.get(i).setCreatedBy(SecurityUtils.getUsername());
+                devList.get(i).setCreatedTime(LocalDateTime.now());
+                devList.get(i).setTenantId(list.get(0).getTenantId());
+                devList.get(i).setServiceStatus(1);
+                devList.get(i).setDeviceUuid(UUIDUtils.uuid());
+
+                DmpDeviceStatus dmpDeviceStatus = new DmpDeviceStatus();
+                dmpDeviceStatus.setDeviceId(devList.get(i).getDeviceId());
+                dmpDeviceStatus.setProductId(devList.get(i).getProductId());
+                dmpDeviceStatus.setDeviceStatus(2);
+                dmpDeviceStatus.setLastOfflineTime(LocalDateTime.now());
+                dmpDeviceStatus.setProductCode(devList.get(i).getProductCode());
+                dmpDeviceStatus.setDeviceUuid(devList.get(i).getDeviceUuid());
+                dmpDeviceStatusList.add(dmpDeviceStatus);
+            } else {
+                throw new BusinessException("新增设备信息'" + devList.get(i).getDeviceId() + "'失败，无对应产品信息");
+            }
+        }
+        this.saveBatch(devList);
+        dmpDeviceStatusService.saveBatch(dmpDeviceStatusList);
+    }
+
+    @Override
+    public void export(DmpDeviceInfoRequest dmpDeviceInfoRequest, HttpServletResponse response) {
+        Workbook workbook = null;
+        try {
+            ExportParams params = new ExportParams(null, "设备列表");
+            workbook = ExcelExportUtil.exportBigExcel(params, DmpDeviceExcelVO.class,
+                    (o, i) -> {
+                        dmpDeviceInfoRequest.setCurrent(i);
+                        dmpDeviceInfoRequest.setSize(30);
+                        CommonPage<DmpDeviceInfo> list = this.page(dmpDeviceInfoRequest);
+                        return new ArrayList<>(BeanMapperUtils.mapList(list.getRecords(), DmpDeviceInfo.class, DmpDeviceExcelVO.class));
+                    }, null);
+            if (null != workbook) {
+                exportExcel(workbook, response);
+            } else {
+                throw new BusinessException("表格数据为空");
+            }
+        } catch (Exception e) {
+            log.error("导出文件失败", e);
+            throw new BusinessException("导出文件失败" + e.getMessage());
+        } finally {
+            if (workbook != null) {
+                try {
+                    workbook.close();
+                } catch (IOException e) {
+                    log.error("===export spec=== 关闭workbook失败", e);
+                }
+            }
+        }
+    }
+
+    public void exportExcel(Workbook workbook, HttpServletResponse response) {
+        // 定义一个流，用作流式输出
+        ServletOutputStream outputStream = null;
+        try {
+            // 使用流的形式传输
+            response.setContentType("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+            // 防止中文乱码
+            response.setCharacterEncoding("utf-8");
+            outputStream = response.getOutputStream();
+            workbook.write(outputStream);
+        } catch (IOException e) {
+            e.printStackTrace();
+        } finally {
+            if (null != outputStream) {
+                try {
+                    // 关闭流
+                    outputStream.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
+
+    /**
+     * 获取表格数据
+     * @param multipartFile
+     * @return
+     */
+    public List<DmpDeviceInfo> getDeviceByFile(Integer productId, MultipartFile multipartFile) {
+        ImportParams importParams = new ImportParams();
+        importParams.setHeadRows(1);
+        try {
+            List<DmpDeviceExportVO> dmpDeviceExportVOS = ExcelImportUtil.importExcel(
+                    multipartFile.getInputStream(),
+                    DmpDeviceExportVO.class,
+                    importParams
+            );
+            if (CollectionUtils.isEmpty(dmpDeviceExportVOS)) {
+                throw new BusinessException("表格数据为空");
+            }
+            List<DmpDeviceInfo> deviceInfos = BeanMapperUtils.mapList(dmpDeviceExportVOS, DmpDeviceExportVO.class, DmpDeviceInfo.class);
+            long count = deviceInfos.stream()
+                    .peek(device -> {
+                        device.setProductId(productId);
+                        device.setDeviceId(UUIDUtils.uuid());
+                    })
+                    .filter(device -> StringUtils.isBlank(device.getDeviceName()) ||
+                            StringUtils.isBlank(device.getDeviceName())
+                            || StringUtils.isBlank(device.getSimCode())
+                            || null == device.getSubscribeFlag()
+                    ).count();
+            long count1 = deviceInfos.stream()
+                    .collect(Collectors.toMap(DmpDeviceInfo::getDeviceName, s -> 1, Integer::sum))
+                    .entrySet()
+                    .stream()
+                    .filter(entry -> entry.getValue() > 1)
+                    .count();
+            if (count > 0) {
+                throw new BusinessException("表格字段不能为空");
+            }
+            if (count1 > 0) {
+                throw new BusinessException("设备名称不能重复");
+            }
+            return deviceInfos;
+        } catch (Exception e) {
+            throw new BusinessException("解析表格异常,检查表格格式" + e.getMessage());
+        }
+    }
+
+    @Override
+    public CommonPage<Object> deviceCurrentDataList(String deviceName, String installAddress, String productCode, Integer pageNum, Integer pageSize) {
+        List<Object> list = new ArrayList<>();
+
+        List<DmpDeviceInfo> devList = new ArrayList<>();
+        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.eq(DmpDeviceInfo::getDeleteFlag, 0)
+                .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId())
+                .like(StringUtils.isNotBlank(deviceName), DmpDeviceInfo::getDeviceName, deviceName)
+                .like(StringUtils.isNotBlank(installAddress), DmpDeviceInfo::getInstallAddress, installAddress)
+                .eq(DmpDeviceInfo::getProductCode, productCode)
+                .orderByAsc(DmpDeviceInfo::getId);
+        devList = this.list(queryWrapper);
+        if (devList.size() <= 0) {
+            return new CommonPage<>(list, 0, pageNum, pageSize);
+        }
+
+        if (devList.size() > 0) {
+            List<String> deviceList = new ArrayList<>();
+            for (int k = 0; k < devList.size(); k++) {
+                deviceList.add(devList.get(k).getDeviceId());
+            }
+
+            if (deviceList.size() > 0) {
+                List<DataRealTimeResponseVO> dataRealList = deviceDataClient.data(productCode, deviceList);
+                if (dataRealList.size() > 0) {
+                    for (int i = 0; i < devList.size(); i++) {
+                        Map<String, Object> map = new HashMap<>();
+                        map.put("deviceId", devList.get(i).getDeviceId());
+                        map.put("deviceName", devList.get(i).getDeviceName());
+                        map.put("installAddress", devList.get(i).getInstallAddress());
+                        map.put("latestTime", LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+
+                        for (int j = 0; j < dataRealList.size(); j++) {
+                            if (devList.get(i).getProductCode().equals(dataRealList.get(j).getProductCode()) && devList.get(i).getDeviceId().equals(dataRealList.get(j).getDeviceId())) {
+                                map.put(dataRealList.get(j).getAttributeName(), dataRealList.get(j).getAttributeData());
+                                map.put(dataRealList.get(j).getAttributeName() + "Time", dataRealList.get(j).getDataTime());
+                            }
+
+                        }
+                        list.add(map);
+
+                    }
+                }
+
+            }
+        }
+
+        List<Object> objectList = new ArrayList<>();
+        int total = 0;
+        if (list.size() > 0) {
+            total = list.size();
+        }
+        int current = 0;
+        if (pageNum != 0 && pageSize > 0) {
+            current = (pageNum - 1) * pageSize;
+        }
+
+        objectList = list.stream().skip(current).limit(pageSize).collect(Collectors.toList());
+
+
+        return new CommonPage<>(objectList, total, pageNum, pageSize);
+    }
+
+    @Override
+    public CommonPage<DataTVResponseVO> dataTVList(DataTVRequestVO requestVO) {
+        List<DataTVResponseVO> list = new ArrayList<>();
+
+        IPage<DmpDeviceInfo> page = new Page<>(requestVO.getCurrent(), requestVO.getSize());
+        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.select(DmpDeviceInfo::getProductId, DmpDeviceInfo::getDeviceId, DmpDeviceInfo::getDeviceName, DmpDeviceInfo::getDeviceType, DmpDeviceInfo::getInstallAddress)
+                .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId())
+                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                .eq(requestVO.getDeviceType() != null, DmpDeviceInfo::getDeviceType, requestVO.getDeviceType())
+                .eq(StringUtils.isNotBlank(requestVO.getDeviceId()), DmpDeviceInfo::getDeviceId, requestVO.getDeviceId())
+                .orderByDesc(DmpDeviceInfo::getId);
+        page = this.page(page, queryWrapper);
+        if (page.getSize() <= 0) {
+            return new CommonPage<>(list, 0, requestVO.getSize(), requestVO.getCurrent());
+        }
+
+        if (page.getRecords().size() > 0) {
+            List<String> deviceIdList = new ArrayList<>();
+            List<Integer> productIdList = new ArrayList<>();
+            for (int i = 0; i < page.getRecords().size(); i++) {
+                deviceIdList.add(page.getRecords().get(i).getDeviceId());
+                if (!productIdList.contains(page.getRecords().get(i).getProductId())) {
+                    productIdList.add(page.getRecords().get(i).getProductId());
+                }
+            }
+
+            List<ProductTVAttributeVO> attributeVOList = baseMapper.attributeList(productIdList);
+
+            if (deviceIdList.size() > 0) {
+                LambdaQueryWrapper<DmpDeviceStatus> queryWrapper1 = Wrappers.lambdaQuery();
+                queryWrapper1.in(DmpDeviceStatus::getDeviceId, deviceIdList);
+                List<DmpDeviceStatus> deviceStatusList = dmpDeviceStatusService.list(queryWrapper1);
+
+                List<BaseAlarm> baseAlarmList = baseMapper.baseAlarmList(deviceIdList);
+
+                List<DataRealTimeResponseVO> dataRealList = deviceDataClient.data(null, deviceIdList);
+                for (int i = 0; i < page.getRecords().size(); i++) {
+                    DataTVResponseVO dataTVResponseVO = new DataTVResponseVO();
+                    dataTVResponseVO.setDeviceId(page.getRecords().get(i).getDeviceId());
+                    dataTVResponseVO.setDeviceName(page.getRecords().get(i).getDeviceName());
+                    dataTVResponseVO.setDeviceType(page.getRecords().get(i).getDeviceType());
+                    dataTVResponseVO.setInstallAddress(page.getRecords().get(i).getInstallAddress());
+                    if (CollectionUtils.isNotEmpty(deviceStatusList)) {
+                        for (int j = 0; j < deviceStatusList.size(); j++) {
+                            if (page.getRecords().get(i).getDeviceId().equals(deviceStatusList.get(j).getDeviceId())) {
+                                dataTVResponseVO.setDeviceStatus(deviceStatusList.get(j).getDeviceStatus());
+                            }
+                        }
+                    }
+
+                    if (CollectionUtils.isNotEmpty(baseAlarmList)) {
+                        for (int j = 0; j < baseAlarmList.size(); j++) {
+                            if (page.getRecords().get(i).getDeviceId().equals(baseAlarmList.get(j).getDeviceId())) {
+                                List<BaseAlarmVO> list1 = new ArrayList<>();
+                                if (baseAlarmList.get(j).getAlarmType().equals("815")) {
+                                    dataTVResponseVO.setAlarmStatus(2);
+                                } else {
+                                    dataTVResponseVO.setAlarmStatus(1);
+                                }
+                                BaseAlarmVO baseAlarmVO = new BaseAlarmVO();
+                                baseAlarmVO.setAlarmContent(baseAlarmList.get(j).getAlarmContent());
+                                baseAlarmVO.setAlarmTime((baseAlarmList.get(j).getAlarmTime()).format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
+                                list1.add(baseAlarmVO);
+                                dataTVResponseVO.setAlarmList(list1);
+                            }
+                        }
+                    }
+
+                    List<DeviceAttributeVO> list1 = new ArrayList<>();
+                    if (dataRealList.size() > 0) {
+                        for (int j = 0; j < dataRealList.size(); j++) {
+                            if (page.getRecords().get(i).getDeviceId().equals(dataRealList.get(j).getDeviceId())) {
+                                DeviceAttributeVO attributeVO = new DeviceAttributeVO();
+                                attributeVO.setCode(dataRealList.get(j).getAttributeName());
+                                attributeVO.setValue(dataRealList.get(j).getAttributeData());
+                                attributeVO.setTime("" + dataRealList.get(j).getDataTime());
+                                if ((attributeVOList.size() > 0)) {
+                                    for (int k = 0; k < attributeVOList.size(); k++) {
+                                        if ((dataRealList.get(j).getProductCode().equals(attributeVOList.get(k).getProductCode())) && (dataRealList.get(j).getAttributeName().equals(attributeVOList.get(k).getAttributeCode()))) {
+                                            if (Objects.nonNull(attributeVOList.get(k).getAttributeName())) {
+                                                attributeVO.setName(attributeVOList.get(k).getAttributeName());
+                                            }
+                                            if (Objects.nonNull(attributeVOList.get(k).getAttributeUnit())) {
+                                                attributeVO.setUnit(attributeVOList.get(k).getAttributeUnit());
+                                            }
+                                            if (Objects.nonNull(attributeVOList.get(k).getMaximum())) {
+                                                attributeVO.setMaximum(Math.round(attributeVOList.get(k).getMaximum() * 100) / 100f);
+                                            }
+                                            if (Objects.nonNull(attributeVOList.get(k).getMinimum())) {
+                                                attributeVO.setMinimum(Math.round(attributeVOList.get(k).getMinimum() * 100) / 100f);
+                                            }
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                list1.add(attributeVO);
+                            }
+                        }
+                    }
+                    dataTVResponseVO.setDp(list1);
+                    list.add(dataTVResponseVO);
+                }
+
+
+            }
+        }
+
+
+        return new CommonPage<>(list, page.getTotal(), page.getSize(), page.getCurrent());
+    }
+
+    @Override
+    public List<DataTVStatisticResponseVO> dataTVStatistic(DataTVRequestVO requestVO) {
+        List<DataTVStatisticResponseVO> list = new ArrayList<>();
+        LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+        queryWrapper.select(DmpDeviceInfo::getProductId, DmpDeviceInfo::getDeviceId, DmpDeviceInfo::getDeviceName, DmpDeviceInfo::getDeviceType, DmpDeviceInfo::getInstallAddress)
+                .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId())
+                .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                .eq(requestVO.getDeviceType() != null, DmpDeviceInfo::getDeviceType, requestVO.getDeviceType())
+                .orderByDesc(DmpDeviceInfo::getId);
+        List<DmpDeviceInfo> list1 = this.list(queryWrapper);
+        if (CollectionUtils.isNotEmpty(list1)) {
+            List<String> deviceIdList = new ArrayList<>();
+            for (int i = 0; i < list1.size(); i++) {
+                deviceIdList.add(list1.get(i).getDeviceId());
+            }
+            Integer alarmCount = baseMapper.baseAlarmCount(deviceIdList);
+            Integer faultCount = baseMapper.baseFaultCount(deviceIdList);
+            Integer offlineCount = baseMapper.deviceOfflineCount(deviceIdList);
+            DataTVStatisticResponseVO responseVO = new DataTVStatisticResponseVO();
+            responseVO.setAlarmNum(alarmCount);
+            responseVO.setFaultNum(faultCount);
+            responseVO.setOfflineNum(offlineCount);
+            list.add(responseVO);
+        }
+
+        return list;
+    }
+
+    @Override
+    public List<Map<String, Object>> deviceDataTotal(DataTotalRequestVO requestVO) {
+        List<Map<String, Object>> list = dataQueryClient.deviceDataTotal(requestVO);
+
+        return list;
+    }
+
+    @Override
+    public List<DataAverageResponseVO> deviceDataAverage(DataAverageRequestVO requestVO) {
+        List<DataAverageResponseVO> list = dataQueryClient.deviceDataAverage(requestVO);
+
+        if (requestVO.getGroupType().equals("Each")) {
+            if (list.size() > 0) {
+                List<String> deviceIdList = new ArrayList<>();
+                for (int i = 0; i < list.size(); i++) {
+                    deviceIdList.add(list.get(i).getDeviceId());
+                }
+                LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.in(DmpDeviceInfo::getDeviceId, deviceIdList)
+                        .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                        .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId());
+                List<DmpDeviceInfo> deviceInfoList = this.list(queryWrapper);
+                if (CollectionUtils.isNotEmpty(deviceIdList)) {
+                    for (int i = 0; i < list.size(); i++) {
+                        for (int j = 0; j < deviceInfoList.size(); j++) {
+                            if (list.get(i).getDeviceId().equals(deviceInfoList.get(j).getDeviceId())) {
+                                list.get(i).setDeviceName(deviceInfoList.get(j).getDeviceName());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return list;
+    }
+
+    @Override
+    public List<DataAverageExportVO> DataAverageExport(DataAverageRequestVO requestVO) {
+        List<DataAverageExportVO> list = dataQueryClient.DataAverageExport(requestVO);
+
+        if (requestVO.getGroupType().equals("Each")) {
+            if (list.size() > 0) {
+                List<String> deviceIdList = new ArrayList<>();
+                for (int i = 0; i < list.size(); i++) {
+                    deviceIdList.add(list.get(i).getDeviceName());
+                }
+                LambdaQueryWrapper<DmpDeviceInfo> queryWrapper = Wrappers.lambdaQuery();
+                queryWrapper.in(DmpDeviceInfo::getDeviceId, deviceIdList)
+                        .eq(DmpDeviceInfo::getDeleteFlag, 0)
+                        .eq(DmpDeviceInfo::getTenantId, SecurityUtils.getTenantId());
+                List<DmpDeviceInfo> deviceInfoList = this.list(queryWrapper);
+                if (CollectionUtils.isNotEmpty(deviceIdList)) {
+                    for (int i = 0; i < list.size(); i++) {
+                        for (int j = 0; j < deviceInfoList.size(); j++) {
+                            if (list.get(i).getDeviceName().equals(deviceInfoList.get(j).getDeviceId())) {
+                                list.get(i).setDeviceName(deviceInfoList.get(j).getDeviceName());
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return list;
+    }
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/vo/alarm/AlarmMessage1VO.java

@@ -0,0 +1,74 @@
+package com.usky.cdi.service.vo.alarm;
+
+import lombok.Data;
+
+@Data
+public class AlarmMessageVO {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 数据包ID
+     */
+    private Long dataPacketID;
+
+    /**
+     * 人防工程ID
+     */
+    private Long engineeringID;
+
+    /**
+     * 事件ID
+     */
+    private Integer alarmID;
+
+    /**
+     * 事件来源
+     */
+    private Integer alarmSource;
+
+    /**
+     * 物联设施ID
+     */
+    private Integer sensorID;
+
+    /**
+     * 事件类型
+     */
+    private String alarmType;
+
+    /**
+     * 事件状态
+     */
+    private Integer alarmStatus;
+
+    /**
+     * 最新水浸状态
+     */
+    private String sensorValue;
+
+    /**
+     * 告警阈值
+     */
+    private Double thresholding;
+
+    /**
+     * 事件发生/更新时间
+     */
+    private String alarmUpdateTime;
+
+    /**
+     * 监测对象编号
+     */
+    private String monitorObjNo;
+
+    /**
+     * 事件描述
+     */
+    private String alarmDesc;
+
+    /**
+     * 上报时间
+     */
+    private String publishTime;
+
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/vo/alarm/AlarmMessageVO.java

@@ -0,0 +1,2 @@
+package com.usky.cdi.service.vo.alarm;public class AlarmMessageVO {
+}

service-cdi/service-cdi-biz/src/main/java/com/usky/cdi/service/vo/base/FacilityDeviceVO.java

@@ -0,0 +1,67 @@
+package com.usky.cdi.service.vo.base;
+
+import lombok.Data;
+import java.io.Serializable;
+
+/**
+ * 楼层平面图信息VO
+ * Topic: base/floorPlane
+ * 
+ * @author han
+ * @date 2025/03/20
+ */
+@Data
+public class FloorPlaneVO implements Serializable {
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * 数据包ID
+     */
+    private Long dataPacketID;
+
+    /**
+     * 人防工程ID
+     */
+    private Long engineeringID;
+
+    /**
+     * 楼层
+     */
+    private String floor;
+
+    /**
+     * 楼层平面图文件ID
+     */
+    private Long floorFileID;
+
+    /**
+     * 楼层平面图文件中文名称
+     */
+    private String floorFileName;
+
+    /**
+     * 楼层平面图文件后缀
+     */
+    private String floorFileSuffix;
+
+    /**
+     * 楼层平面图图片像素宽度
+     */
+    private Integer filePixWidth;
+
+    /**
+     * 楼层平面图图片像素高度
+     */
+    private Integer filePixHeight;
+
+    /**
+     * 平面图文件（二进制字节数组）
+     */
+    private byte[] floorFile;
+
+    /**
+     * 上报时间
+     */
+    private String publishTime;
+}
+

service-cdi/service-cdi-biz/src/main/resources/mapper/cdi/BaseBuildFacilityMapper.xml

@@ -0,0 +1,38 @@
+<?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="com.usky.cdi.mapper.BaseBuildFacilityMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.usky.cdi.domain.BaseBuildFacility">
+        <id column="id" property="id" />
+        <result column="facility_num" property="facilityNum" />
+        <result column="facility_name" property="facilityName" />
+        <result column="facility_type" property="facilityType" />
+        <result column="floor" property="floor" />
+        <result column="address" property="address" />
+        <result column="images_url" property="imagesUrl" />
+        <result column="device_id" property="deviceId" />
+        <result column="contact" property="contact" />
+        <result column="contact_phone" property="contactPhone" />
+        <result column="plane_x" property="planeX" />
+        <result column="plane_y" property="planeY" />
+        <result column="coordinate_x" property="coordinateX" />
+        <result column="coordinate_y" property="coordinateY" />
+        <result column="coordinate_z" property="coordinateZ" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="create_time" property="createTime" />
+        <result column="update_time" property="updateTime" />
+        <result column="update_by" property="updateBy" />
+        <result column="create_by" property="createBy" />
+        <result column="dept_id" property="deptId" />
+        <result column="tenant_id" property="tenantId" />
+        <result column="facility_desc" property="facilityDesc" />
+        <result column="angles_x" property="anglesX" />
+        <result column="angles_y" property="anglesY" />
+        <result column="angles_z" property="anglesZ" />
+        <result column="scale_l" property="scaleL" />
+        <result column="scale_w" property="scaleW" />
+        <result column="scale_h" property="scaleH" />
+    </resultMap>
+
+</mapper>

service-cdi/service-cdi-biz/src/main/resources/mapper/cdi/DmpDeviceMapper.xml

@@ -0,0 +1,30 @@
+<?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="com.usky.alarm.mapper.DmpDeviceMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.usky.cdi.domain.DmpDevice">
+        <id column="id" property="id" />
+        <result column="device_id" property="deviceId" />
+        <result column="device_name" property="deviceName" />
+        <result column="device_type" property="deviceType" />
+        <result column="product_id" property="productId" />
+        <result column="sim_code" property="simCode" />
+        <result column="imsi_code" property="imsiCode" />
+        <result column="subscribe_flag" property="subscribeFlag" />
+        <result column="node_type" property="nodeType" />
+        <result column="group_id" property="groupId" />
+        <result column="delete_flag" property="deleteFlag" />
+        <result column="created_by" property="createdBy" />
+        <result column="created_time" property="createdTime" />
+        <result column="updated_by" property="updatedBy" />
+        <result column="updated_time" property="updatedTime" />
+        <result column="tenant_id" property="tenantId" />
+        <result column="company_code" property="companyCode" />
+        <result column="install_address" property="installAddress" />
+        <result column="service_status" property="serviceStatus" />
+        <result column="product_code" property="productCode" />
+        <result column="device_uuid" property="deviceUuid" />
+    </resultMap>
+
+</mapper>