三环朝晖数据拉取上报

@@ -35,6 +35,55 @@
             <artifactId>spring-boot-starter-test</artifactId>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP</artifactId>
+            <version>4.0.3</version>
+        </dependency>
+        <dependency>
+            <groupId>com.zaxxer</groupId>
+            <artifactId>HikariCP-java7</artifactId>
+            <version>2.4.13</version>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>42.7.3</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>4.5.8</version>
+        </dependency>
+        <!--工具类-->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.6</version>
+        </dependency>
+
+        <!--工具类-->
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-collections4</artifactId>
+            <version>4.2</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.2.60</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <version>2.0.9.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>redis.clients</groupId>
+            <artifactId>jedis</artifactId>
+            <version>2.9.0</version>
+        </dependency>
     </dependencies>
 
     <build>

 package com.iot.scheduler.controller;
 
+import com.iot.scheduler.service.HnDeviceReportService;
+import com.iot.scheduler.service.ShDevicePullService;
+import jakarta.annotation.Resource;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
 public class HealthController {
 
+    @Resource
+    private HnDeviceReportService hnDeviceReportService;
+    @Resource
+    private ShDevicePullService shDevicePullService;
+
     @GetMapping("/health")
     public String health() {
         return "IoT Scheduler is running...";
     }
+
+    @GetMapping("/manualSynchronization")
+    public void manualSynchronization() {
+        hnDeviceReportService.deviceReport();
+    }
+
+    @GetMapping("/pullSynchronization")
+    public void pullSynchronization() {
+        shDevicePullService.pullDeviceAndPushToIot();
+    }
+
 }

+package com.iot.scheduler.model;
+
+import lombok.Data;
+
+/**
+ * IOT平台token
+ */
+@Data
+public class DeviceToken {
+    //设备凭证类型
+    private String credentialsType;
+    //设备凭证id
+    private String credentialsId;
+    //凭证值
+    private String credentialsValue;
+
+}

+package com.iot.scheduler.model;
+
+import lombok.Data;
+
+/**
+ * IOT平台:设备实体
+ */
+@Data
+public class QxDeviceInfo {
+    //设备厂商（必填）
+    private String brand;
+
+    //别名（选填）
+    private String alias;
+
+    //名称（必填）
+    private String name;
+
+    //设备类型(
+    //网关：GATEWAY, 直连：DIRECT_CONNECTION, 网关子：SENSOR)
+    //默认填写：DIRECT_CONNECTION
+    private String deviceType;
+
+    //协议类型
+    //（DEFAULT,TCP,MQTT,COAP,GB
+    //T28281）默认填写：DEFAULT
+    private String transportType;
+
+    //平台设备配置 ID
+    private String deviceProfileId;
+
+    //设备配置 ID
+    private String profileId;
+
+    //组织 ID
+    private String organizationId;
+
+    //设备标签
+    private String label;
+
+    //设备描述
+    private String description;
+
+    //设备编号
+    private String sn;
+
+    //设备凭证信息
+    private DeviceToken deviceToken;
+
+}

+package com.iot.scheduler.model;
+
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * 三色灯状态详情
+ */
+@Data
+public class QxDeviceInfoDetail {
+    //设备状态
+    // RUN(运/行)/OFF(关机)/ERROR（故障）/STAND(待机)
+    private String status;
+
+    //是否报警 1/0
+    private boolean alarm;
+
+    //报警类型
+    private String alarmType;
+
+    //设备序列号
+    private String dtuSn;
+
+    //设备时间
+    private Date startTime;
+
+
+    //以下为非必填
+    //报警详情
+    private String alarmInfo;
+
+    //用电能耗
+    private double eleEnergy;
+
+    //用水量
+    private double waterEnergy;
+
+    //用气量
+    private double gasEnergy;
+
+    //产能
+    private double capacity;
+
+    /**
+     * 累计产量
+     */
+    private double cumulativeOutput;
+
+}

+package com.iot.scheduler.model;
+
+import lombok.Data;
+
+import java.util.Map;
+
+/**
+ * 上报设备状态
+ */
+@Data
+public class ReportDevice {
+
+    // 设备ID
+    private String deviceId;
+
+    // 上报设备属性
+    private Map<String, Object> properties;
+}

