package com.ruoyi.energymeter.provider;
import cn.hutool.http.HttpException;
import cn.hutool.http.HttpRequest;
import cn.hutool.http.HttpResponse;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.energymeter.config.EnergyMeterProperties;
import com.ruoyi.energymeter.constant.EnergyMeterConstants;
import com.ruoyi.energymeter.dto.MeterArchive;
import com.ruoyi.energymeter.dto.MeterQuarterPoint;
import com.ruoyi.energymeter.dto.MeterReadingPoint;
import com.ruoyi.energymeter.dto.MeterUsagePoint;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
/**
* 集社云能源监控 API 客户端。
*
*
真实调用:POST application/json,请求头传 API_KEY。授权码只从配置读取,日志不输出授权码与响应原文。
* 演示模式:未配置授权码或显式开启 mock 时,生成可重复的本地数据,仅用于本地联调与页面演示。
*/
@Slf4j
@Component
@RequiredArgsConstructor
public class YunJiChaoBiaoProviderClient implements MeterProviderClient {
private static final String PATH_ELECTRIC_ARCHIVE = "/NH2/AmmeterBasicInfo";
private static final String PATH_WATER_ARCHIVE = "/NH2/WatermeterBasicInfo";
private static final String PATH_WATER_USAGE = "/NH2/GetUseWater";
private static final String PATH_WATER_RAW = "/NH2/GetWaterRawData";
private static final String PATH_FROZEN_ELECTRICITY = "/NH2/FrozenElectricity";
private static final String PATH_GAS_ARCHIVE = "/NH2/GasmeterBasicInfo";
private static final String PATH_GAS_USAGE = "/NH2/GetGasUseData";
private static final String PATH_GAS_RAW = "/NH2/GetGasRawData";
private static final String PATH_ELECTRIC_QUANTITY = "/NH2/ElectricQuantity";
/** 演示读数基准日期与基准表码,保证重复查询结果一致。 */
private static final LocalDate MOCK_READING_EPOCH = LocalDate.of(2025, 9, 1);
private static final BigDecimal MOCK_WATER_BASE = BigDecimal.valueOf(1000);
private static final BigDecimal MOCK_ELECTRIC_BASE = BigDecimal.valueOf(50000);
private static final DateTimeFormatter[] DATE_TIME_FORMATS = new DateTimeFormatter[]{
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"),
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"),
DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss"),
DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"),
DateTimeFormatter.ofPattern("yyyy-MM-dd"),
DateTimeFormatter.ofPattern("yyyy/MM/dd")
};
private final EnergyMeterProperties properties;
/** 上一次请求时间,用于控制最小请求间隔,规避供应商限流。 */
private long lastRequestAt = 0L;
/**
* 全局最小请求间隔:供应商对短时间内的连续调用会返回 429,这里串行控速。
*/
private synchronized void throttle(long minIntervalMs) {
if (minIntervalMs <= 0) {
return;
}
long wait = minIntervalMs - (System.currentTimeMillis() - lastRequestAt);
if (wait > 0) {
try {
Thread.sleep(wait);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
lastRequestAt = System.currentTimeMillis();
}
@Override
public boolean mockMode() {
// 只有显式开启 mock 才使用演示数据;未配置授权码时直接报错,避免把模拟值当成真实用量
return properties.getProvider().isMockEnabled();
}
@Override
public boolean hasApiKey() {
return StringUtils.isNotBlank(properties.getProvider().getApiKey());
}
@Override
public MeterArchive queryArchive(String meterType, String address) {
String trimmed = StringUtils.trim(address);
if (StringUtils.isBlank(trimmed)) {
throw new MeterProviderException("INVALID_ADDRESS", "通信地址不能为空");
}
if (mockMode()) {
return mockArchive(meterType, trimmed);
}
boolean water = EnergyMeterConstants.isWater(meterType);
boolean gas = EnergyMeterConstants.isGas(meterType);
JSONObject payload = new JSONObject();
if (water || gas) {
payload.put("address", trimmed);
} else {
payload.put("meterAddress", trimmed);
}
String archivePath = gas ? PATH_GAS_ARCHIVE
: (water ? PATH_WATER_ARCHIVE : PATH_ELECTRIC_ARCHIVE);
List items = callList(archivePath, payload);
JSONObject matched = items.stream()
.filter(item -> trimmed.equals(StringUtils.trim(firstString(item, "Address", "address"))))
.findFirst()
.orElse(null);
if (matched == null) {
throw new MeterProviderException("NOT_FOUND", "第三方未找到该表计");
}
MeterArchive archive = new MeterArchive();
archive.setMeterType(EnergyMeterConstants.canonicalType(meterType));
archive.setMeterAddress(trimmed);
archive.setProviderMeterId(firstString(matched, "ID", "Id", "id"));
archive.setProviderName(water || gas
? firstString(matched, "Name", "name")
: firstString(matched, "AmmeterName", "Name", "name"));
archive.setAreaName(firstString(matched, "AreaName", "areaName"));
archive.setParentProviderId(firstString(matched, "ParentID", "ParentId", "parentId"));
archive.setStateText(firstString(matched, "State", "LineState", "OnlineState"));
archive.setOnlineStatus(parseOnline(water || gas
? firstString(matched, "LineState", "State", "OnlineState")
: firstString(matched, "OnlineState", "State")));
Long areaId = firstLong(matched, "AreaID", "AreaId", "areaId");
archive.setAreaId(areaId);
return archive;
}
@Override
public List queryDailyUsage(String meterType, String address, String providerMeterId,
LocalDate start, LocalDate end) {
boolean water = EnergyMeterConstants.isWater(meterType);
boolean gas = EnergyMeterConstants.isGas(meterType);
if (mockMode()) {
return mockUsage(meterType, address, start, end);
}
JSONObject payload = new JSONObject();
payload.put("dateType", "D");
payload.put("startTime", start.toString());
payload.put("endTime", end.toString());
String path;
if (water) {
payload.put("address", address);
path = PATH_WATER_USAGE;
} else if (gas) {
// 气表用量接口按第三方设备ID查询,不认通信地址
payload.put("gasmeterID", requireMeterId(meterType, providerMeterId));
path = PATH_GAS_USAGE;
} else {
// 电表期间用量用 ElectricQuantity 的 ZYGDN(正向有功电量);
// FrozenElectricity 的 TotalKwh 在部分表上恒为 null,不能作为用量来源
payload.put("meterAddress", address);
payload.put("valueType", "SJZ");
path = PATH_ELECTRIC_QUANTITY;
}
List items = callList(path, payload);
List points = new ArrayList<>(items.size());
for (JSONObject item : items) {
String rawTime = firstString(item, "ReadingDate", "readingDate", "Time", "time", "Date");
LocalDateTime time = parseDateTime(rawTime);
if (time == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE,
"无法识别用量时间:" + rawTime);
}
BigDecimal value;
if (water) {
value = firstDecimal(item, "Value", "value", "UseNumber");
} else if (gas) {
value = firstDecimal(item, "UseNumber", "useNumber");
} else {
value = firstDecimal(item, "ZYGDN", "zygdn", "TotalKwh", "totalKwh");
}
if (value == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "用量字段缺失");
}
MeterUsagePoint point = new MeterUsagePoint();
point.setTime(time.toLocalDate().atStartOfDay());
point.setValue(value);
point.setAddress(firstString(item, "Address", "address"));
point.setRawTime(rawTime);
points.add(point);
}
return points;
}
@Override
public List queryQuarterUsage(String meterType, String address, String providerMeterId,
LocalDate start, LocalDate end) {
if (!EnergyMeterConstants.isElectric(meterType)) {
throw new MeterProviderException("UNSUPPORTED",
"15 分钟电量目前只支持电表");
}
if (mockMode()) {
return mockQuarterUsage(address, start, end);
}
JSONObject payload = new JSONObject();
payload.put("dateType", "mi15");
payload.put("startTime", start.toString());
payload.put("endTime", end.toString());
payload.put("meterAddress", address);
payload.put("valueType", "SJZ");
List items = callList(PATH_ELECTRIC_QUANTITY, payload);
List points = new ArrayList<>(items.size());
for (JSONObject item : items) {
String rawTime = firstString(item, "ReadingDate", "readingDate", "Time", "time", "Date");
LocalDateTime time = parseDateTime(rawTime);
if (time == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE,
"无法识别 15 分钟电量时间:" + rawTime);
}
BigDecimal active = firstDecimal(item, "ZYGDN", "zygdn");
// 最后一个未闭合时间片的 ZYGDN 为空,只保留已经结算的时间片
if (active == null) {
continue;
}
MeterQuarterPoint point = new MeterQuarterPoint();
point.setTime(time);
point.setActive(active);
point.setReactive(firstDecimal(item, "ZWGDN", "zwgdn"));
point.setActiveReading(firstDecimal(item, "ZYGDNSZ", "zygdnsz"));
point.setReactiveReading(firstDecimal(item, "ZWGDNSZ", "zwgdnsz"));
point.setAddress(firstString(item, "Address", "address"));
point.setRawTime(rawTime);
points.add(point);
}
return points;
}
@Override
public List queryReadings(String meterType, String address, String providerMeterId,
LocalDate start, LocalDate end) {
boolean water = EnergyMeterConstants.isWater(meterType);
if (mockMode()) {
return mockReadings(meterType, address, start, end);
}
if (EnergyMeterConstants.isGas(meterType)) {
return queryGasReadings(address, providerMeterId, start, end);
}
JSONObject payload = new JSONObject();
payload.put("startTime", start.toString());
payload.put("endTime", end.toString());
if (water) {
payload.put("address", address);
List items = callList(PATH_WATER_RAW, payload);
List points = new ArrayList<>(items.size());
for (JSONObject item : items) {
String rawTime = firstString(item, "ReadingDate", "readingDate", "Time", "time", "Date");
LocalDateTime time = parseDateTime(rawTime);
if (time == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "无法识别示值时间:" + rawTime);
}
BigDecimal reading = firstDecimal(item, "ReadNumber", "readNumber");
if (reading == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "示值字段缺失");
}
MeterReadingPoint point = new MeterReadingPoint();
point.setTime(time);
point.setReading(reading);
point.setUsage(firstDecimal(item, "UseNumber", "useNumber"));
point.setAddress(firstString(item, "Address", "address"));
point.setRawTime(rawTime);
points.add(point);
}
return points;
}
payload.put("meterAddress", address);
payload.put("dateType", "D");
payload.put("valueType", "SJZ");
List items = callList(PATH_FROZEN_ELECTRICITY, payload);
List points = new ArrayList<>(items.size());
for (JSONObject item : items) {
// FrozenElectricity 同一天会返回 Type=D(表码)与 Type=DF(日冻结电量)两行,
// 只有 Type=D 的 TotalNowKwh 才是累计表码
String freezeType = firstString(item, "Type", "type");
if (StringUtils.isNotBlank(freezeType) && !"D".equalsIgnoreCase(freezeType)) {
continue;
}
String rawTime = firstString(item, "ReadingDate", "readingDate", "Time", "time", "Date");
LocalDateTime time = parseDateTime(rawTime);
if (time == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "无法识别示值时间:" + rawTime);
}
BigDecimal reading = firstDecimal(item, "TotalNowKwh", "totalNowKwh", "ZYGDNSZ", "zygdnsz");
if (reading == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "示值字段缺失");
}
MeterReadingPoint point = new MeterReadingPoint();
point.setTime(time);
point.setReading(reading);
point.setUsage(firstDecimal(item, "TotalKwh", "totalKwh"));
point.setAddress(firstString(item, "Address", "address"));
point.setRawTime(rawTime);
points.add(point);
}
return points;
}
/**
* 气表示值:/NH2/GetGasRawData,按第三方设备ID或通信地址查询。
*/
private List queryGasReadings(String address, String providerMeterId,
LocalDate start, LocalDate end) {
JSONObject payload = new JSONObject();
payload.put("pageIndex", "1");
payload.put("pageSize", "100");
payload.put("dateType", "D");
payload.put("areaID", "0");
payload.put("gasmeterID", requireMeterId(EnergyMeterConstants.TYPE_GAS, providerMeterId));
payload.put("address", StringUtils.defaultString(address));
payload.put("startTime", start.toString());
payload.put("endTime", end.toString());
List items = callList(PATH_GAS_RAW, payload);
List points = new ArrayList<>(items.size());
for (JSONObject item : items) {
String rawTime = firstString(item, "ReadingDate", "readingDate", "RealReadingDate", "Time", "time");
LocalDateTime time = parseDateTime(rawTime);
if (time == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "无法识别气表示值时间:" + rawTime);
}
BigDecimal reading = firstDecimal(item, "ReadNumber", "readNumber");
if (reading == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "气表示值字段缺失");
}
MeterReadingPoint point = new MeterReadingPoint();
point.setTime(time);
point.setReading(reading);
point.setUsage(firstDecimal(item, "UseNumber", "useNumber"));
point.setAddress(firstString(item, "Address", "address"));
point.setRawTime(rawTime);
points.add(point);
}
return points;
}
/**
* 气表接口要求传第三方设备ID(数字),这里统一校验。
*/
private long requireMeterId(String meterType, String providerMeterId) {
if (StringUtils.isBlank(providerMeterId)) {
throw new MeterProviderException("MISSING_METER_ID",
EnergyMeterConstants.typeName(meterType) + "缺少第三方设备ID,请重新验证档案后再采集");
}
try {
return Long.parseLong(providerMeterId.trim());
} catch (NumberFormatException e) {
throw new MeterProviderException("MISSING_METER_ID",
"第三方设备ID格式不正确:" + providerMeterId);
}
}
/* ------------------------------------------------------------------ */
/* HTTP 调用与响应解析 */
/* ------------------------------------------------------------------ */
private List callList(String path, JSONObject payload) {
JSONObject root = call(path, payload);
JSONArray array = findArray(root);
if (array == null) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "第三方响应缺少数据列表");
}
List items = new ArrayList<>(array.size());
for (int i = 0; i < array.size(); i++) {
JSONObject item = array.getJSONObject(i);
if (item != null) {
items.add(item);
}
}
int pageCount = firstInt(root, 1, "pageCount", "pagecount", "pages", "totalPage", "totalPages");
if (pageCount > 1) {
int pageSize = firstInt(root, Math.max(items.size(), 1), "pageSize", "pagesize", "size");
int total = firstInt(root, -1, "total", "totalCount", "totalRows", "count");
Set fingerprints = new HashSet<>();
items.forEach(item -> fingerprints.add(item.toJSONString()));
for (int page = 2; page <= pageCount; page++) {
JSONObject nextPayload = new JSONObject(payload);
nextPayload.put("pageIndex", page);
nextPayload.put("pageSize", pageSize);
nextPayload.put("pageNum", page);
JSONArray nextArray = findArray(call(path, nextPayload));
if (nextArray == null || nextArray.isEmpty()) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PAGE_INCOMPLETE,
"第三方分页第 " + page + " 页为空,无法确认全量数据");
}
for (int i = 0; i < nextArray.size(); i++) {
JSONObject item = nextArray.getJSONObject(i);
if (item != null && fingerprints.add(item.toJSONString())) {
items.add(item);
}
}
}
if (total > 0 && items.size() < total) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PAGE_INCOMPLETE,
"第三方分页条数不完整:" + items.size() + "/" + total);
}
}
return items;
}
private JSONObject call(String path, JSONObject payload) {
EnergyMeterProperties.Provider provider = properties.getProvider();
if (StringUtils.isBlank(provider.getApiKey())) {
throw new MeterProviderException("NO_API_KEY",
"未配置第三方授权码(环境变量 NH_ENERGY_API_KEY),无法获取真实用量");
}
String url = joinUrl(provider.getBaseUrl(), path);
String body;
HttpResponse response = null;
try {
throttle(provider.getMinIntervalMs());
response = HttpRequest.post(url)
.header("API_KEY", provider.getApiKey())
.contentType("application/json")
.body(payload.toJSONString())
.timeout(provider.getReadTimeoutSeconds() * 1000)
.setConnectionTimeout(provider.getConnectTimeoutSeconds() * 1000)
.execute();
int status = response.getStatus();
if (status == 429) {
throw new MeterProviderException("RATE_LIMITED", "第三方接口限流(429),请降低采集频率后重试");
}
if (status >= 400) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_UPSTREAM,
"第三方接口返回状态码:" + status + "(" + path + ")");
}
body = response.body();
} catch (MeterProviderException e) {
throw e;
} catch (HttpException e) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_TIMEOUT,
"第三方接口请求超时或网络异常:" + path, e);
} catch (Exception e) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_UPSTREAM,
"第三方接口调用失败:" + path, e);
} finally {
if (response != null) {
response.close();
}
}
if (StringUtils.isBlank(body)) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "第三方响应为空");
}
Object parsed;
try {
parsed = JSON.parse(body);
} catch (Exception e) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "第三方响应不是合法 JSON", e);
}
JSONObject root;
if (parsed instanceof JSONArray array) {
root = new JSONObject();
root.put("list", array);
} else if (parsed instanceof JSONObject object) {
root = object;
} else {
throw new MeterProviderException(EnergyMeterConstants.ERROR_PARSE, "第三方响应结构无法识别");
}
checkBusinessError(root);
return root;
}
private void checkBusinessError(JSONObject root) {
Boolean success = null;
for (String key : new String[]{"success", "Success"}) {
if (root.containsKey(key)) {
success = root.getBoolean(key);
break;
}
}
Integer code = null;
for (String key : new String[]{"code", "Code", "errcode", "errCode", "status"}) {
if (root.containsKey(key)) {
code = root.getInteger(key);
break;
}
}
String message = firstString(root, "msg", "message", "Message", "errmsg", "error", "Error");
if (Boolean.FALSE.equals(success)) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_UPSTREAM,
"第三方返回失败:" + StringUtils.defaultString(message, "未知原因"));
}
if (code != null && code != 0 && code != 200 && code != 1) {
throw new MeterProviderException(EnergyMeterConstants.ERROR_UPSTREAM,
"第三方返回错误码 " + code + ":" + StringUtils.defaultString(message, "未知原因"));
}
}
private JSONArray findArray(JSONObject root) {
if (root == null) {
return null;
}
for (String key : new String[]{"list", "data", "result", "rows", "records", "items", "List", "Data"}) {
Object value = root.get(key);
if (value instanceof JSONArray array) {
return array;
}
if (value instanceof JSONObject object) {
JSONArray nested = findArray(object);
if (nested != null) {
return nested;
}
}
}
return null;
}
private String joinUrl(String baseUrl, String path) {
String base = StringUtils.trim(baseUrl);
if (StringUtils.isBlank(base)) {
throw new MeterProviderException("CONFIG_ERROR", "未配置第三方基础地址 energy-meter.provider.base-url");
}
while (base.endsWith("/")) {
base = base.substring(0, base.length() - 1);
}
return base + path;
}
/* ------------------------------------------------------------------ */
/* 演示数据 */
/* ------------------------------------------------------------------ */
private MeterArchive mockArchive(String meterType, String address) {
boolean water = EnergyMeterConstants.isWater(meterType);
MeterArchive archive = new MeterArchive();
archive.setMeterType(meterType);
archive.setMeterAddress(address);
archive.setProviderMeterId("MOCK-" + Integer.toHexString(Math.abs(address.hashCode())).toUpperCase());
archive.setProviderName((water ? "演示水表 " : "演示电表 ") + address);
archive.setAreaName("演示区域");
archive.setOnlineStatus(1);
archive.setStateText("在线");
return archive;
}
private List mockUsage(String meterType, String address, LocalDate start, LocalDate end) {
List points = new ArrayList<>();
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1)) {
MeterUsagePoint point = new MeterUsagePoint();
point.setTime(date.atStartOfDay());
point.setValue(mockDailyValue(meterType, address, date));
point.setAddress(address);
point.setRawTime(date.toString());
points.add(point);
}
return points;
}
private List mockQuarterUsage(String address, LocalDate start, LocalDate end) {
List points = new ArrayList<>();
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1)) {
BigDecimal daily = mockDailyValue(EnergyMeterConstants.TYPE_ELECTRIC, address, date);
BigDecimal quarterBase = daily.divide(BigDecimal.valueOf(96), 6, RoundingMode.HALF_UP);
for (int index = 1; index <= 96; index++) {
LocalDateTime time = date.atStartOfDay().plusMinutes(index * 15L);
// 白天负荷高、夜间负荷低,保证曲线稳定且可重复
double hour = (index * 15.0) / 60.0;
double shape = 0.45 + 0.75 * Math.sin(Math.PI * Math.min(Math.max((hour - 6) / 16.0, 0), 1));
BigDecimal active = quarterBase.multiply(BigDecimal.valueOf(shape))
.setScale(3, RoundingMode.HALF_UP);
MeterQuarterPoint point = new MeterQuarterPoint();
point.setTime(time);
point.setActive(active);
point.setReactive(active.multiply(BigDecimal.valueOf(0.18)).setScale(3, RoundingMode.HALF_UP));
point.setActiveReading(BigDecimal.valueOf(MOCK_ELECTRIC_BASE.doubleValue())
.add(daily.multiply(BigDecimal.valueOf(index / 96.0))).setScale(3, RoundingMode.HALF_UP));
point.setReactiveReading(point.getActiveReading().multiply(BigDecimal.valueOf(0.18))
.setScale(3, RoundingMode.HALF_UP));
point.setAddress(address);
point.setRawTime(time.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm")));
points.add(point);
}
}
return points;
}
private List mockReadings(String meterType, String address, LocalDate start, LocalDate end) {
boolean water = EnergyMeterConstants.isWater(meterType);
BigDecimal base = water ? MOCK_WATER_BASE : MOCK_ELECTRIC_BASE;
List points = new ArrayList<>();
for (LocalDate date = start; !date.isAfter(end); date = date.plusDays(1)) {
BigDecimal cumulative = base;
for (LocalDate cursor = MOCK_READING_EPOCH; !cursor.isAfter(date); cursor = cursor.plusDays(1)) {
cumulative = cumulative.add(mockDailyValue(meterType, address, cursor));
}
MeterReadingPoint point = new MeterReadingPoint();
point.setTime(date.atStartOfDay());
point.setReading(cumulative.setScale(3, RoundingMode.HALF_UP));
point.setUsage(mockDailyValue(meterType, address, date));
point.setAddress(address);
point.setRawTime(date.toString());
points.add(point);
}
return points;
}
/**
* 演示用量:同一设备同一日期恒定,保证重复查表结果一致(便于验证幂等)。
*/
private BigDecimal mockDailyValue(String meterType, String address, LocalDate date) {
boolean water = EnergyMeterConstants.isWater(meterType);
long seed = Math.abs(Objects.hash(address, date.toString()));
double seasonal = 1 + 0.16 * Math.sin((date.getDayOfYear() - 80) / 365.0 * 2 * Math.PI);
double base = water ? 3.2 : 55.0;
double variance = water ? 1.6 : 30.0;
double value = (base + (seed % 1000) / 1000.0 * variance) * seasonal;
return BigDecimal.valueOf(value).setScale(3, RoundingMode.HALF_UP);
}
/* ------------------------------------------------------------------ */
/* 解析工具 */
/* ------------------------------------------------------------------ */
private String firstString(JSONObject object, String... keys) {
if (object == null) {
return null;
}
for (String key : keys) {
Object value = object.get(key);
if (value != null && StringUtils.isNotBlank(String.valueOf(value))) {
return String.valueOf(value).trim();
}
}
return null;
}
private BigDecimal firstDecimal(JSONObject object, String... keys) {
if (object == null) {
return null;
}
for (String key : keys) {
Object value = object.get(key);
if (value == null) {
continue;
}
try {
return new BigDecimal(String.valueOf(value).trim());
} catch (NumberFormatException ignored) {
// 继续尝试下一个候选字段
}
}
return null;
}
private Long firstLong(JSONObject object, String... keys) {
BigDecimal value = firstDecimal(object, keys);
return value == null ? null : value.longValue();
}
private int firstInt(JSONObject object, int defaultValue, String... keys) {
BigDecimal value = firstDecimal(object, keys);
return value == null ? defaultValue : value.intValue();
}
private Integer parseOnline(String state) {
if (StringUtils.isBlank(state)) {
return null;
}
String normalized = state.trim();
if ("1".equals(normalized) || "true".equalsIgnoreCase(normalized)
|| normalized.contains("在线") || "on".equalsIgnoreCase(normalized)) {
return 1;
}
if ("0".equals(normalized) || "false".equalsIgnoreCase(normalized)
|| normalized.contains("离线") || "off".equalsIgnoreCase(normalized)) {
return 0;
}
return null;
}
private LocalDateTime parseDateTime(String raw) {
if (StringUtils.isBlank(raw)) {
return null;
}
String text = raw.trim();
for (DateTimeFormatter formatter : DATE_TIME_FORMATS) {
try {
if (text.length() <= 10) {
return LocalDate.parse(text, formatter).atStartOfDay();
}
return LocalDateTime.parse(text, formatter);
} catch (DateTimeParseException ignored) {
// 尝试下一种格式
}
}
return null;
}
}