+package com.iot.scheduler.service;
+
+import com.alibaba.fastjson.JSON;
+import com.iot.scheduler.model.ReportDevice;
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.http.Consts;
+import org.apache.http.HttpEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Service;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.*;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * 怀宁设备属性上报
+ */
+@Slf4j
+@Service
+public class HnDeviceReportService {
+
+    @Value("${hn.third.domain:http://220.180.204.38:1803/report-property}")
+    private String reportUrl;
+
+    @Value("${hn.third.jdbcUrl:jdbc:postgresql://106.15.73.210:5433/thingskit}")
+    private String jdbcUrl;
+
+    @Value("${hn.third.jdbcUserName:postgres}")
+    private String jdbcUserName;
+
+    @Value("${hn.third.jdbcPassword:postgres}")
+    private String jdbcPassword;
+
+    @Value("${hn.third.selectSql:SELECT * FROM ts_kv_dictionary;}")
+    private String selectSql;
+
+    public void deviceReport() {
+        log.info("开始执行怀宁设备属性上报任务");
+        try {
+            List<Object> needSyncDataList = initConnectAndSelectData();
+            log.info("数据库查询完成，共获取{}条数据", needSyncDataList != null ? needSyncDataList.size() : 0);
+
+            if (CollectionUtils.isEmpty(needSyncDataList)) {
+                log.info("没有需要上报的数据，任务结束");
+                return;
+            }
+
+            log.info("开始处理{}条设备数据并进行上报", needSyncDataList.size());
+            int successCount = 0;
+            int failCount = 0;
+
+            for (int i = 0; i < needSyncDataList.size(); i++) {
+                Object needSyncData = needSyncDataList.get(i);
+                try {
+                    List<Object> dataList = (ArrayList) needSyncData;
+                    String deviceId = dataList.get(0).toString();
+
+                    log.info("开始处理设备[{}]的数据，进度: {}/{}", deviceId, i + 1, needSyncDataList.size());
+
+                    ReportDevice reportDevice = new ReportDevice();
+                    reportDevice.setDeviceId(deviceId);
+                    Map<String, Object> propertiesMap = new HashMap<>(4);
+
+                    String status = dataList.get(1).toString();
+                    if ("RUN".equals(status)) {
+                        propertiesMap.put("State_Run", 1);
+                        propertiesMap.put("State_PowerOn", 1);
+                        propertiesMap.put("State_Alarm", 0);
+                        log.info("设备[{}]状态为: RUN", deviceId);
+                    } else if ("STAND".equals(status)) {
+                        propertiesMap.put("State_Run", 0);
+                        propertiesMap.put("State_PowerOn", 1);
+                        propertiesMap.put("State_Alarm", 0);
+                        log.info("设备[{}]状态为: STAND", deviceId);
+                    } else if ("ERROR".equals(status)) {
+                        propertiesMap.put("State_Run", 0);
+                        propertiesMap.put("State_PowerOn", 1);
+                        propertiesMap.put("State_Alarm", 1);
+                        log.info("设备[{}]状态为: ERROR", deviceId);
+                    } else {
+                        propertiesMap.put("State_Run", 0);
+                        propertiesMap.put("State_PowerOn", 0);
+                        propertiesMap.put("State_Alarm", 0);
+                        log.info("设备[{}]状态为: 未知[{}]，设置为离线", deviceId, status);
+                    }
+
+                    Object outputValue = dataList.get(2);
+                    long outputLong = 0L;
+
+                    if (outputValue != null) {
+                        if (outputValue instanceof Double) {
+                            double doubleValue = (Double) outputValue;
+                            outputLong = (long) doubleValue; // 直接转型，会丢失小数部分
+                            log.info("设备[{}]输出值: {} (double转换为long: {})", deviceId, doubleValue, outputLong);
+                        } else if (outputValue instanceof Number) {
+                            outputLong = ((Number) outputValue).longValue();
+                            log.info("设备[{}]输出值: {} (Number转换为long: {})", deviceId, outputValue, outputLong);
+                        } else {
+                            // 处理字符串或其他类型
+                            outputLong = Long.parseLong(outputValue.toString());
+                            log.info("设备[{}]输出值: {} (字符串转换为long: {})", deviceId, outputValue, outputLong);
+                        }
+                    } else {
+                        log.info("设备[{}]输出值为null，使用默认值0", deviceId);
+                    }
+
+                    propertiesMap.put("ProInfo_Output", outputLong);
+                    reportDevice.setProperties(propertiesMap);
+
+                    boolean sendResult = sendReportDevice(reportDevice);
+                    if (sendResult) {
+                        successCount++;
+                        log.info("设备[{}]数据上报成功", deviceId);
+                    } else {
+                        failCount++;
+                        log.error("设备[{}]数据上报失败", deviceId);
+                    }
+
+                } catch (Exception e) {
+                    failCount++;
+                    log.error("处理第{}条数据时发生异常，数据内容: {}", i + 1, needSyncData, e);
+                }
+            }
+
+            log.info("设备属性上报任务完成，成功: {}条，失败: {}条，总计: {}条",
+                    successCount, failCount, needSyncDataList.size());
+
+        } catch (Exception e) {
+            log.error("执行设备属性上报任务时发生异常", e);
+        } finally {
+            log.info("怀宁设备属性上报任务执行结束");
+        }
+    }
+
+    private boolean sendReportDevice(ReportDevice reportDevice) {
+        String deviceId = reportDevice.getDeviceId();
+        log.info("开始上报设备[{}]的数据，请求URL: {}", deviceId, reportUrl);
+
+        HttpPost httpPost = new HttpPost(reportUrl);
+        CloseableHttpClient httpClient = HttpClients.createDefault();
+        String requestBody = JSON.toJSONString(reportDevice);
+
+        log.info("设备[{}]上报请求体: {}", deviceId, requestBody);
+
+        StringEntity entity = new StringEntity(requestBody, ContentType.create("application/json", Consts.UTF_8));
+        httpPost.setEntity(entity);
+        httpPost.setHeader("Content-Type", "application/json;charset=UTF-8");
+
+        try (CloseableHttpResponse execute = httpClient.execute(httpPost)) {
+            int statusCode = execute.getStatusLine().getStatusCode();
+
+            HttpEntity res = execute.getEntity();
+            String responseBody = "";
+            if (res != null) {
+                try (InputStream is = res.getContent();
+                     ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) {
+                    byte[] buf = new byte[128];
+                    int len;
+                    while ((len = is.read(buf)) != -1) {
+                        byteArrayOutputStream.write(buf, 0, len);
+                    }
+                    responseBody = byteArrayOutputStream.toString("UTF-8");
+                }
+            }
+
+            log.info("设备[{}]上报响应，状态码: {}，响应内容: {}", deviceId, statusCode, responseBody);
+
+            if (statusCode >= 200 && statusCode < 300) {
+                return true;
+            } else {
+                log.error("设备[{}]上报失败，HTTP状态码: {}，响应: {}", deviceId, statusCode, responseBody);
+                return false;
+            }
+
+        } catch (IOException e) {
+            log.error("设备[{}]上报请求发生IO异常", deviceId, e);
+            return false;
+        } finally {
+            try {
+                httpClient.close();
+            } catch (IOException e) {
+                log.error("关闭HTTP客户端时发生异常", e);
+            }
+        }
+    }
+
+    private List<Object> initConnectAndSelectData() {
+        Connection connection = null;
+        PreparedStatement statement = null;
+        ResultSet resultSet = null;
+        HikariDataSource dataSource = null;
+        List<Object> resultList = new ArrayList<>();
+
+        log.info("开始连接数据库，URL: {}", jdbcUrl);
+
+        try {
+            HikariConfig config = new HikariConfig();
+            config.setJdbcUrl(jdbcUrl);
+            config.setUsername(jdbcUserName);
+            config.setPassword(jdbcPassword);
+            config.setDriverClassName("org.postgresql.Driver");
+            config.setMaximumPoolSize(5);
+            config.setMinimumIdle(5);
+            config.setConnectionTimeout(60000);
+            config.setConnectionTestQuery("SELECT 1");
+
+            dataSource = new HikariDataSource(config);
+            log.info("Hikari连接池配置完成");
+
+            connection = dataSource.getConnection();
+            log.info("数据库连接成功");
+
+            statement = connection.prepareStatement(selectSql);
+            log.info("执行SQL查询: {}", selectSql);
+
+            resultSet = statement.executeQuery();
+            ResultSetMetaData metaData = resultSet.getMetaData();
+            int columnCount = metaData.getColumnCount();
+            log.info("查询结果集元数据获取成功，共{}列", columnCount);
+
+            int rowCount = 0;
+            while (resultSet.next()) {
+                List<Object> result = new ArrayList<>(columnCount);
+                for (int index = 1; index <= columnCount; index++) {
+                    int columnType = metaData.getColumnType(index);
+                    Object value = getTypedValue(resultSet, index, columnType);
+                    result.add(value);
+                }
+                resultList.add(result);
+                rowCount++;
+
+                // 每处理1000行记录一次日志
+                if (rowCount % 1000 == 0) {
+                    log.info("已处理{}行数据", rowCount);
+                }
+            }
+
+            log.info("数据查询完成，共获取{}行数据", rowCount);
+
+        } catch (SQLException e) {
+            log.error("数据库操作异常，URL: {}, 用户名: {}", jdbcUrl, jdbcUserName, e);
+        } catch (Exception e) {
+            log.error("初始化数据库连接或查询数据时发生异常", e);
+        } finally {
+            // 释放资源
+            try {
+                if (resultSet != null) resultSet.close();
+                if (statement != null) statement.close();
+                if (connection != null) connection.close();
+                log.info("数据库连接资源已释放");
+            } catch (SQLException e) {
+                log.error("关闭数据库资源时发生异常", e);
+            }
+
+            if (dataSource != null) {
+                try {
+                    dataSource.close();
+                    log.info("HikariDataSource连接池已关闭");
+                } catch (Exception e) {
+                    log.error("关闭HikariDataSource连接池时发生异常", e);
+                }
+            }
+        }
+
+        log.info("数据库操作完成，返回{}条记录", resultList.size());
+        return resultList;
+    }
+
+    private Object getTypedValue(ResultSet rs, int index, int sqlType) throws SQLException {
+        Object value;
+
+        try {
+            switch (sqlType) {
+                case Types.BIT:
+                case Types.BOOLEAN:
+                    value = rs.getBoolean(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.TINYINT:
+                case Types.SMALLINT:
+                case Types.INTEGER:
+                    value = rs.getInt(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.BIGINT:
+                    value = rs.getLong(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.FLOAT:
+                case Types.REAL:
+                    value = rs.getFloat(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.DOUBLE:
+                    value = rs.getDouble(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.NUMERIC:
+                case Types.DECIMAL:
+                    value = rs.getBigDecimal(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.CHAR:
+                case Types.VARCHAR:
+                case Types.LONGVARCHAR:
+                case Types.NCHAR:
+                case Types.NVARCHAR:
+                case Types.LONGNVARCHAR:
+                    value = rs.getString(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.DATE:
+                    Date date = rs.getDate(index);
+                    return date != null ? date.toLocalDate() : null;
+
+                case Types.TIME:
+                    Time time = rs.getTime(index);
+                    return time != null ? time.toLocalTime() : null;
+
+                case Types.TIMESTAMP:
+                    Timestamp timestamp = rs.getTimestamp(index);
+                    return timestamp != null ? timestamp.toLocalDateTime() : null;
+
+                case Types.BINARY:
+                case Types.VARBINARY:
+                case Types.LONGVARBINARY:
+                    value = rs.getBytes(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.BLOB:
+                    value = rs.getBlob(index);
+                    return rs.wasNull() ? null : value;
+
+                case Types.CLOB:
+                    value = rs.getClob(index);
+                    return rs.wasNull() ? null : value;
+
+                default:
+                    value = rs.getObject(index);
+                    return rs.wasNull() ? null : value;
+            }
+        } catch (SQLException e) {
+            log.error("获取结果集第{}列数据时发生异常，数据类型: {}", index, sqlType, e);
+            throw e;
+        }
+    }
+}
\ No newline at end of file

+package com.iot.scheduler.service;
+
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.iot.scheduler.model.DeviceToken;
+import com.iot.scheduler.model.QxDeviceInfo;
+import com.iot.scheduler.model.QxDeviceInfoDetail;
+import jakarta.annotation.Resource;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.http.Consts;
+import org.apache.http.HttpEntity;
+import org.apache.http.client.methods.CloseableHttpResponse;
+import org.apache.http.client.methods.HttpGet;
+import org.apache.http.client.methods.HttpPost;
+import org.apache.http.entity.ContentType;
+import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.CloseableHttpClient;
+import org.apache.http.impl.client.HttpClients;
+import org.apache.http.message.BasicHeader;
+import org.apache.http.util.EntityUtils;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Service;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.SimpleDateFormat;
+import java.time.LocalTime;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * 三环朝晖应用数据同步
+ */
+@Slf4j
+@Service
+public class ShDevicePullService {
+
+    @Value("${sh.iot.organizeId:}")
+    private String iotOrganizeId;
+    @Value("${sh.iot.profileId}")
+    private String iotProfileId;
+    @Value("${sh.iot.deviceProfileId}")
+    private String iotDeviceProfileId;
+    @Value("${sh.iot.userName:}")
+    private String iotUserName;
+    @Value("${sh.iot.password:}")
+    private String iotPassword;
+    @Value("${sh.iot.tokenUrl}")
+    private String iotTokenUrl;
+    @Value("${sh.iot.infoUrl}")
+    private String iotDeviceInfoUrl;
+    @Value("${sh.iot.detailUrl}")
+    private String iotDeviceDetailUrl;
+
+    @Value("${device.token.url}")
+    private String deviceTokenUrl;
+    @Value("${device.token.userName}")
+    private String deviceUserName;
+    @Value("${device.token.password}")
+    private String devicePassword;
+    @Value("${device.info.url}")
+    private String deviceInfoUrl;
+    @Value("${device.detail.url}")
+    private String deviceDetailUrl;
+
+    @Resource
+    private RedisTemplate<String, String> redisTemplate;
+
+    final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+    public void pullDeviceAndPushToIot() {
+        String deviceResult = getDeviceInfo();
+        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<>() {
+        });
+
+        JSONArray deviceInfoList = (JSONArray) deviceInfos.get("data");
+        List<QxDeviceInfo> qxDeviceInfos = new ArrayList<>();
+        List<QxDeviceInfoDetail> qxAddDeviceInfoDetails = new ArrayList<>();
+        Map<String, QxDeviceInfoDetail> qxDeviceInfoDetailMap = new HashMap<>();
+        for (Object o : deviceInfoList) {
+            JSONObject deviceInfoJson = (JSONObject) o;
+            QxDeviceInfo qxDeviceInfo = new QxDeviceInfo();
+            qxDeviceInfo.setDeviceType("DIRECT_CONNECTION");
+            qxDeviceInfo.setTransportType("DEFAULT");
+            qxDeviceInfo.setOrganizationId(iotOrganizeId);
+            qxDeviceInfo.setDeviceProfileId(iotDeviceProfileId);
+            qxDeviceInfo.setProfileId(iotProfileId);
+//            //项目状态（1：在线，2：离线，3：报警）
+//            Integer projectState = deviceInfoJson.getInteger("projectState");
+//            if (projectState != null) {
+//                qxDeviceInfo.setDescription(String.valueOf(projectState));
+//            }
+
+            //项目类型
+            qxDeviceInfo.setLabel("生产设备");
+            //设备名称
+            String deviceName = deviceInfoJson.getString("deviceName");
+
+            qxDeviceInfo.setName(deviceName);
+            qxDeviceInfo.setBrand(deviceName);
+            //序列号
+            String dtuSn = deviceInfoJson.getString("dtuSn");
+            qxDeviceInfo.setSn(dtuSn);
+            //高速/中速
+            List<String> highSpeedDeviceList = Arrays.asList("AGX251111720", "AGY251111266", "AGM251111722", "AGF251111329",
+                    "AGM251111301", "AGM251111746", "AGW251111837", "AGW251111403", "AGW251111450");
+            if (highSpeedDeviceList.contains(dtuSn)) {
+                qxDeviceInfo.setDescription("高速机");
+            } else {
+                qxDeviceInfo.setDescription("中速机");
+            }
+
+            DeviceToken deviceToken = new DeviceToken();
+            deviceToken.setCredentialsType("ACCESS_TOKEN");
+            deviceToken.setCredentialsId(dtuSn);
+            deviceToken.setCredentialsValue(dtuSn);
+            qxDeviceInfo.setDeviceToken(deviceToken);
+            qxDeviceInfos.add(qxDeviceInfo);
+            //有序列号直接获取灯信息
+            if (StringUtils.isNotBlank(dtuSn)) {
+                String deviceInfoDetails = getDeviceInfoDetail(dtuSn);
+                if (StringUtils.isBlank(deviceInfoDetails)) {
+                    continue;
+                }
+
+                Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetails, new TypeReference<>() {
+                });
+
+                JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
+                if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
+                    continue;
+                }
+
+                JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
+                //灯详情数据
+                //序列号
+                String dtuSnDetail = deviceInfoDetailJson.getString("dtuSn");
+                //开始时间
+                String startTime = deviceInfoDetailJson.getString("startTime");
+                QxDeviceInfoDetail qxDeviceInfoDetail = new QxDeviceInfoDetail();
+                qxDeviceInfoDetail.setAlarm(false);
+                //灯状态(0:灭灯，1：红，2：黄，3：绿，4：蓝)
+                Integer lampState = deviceInfoDetailJson.getInteger("lampState");
+                switch (lampState) {
+                    case 0:
+                        qxDeviceInfoDetail.setStatus("OFF");
+                        break;
+                    case 1:
+                        qxDeviceInfoDetail.setStatus("ERROR");
+                        qxDeviceInfoDetail.setAlarm(true);
+                        break;
+                    case 2:
+                        qxDeviceInfoDetail.setStatus("STAND");
+                        break;
+                    case 3:
+                        qxDeviceInfoDetail.setStatus("RUN");
+                        //先从缓存里面拿token信息
+                        String totalCapacity = getTotalCapacity("total_capacity_" + dtuSn, highSpeedDeviceList.contains(dtuSn));
+                        qxDeviceInfoDetail.setCumulativeOutput(Double.valueOf(totalCapacity));
+                        break;
+                    default:
+                        continue;
+                }
+
+                if (StringUtils.isNotBlank(startTime)) {
+                    try {
+                        qxDeviceInfoDetail.setStartTime(dateFormat.parse(startTime));
+                    } catch (Exception e) {
+                        log.error("时间格式出错");
+                        qxDeviceInfoDetail.setStartTime(new Date());
+                    }
+                } else {
+                    qxDeviceInfoDetail.setStartTime(new Date());
+                }
+
+                qxDeviceInfoDetail.setDtuSn(dtuSn);
+                qxDeviceInfoDetailMap.put(dtuSn, qxDeviceInfoDetail);
+                qxAddDeviceInfoDetails.add(qxDeviceInfoDetail);
+            }
+        }
+
+        //将数据同步到IOT平台
+        Map<String, String> qxParam = new HashMap<>(2);
+        qxParam.put("username", iotUserName);
+        qxParam.put("password", iotPassword);
+
+        HttpPost qxHttpPost = new HttpPost(iotTokenUrl);
+        String qxResult = sendPost(qxHttpPost, JSON.toJSONString(qxParam));
+        if (StringUtils.isBlank(qxResult)) {
+            return;
+        }
+        Map<String, Object> qxRes = JSON.parseObject(qxResult, new TypeReference<Map<String, Object>>() {
+        });
+
+        String qxAccessToken = (String) qxRes.get("token");
+        if (StringUtils.isBlank(qxAccessToken)) {
+            return;
+        }
+
+        BasicHeader qxAuthorization = new BasicHeader("X-Authorization", "Bearer " + qxAccessToken);
+        if (!CollectionUtils.isEmpty(qxDeviceInfos)) {
+            HttpPost qxDeviceInfoPost = new HttpPost(iotDeviceInfoUrl);
+            qxDeviceInfoPost.addHeader(qxAuthorization);
+            for (QxDeviceInfo qxDeviceInfo : qxDeviceInfos) {
+                // todo
+                String syncDeviceInfo = sendPost(qxDeviceInfoPost, JSON.toJSONString(qxDeviceInfo));
+                //log.info("同步设备信息 syncDeviceInfo:{}", syncDeviceInfo);
+            }
+        }
+
+        if (!CollectionUtils.isEmpty(qxAddDeviceInfoDetails)) {
+            for (QxDeviceInfoDetail qxDeviceInfoDetail : qxAddDeviceInfoDetails) {
+                String qxDeviceInfoDetailUrlStr = iotDeviceDetailUrl + qxDeviceInfoDetail.getDtuSn() + "/telemetry";
+                HttpPost qxDeviceInfoDetailPost = new HttpPost(qxDeviceInfoDetailUrlStr);
+                qxDeviceInfoDetailPost.addHeader(qxAuthorization);
+                String syncDeviceInfoDetail = sendPost(qxDeviceInfoDetailPost, JSON.toJSONString(qxDeviceInfoDetail));
+            }
+        }
+    }
+
+    private String getTotalCapacity(String key, boolean highSpeedDevice) {
+        String totalCapacity = redisTemplate.opsForValue().get(key);
+        Double production = highSpeedDevice ? 120D : 90D;
+        Double totalCapacityD = 0D;
+        if (StringUtils.isEmpty(totalCapacity)) {
+            totalCapacityD = production;
+        } else {
+            totalCapacityD = Double.parseDouble(totalCapacity) + production;
+        }
+
+        redisTemplate.opsForValue().set(key, String.valueOf(totalCapacityD));
+        return String.valueOf(totalCapacityD);
+    }
+
+    public String getDeviceInfoDetail(String dtuSn) {
+        String accessToken = getAccessToken();
+        Map<String, String> dtuSnOb = new HashMap<>(1);
+        dtuSnOb.put("dtuSn", dtuSn);
+        Map<String, String> headerMap = new HashMap<>(1);
+        headerMap.put("Authorization", "Bearer " + accessToken);
+        String deviceInfoDetail = sendRequestGet(deviceDetailUrl, dtuSnOb, headerMap);
+        if (StringUtils.isBlank(deviceInfoDetail)) {
+            return null;
+        }
+
+        Map<String, Object> deviceInfoDetailMap = JSON.parseObject(deviceInfoDetail,
+                new TypeReference<>() {
+                });
+        Integer deviceInfoDetailCode = (Integer) deviceInfoDetailMap.get("code");
+        if (deviceInfoDetailCode != 200) {
+            return null;
+        }
+
+        JSONArray deviceInfoDetailList = (JSONArray) deviceInfoDetailMap.get("data");
+        if (CollectionUtils.isEmpty(deviceInfoDetailList)) {
+            return null;
+        }
+
+        JSONObject deviceInfoDetailJson = (JSONObject) deviceInfoDetailList.get(0);
+        //灯详情数据
+        //灯状态(0:灭灯，1：红，2：黄，3：绿，4：蓝)
+        Integer lampState = deviceInfoDetailJson.getInteger("lampState");
+        if (lampState == null) {
+            return null;
+        }
+
+        return deviceInfoDetail;
+    }
+
+    public String getDeviceInfo() {
+        String accessToken = getAccessToken();
+        // 初始化headerMap并设置Authorization
+        Map<String, String> headerMap = new HashMap<>(1);
+        headerMap.put("Authorization", "Bearer " + accessToken);
+
+        Map<String, String> paramsMap = new HashMap<>();
+        paramsMap.put("groupName", "三环朝晖");
+
+        // 第一次请求设备信息
+        String deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
+
+        // 检查设备信息是否为空
+        if (StringUtils.isBlank(deviceResult)) {
+            return null;
+        }
+
+        // 解析设备信息
+        Map<String, Object> deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
+        });
+        Integer deviceInfoCode = (Integer) deviceInfos.get("code");
+
+        // 如果code不为200，可能是accessToken失效，重新获取token并重试
+        if (deviceInfoCode != 200) {
+            accessToken = getAccessToken();
+            if (StringUtils.isEmpty(accessToken)) {
+                return null;
+            }
+
+            // 更新headerMap中的Authorization
+            headerMap.put("Authorization", "Bearer " + accessToken);
+
+            // 第二次请求设备信息
+            deviceResult = sendRequestGet(deviceInfoUrl, paramsMap, headerMap);
+            if (StringUtils.isBlank(deviceResult)) {
+                return null;
+            }
+
+            // 重新解析设备信息
+            deviceInfos = JSON.parseObject(deviceResult, new TypeReference<Map<String, Object>>() {
+            });
+            deviceInfoCode = (Integer) deviceInfos.get("code");
+
+            // 如果第二次请求仍然失败，返回错误信息
+            if (deviceInfoCode != 200) {
+                return null;
+            }
+        }
+
+        // 返回成功的设备信息
+        return deviceResult;
+    }
+
+    private String getAccessToken() {
+        String accessToken = "";
+        String redisKey = "device_token";
+        if (StringUtils.isNotBlank(redisTemplate.opsForValue().get(redisKey)) && redisTemplate.getExpire(redisKey) > 0) {
+            return redisTemplate.opsForValue().get(redisKey);
+        }
+
+        Map<String, String> param = new HashMap<>(2);
+        param.put("username", deviceUserName);
+        param.put("password", devicePassword);
+        HttpPost httpPost = new HttpPost(deviceTokenUrl);
+        String result = sendPost(httpPost, JSON.toJSONString(param));
+        if (StringUtils.isBlank(result)) {
+            return accessToken;
+        }
+
+        Map<String, Object> res = JSON.parseObject(result, new TypeReference<>() {
+        });
+
+        Integer code = (Integer) res.get("code");
+        if (code == 200) {
+            JSONObject data = (JSONObject) res.get("data");
+            accessToken = (String) data.get("token");
+            redisTemplate.opsForValue().set(redisKey, accessToken, 3600, TimeUnit.SECONDS); // 一小时过期
+        }
+
+        return accessToken;
+    }
+
+    public static String sendRequestGet(String url, Map<String, String> params, Map<String, String> header) {
+        //实例化httpclient
+        CloseableHttpClient httpclient = HttpClients.createDefault();
+        url = builderUrl(url, params);
+        //请求结果
+        String content = "";
+        //实例化get方法
+        HttpGet httpget = new HttpGet(url);
+        if (!CollectionUtils.isEmpty(header)) {
+            for (Map.Entry<String, String> entry : header.entrySet()) {
+                httpget.setHeader(entry.getKey(), entry.getValue());
+            }
+        }
+
+        try (CloseableHttpResponse response = httpclient.execute(httpget)) {
+
+            //执行get方法
+            if (response.getStatusLine().getStatusCode() == 200) {
+                content = EntityUtils.toString(response.getEntity(), "UTF-8");
+            }
+        } catch (IOException e) {
+            log.error("sendRequest---GET Error!", e);
+        }
+        return content;
+    }
+
+    private static String builderUrl(String url, Map<String, String> params) {
+        UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(url);
+        if (!CollectionUtils.isEmpty(params)) {
+            MultiValueMap<String, String> paramsValue = new LinkedMultiValueMap<>();
+            for (Map.Entry<String, String> entry : params.entrySet()) {
+                paramsValue.add(entry.getKey(), entry.getValue());
+            }
+
+            uriBuilder = uriBuilder.queryParams(paramsValue);
+        }
+
+        return uriBuilder.toUriString();
+    }
+
+    private String sendPost(HttpPost httpPost, String jsonData) {
+        CloseableHttpClient httpClient = HttpClients.createDefault();
+        StringEntity entity = new StringEntity(jsonData, ContentType.create("application/json", Consts.UTF_8));
+        httpPost.setEntity(entity);
+        String result = null;
+        try {
+            CloseableHttpResponse execute = httpClient.execute(httpPost);
+            HttpEntity res = execute.getEntity();
+            InputStream is = res.getContent();
+            int len;
+            byte[] buf = new byte[128];
+            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
+            while ((len = is.read(buf)) != -1) {
+                byteArrayOutputStream.write(buf, 0, len);
+            }
+            result = byteArrayOutputStream.toString();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return result;
+    }
+}

 package com.iot.scheduler.zone;
 
+import com.iot.scheduler.service.HnDeviceReportService;
 import com.iot.scheduler.task.AbstractZoneScheduler;
+import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
@@ -9,6 +11,9 @@ import org.springframework.stereotype.Component;
 @Component
 public class ChizhouZoneScheduler extends AbstractZoneScheduler {
 
+    @Resource
+    private HnDeviceReportService hnDeviceReportService;
+
     @Override
     protected String getZoneName() {
         return "Chizhou (池州经开区)";

@@ -3,6 +3,15 @@ spring:
     name: iot-scheduler
   main:
     banner-mode: off
+  data:
+    redis:
+      cluster:
+        nodes: # 集群节点列表
+          - 10.9.1.252:16380
+          - 10.9.1.252:16381
+          - 10.9.1.252:16382
+        max-redirects: 3  # 最大重定向次数
+      password: "Qixiao@redis20240410.com"  # 如果有密码
 
 server:
   port: 8080
@@ -24,3 +33,44 @@ scheduler:
   panji:
     pull: "0 0/5 * * * ?"
     push: "0 0/10 * * * ?"
+
+hn:
+  third:
+    domain: "http://220.180.204.38:1803/report-property"
+    jdbcUrl: "jdbc:postgresql://106.15.73.210:5433/thingskit"
+    jdbcUserName: "postgres"
+    jdbcPassword: "postgres"
+    selectSql: "SELECT
+                  de.sn,
+                  tkl1.str_v,
+                  tkl2.dbl_v
+                FROM
+                  device de
+                  LEFT JOIN ts_kv_latest tkl1 ON de.id = tkl1.entity_id
+                  AND tkl1.key = 61
+                  LEFT JOIN ts_kv_latest tkl2 ON de.id = tkl2.entity_id
+                  AND tkl2.key = 175
+                  WHERE
+                  de.organization_id = 'f82530a0-93e4-4aeb-9339-f5b6d1127840';"
+
+sh:
+  iot:
+    organizeId: "f82530a0-93e4-4aeb-9339-f5b6d1127840"
+    profileId: "f2292f60-f738-11f0-9cb8-e3376d1e7978"
+    deviceProfileId: "f2292f60-f738-11f0-9cb8-e3376d1e7978"
+    userName: "shzh"
+    password: "123456"
+    tokenUrl: "https://iot.hzzlyun.com/api/auth/login"
+    infoUrl: "https://iot.hzzlyun.com/api/yt/device"
+    detailUrl: "https://iot.hzzlyun.com/api/v1/"
+
+device:
+  token:
+    url: "https://iotgc.cniot.vip/auth/token"
+    userName: "chuzhoult"
+    password: "111111"
+  info:
+    url: "https://iotgc.cniot.vip/triColorLamp/userGroupDtuSns"
+  detail:
+    url: "https://iotgc.cniot.vip/triColorLamp/dtuSnState"
+