package com.ruoyi.energymeter.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.StringUtils;
|
import com.ruoyi.energymeter.constant.EnergyMeterConstants;
|
import com.ruoyi.energymeter.dto.EnergyMeterDeviceQuery;
|
import com.ruoyi.energymeter.dto.MeterArchive;
|
import com.ruoyi.energymeter.dto.MeterBindRequest;
|
import com.ruoyi.energymeter.dto.MeterManualBindRequest;
|
import com.ruoyi.energymeter.dto.MeterReadingRequest;
|
import com.ruoyi.energymeter.dto.MeterUpdateRequest;
|
import com.ruoyi.energymeter.dto.MeterUsageRow;
|
import com.ruoyi.energymeter.mapper.EnergyMeterDeviceMapper;
|
import com.ruoyi.energymeter.mapper.EnergyMeterMeasurementMapper;
|
import com.ruoyi.energymeter.mapper.EnergyMeterSyncTaskMapper;
|
import com.ruoyi.energymeter.pojo.EnergyMeterDevice;
|
import com.ruoyi.energymeter.pojo.EnergyMeterMeasurement;
|
import com.ruoyi.energymeter.pojo.EnergyMeterSyncTask;
|
import com.ruoyi.energymeter.provider.MeterProviderClient;
|
import com.ruoyi.energymeter.service.EnergyMeterDeviceService;
|
import com.ruoyi.energymeter.service.EnergyMeterSyncService;
|
import com.ruoyi.energymeter.util.EnergyMeterSupport;
|
import com.ruoyi.energymeter.vo.MeterArchiveVO;
|
import com.ruoyi.energymeter.vo.MeterReadingResultVO;
|
import lombok.RequiredArgsConstructor;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.util.ArrayList;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Set;
|
import java.util.stream.Collectors;
|
|
/**
|
* 能耗表设备服务实现：第三方接入设备 + 手工抄表设备。
|
*/
|
@Slf4j
|
@Service
|
@RequiredArgsConstructor
|
public class EnergyMeterDeviceServiceImpl extends ServiceImpl<EnergyMeterDeviceMapper, EnergyMeterDevice>
|
implements EnergyMeterDeviceService {
|
|
private final EnergyMeterDeviceMapper deviceMapper;
|
private final EnergyMeterMeasurementMapper measurementMapper;
|
private final EnergyMeterSyncTaskMapper taskMapper;
|
private final MeterProviderClient provider;
|
private final EnergyMeterSyncService syncService;
|
|
@Override
|
public IPage<EnergyMeterDevice> pageDevices(Page<EnergyMeterDevice> page, EnergyMeterDeviceQuery query) {
|
LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
|
Long tenantId = EnergyMeterSupport.currentTenantId();
|
if (tenantId != null) {
|
wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
|
}
|
if (query != null) {
|
if (StringUtils.isNotBlank(query.getMeterType())) {
|
wrapper.eq(EnergyMeterDevice::getMeterType, normalizeType(query.getMeterType()));
|
}
|
if (StringUtils.isNotBlank(query.getSourceType())) {
|
wrapper.eq(EnergyMeterDevice::getSourceType, query.getSourceType().trim().toUpperCase());
|
}
|
if (StringUtils.isNotBlank(query.getMeterAddress())) {
|
wrapper.eq(EnergyMeterDevice::getMeterAddress, query.getMeterAddress().trim());
|
}
|
if (query.getEnabled() != null) {
|
wrapper.eq(EnergyMeterDevice::getEnabled, query.getEnabled());
|
}
|
if (query.getSimulated() != null) {
|
wrapper.eq(EnergyMeterDevice::getSimulated, query.getSimulated());
|
}
|
if (StringUtils.isNotBlank(query.getCollectionMode())) {
|
String mode = query.getCollectionMode().trim().toUpperCase();
|
if ("AUTO".equals(mode)) {
|
// 第三方接入 + 系统每日自动生成，都属于自动采集
|
wrapper.and(w -> w.eq(EnergyMeterDevice::getSourceType,
|
EnergyMeterConstants.SOURCE_TYPE_PROVIDER)
|
.or().eq(EnergyMeterDevice::getSimulated, 1));
|
} else if ("MANUAL".equals(mode)) {
|
wrapper.eq(EnergyMeterDevice::getSourceType, EnergyMeterConstants.SOURCE_TYPE_MANUAL)
|
.eq(EnergyMeterDevice::getSimulated, 0);
|
}
|
}
|
if (StringUtils.isNotBlank(query.getBindStatus())) {
|
wrapper.eq(EnergyMeterDevice::getBindStatus, query.getBindStatus());
|
}
|
if (StringUtils.isNotBlank(query.getKeyword())) {
|
String keyword = query.getKeyword().trim();
|
wrapper.and(w -> w.like(EnergyMeterDevice::getDisplayName, keyword)
|
.or().like(EnergyMeterDevice::getProviderName, keyword)
|
.or().like(EnergyMeterDevice::getMeterAddress, keyword));
|
}
|
}
|
wrapper.orderByAsc(EnergyMeterDevice::getMeterType)
|
.orderByDesc(EnergyMeterDevice::getIsSeed)
|
.orderByAsc(EnergyMeterDevice::getId);
|
IPage<EnergyMeterDevice> result = deviceMapper.selectPage(page, wrapper);
|
enrichDevices(result.getRecords());
|
return result;
|
}
|
|
@Override
|
public List<EnergyMeterDevice> listDeviceOptions(String meterType) {
|
LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
|
Long tenantId = EnergyMeterSupport.currentTenantId();
|
if (tenantId != null) {
|
wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
|
}
|
if (StringUtils.isNotBlank(meterType)) {
|
wrapper.eq(EnergyMeterDevice::getMeterType, normalizeType(meterType));
|
}
|
wrapper.eq(EnergyMeterDevice::getEnabled, 1)
|
.eq(EnergyMeterDevice::getBindStatus, EnergyMeterConstants.BIND_VERIFIED)
|
.orderByAsc(EnergyMeterDevice::getId);
|
return deviceMapper.selectList(wrapper);
|
}
|
|
@Override
|
public MeterArchiveVO verifyArchive(String meterType, String meterAddress) {
|
String normalizedType = normalizeType(meterType);
|
String address = StringUtils.trim(meterAddress);
|
if (StringUtils.isBlank(address)) {
|
throw new ServiceException("通信地址不能为空");
|
}
|
MeterArchive archive = provider.queryArchive(normalizedType, address);
|
MeterArchiveVO vo = new MeterArchiveVO();
|
vo.setMeterType(normalizedType);
|
vo.setMeterAddress(address);
|
vo.setProviderMeterId(archive.getProviderMeterId());
|
vo.setProviderName(archive.getProviderName());
|
vo.setAreaId(archive.getAreaId());
|
vo.setAreaName(archive.getAreaName());
|
vo.setOnlineStatus(archive.getOnlineStatus());
|
vo.setParentProviderId(archive.getParentProviderId());
|
vo.setMockMode(provider.mockMode());
|
|
EnergyMeterDevice existing = findBinding(normalizedType, address);
|
if (existing == null) {
|
vo.setBindable(true);
|
vo.setMessage("验证通过，可新增绑定");
|
} else {
|
vo.setExistingDeviceId(existing.getId());
|
vo.setExistingEnabled(Integer.valueOf(1).equals(existing.getEnabled()));
|
boolean enabled = Integer.valueOf(1).equals(existing.getEnabled());
|
vo.setBindable(!enabled);
|
vo.setMessage(enabled
|
? "该通信地址已在本地绑定，请勿重复新增"
|
: "该地址已存在停用设备，确认后将重新启用并补采停用期间数据");
|
}
|
return vo;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public EnergyMeterDevice bind(MeterBindRequest request) {
|
String normalizedType = normalizeType(request.getMeterType());
|
String address = StringUtils.trim(request.getMeterAddress());
|
if (StringUtils.isBlank(address)) {
|
throw new ServiceException("通信地址不能为空");
|
}
|
MeterArchive archive = provider.queryArchive(normalizedType, address);
|
EnergyMeterDevice existing = findBinding(normalizedType, address);
|
if (existing != null && Integer.valueOf(1).equals(existing.getEnabled())) {
|
throw new ServiceException("该通信地址已在本地绑定，请勿重复新增");
|
}
|
if (existing != null && EnergyMeterConstants.isManual(existing.getSourceType())) {
|
throw new ServiceException("该表号已用于手工抄表设备，请先删除原设备或改用其他表号");
|
}
|
LocalDate yesterday = EnergyMeterSupport.today().minusDays(1);
|
// 采集起点由系统自动确定：已停用设备沿用原起点，新设备默认上一自然年 1 月 1 日
|
LocalDate startDate = resolveStartDate(null,
|
existing != null ? existing.getSyncStartDate() : null, yesterday);
|
|
EnergyMeterDevice device = existing == null ? new EnergyMeterDevice() : existing;
|
device.setMeterType(normalizedType);
|
device.setSourceType(EnergyMeterConstants.SOURCE_TYPE_PROVIDER);
|
device.setMeterAddress(address);
|
device.setProviderMeterId(archive.getProviderMeterId());
|
device.setProviderName(archive.getProviderName());
|
device.setProviderAreaId(archive.getAreaId());
|
device.setProviderAreaName(archive.getAreaName());
|
device.setParentProviderId(archive.getParentProviderId());
|
device.setOnlineStatus(archive.getOnlineStatus());
|
device.setBindStatus(EnergyMeterConstants.BIND_VERIFIED);
|
device.setEnabled(1);
|
device.setSyncStartDate(startDate);
|
device.setDisplayName(StringUtils.isNotBlank(request.getDisplayName())
|
? request.getDisplayName().trim()
|
: StringUtils.defaultIfBlank(archive.getProviderName(), address));
|
device.setLocation(StringUtils.defaultIfBlank(request.getLocation(), device.getLocation()));
|
if (device.getIsSeed() == null) {
|
device.setIsSeed(0);
|
}
|
if (existing == null) {
|
deviceMapper.insert(device);
|
} else {
|
deviceMapper.updateById(device);
|
}
|
log.info("能耗表绑定成功 meterId={} type={} address={}", device.getId(), normalizedType, address);
|
|
try {
|
syncService.triggerBackfill(device, startDate, yesterday);
|
} catch (Exception e) {
|
log.warn("绑定成功但历史补采批次创建失败 meterId={}: {}", device.getId(), e.getMessage());
|
}
|
return device;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public EnergyMeterDevice addManual(MeterManualBindRequest request) {
|
String type = normalizeType(request.getMeterType());
|
String address = StringUtils.trim(request.getMeterAddress());
|
if (StringUtils.isBlank(address)) {
|
throw new ServiceException("表号不能为空");
|
}
|
if (request.getInitialReading() == null) {
|
throw new ServiceException("起始表码不能为空");
|
}
|
if (request.getInitialReading().signum() < 0) {
|
throw new ServiceException("起始表码不能为负数");
|
}
|
LocalDate today = EnergyMeterSupport.today();
|
LocalDate initialDate = request.getInitialReadingDate() == null ? today : request.getInitialReadingDate();
|
if (initialDate.isAfter(today)) {
|
throw new ServiceException("起始表码日期不能晚于今天");
|
}
|
|
EnergyMeterDevice existing = findBinding(type, address);
|
if (existing != null) {
|
if (Integer.valueOf(1).equals(existing.getEnabled())) {
|
throw new ServiceException("该表号已存在有效的" + EnergyMeterConstants.typeName(type) + "设备，请勿重复新增");
|
}
|
if (!EnergyMeterConstants.isManual(existing.getSourceType())) {
|
throw new ServiceException("该表号已被第三方接入设备占用，请先停用原设备或改用其他表号");
|
}
|
}
|
|
EnergyMeterDevice device = existing == null ? new EnergyMeterDevice() : existing;
|
device.setMeterType(type);
|
device.setSourceType(EnergyMeterConstants.SOURCE_TYPE_MANUAL);
|
device.setMeterAddress(address);
|
device.setDisplayName(StringUtils.isNotBlank(request.getDisplayName())
|
? request.getDisplayName().trim()
|
: address);
|
device.setLocation(StringUtils.defaultIfBlank(request.getLocation(), device.getLocation()));
|
device.setBindStatus(EnergyMeterConstants.BIND_VERIFIED);
|
device.setEnabled(1);
|
device.setIsSeed(0);
|
device.setInitialReading(request.getInitialReading());
|
device.setInitialReadingDate(initialDate);
|
device.setSyncStartDate(initialDate);
|
device.setOnlineStatus(null);
|
device.setLastErrorCode(null);
|
device.setLastErrorMessage(null);
|
if (existing == null) {
|
deviceMapper.insert(device);
|
} else {
|
deviceMapper.updateById(device);
|
}
|
|
// 起始表码作为基准记录写入，不计入用量
|
EnergyMeterMeasurement basePoint = newManualPoint(device, initialDate.atStartOfDay(),
|
request.getInitialReading(), "起始表码");
|
measurementMapper.upsertBatch(List.of(basePoint));
|
deviceMapper.markCollectSuccess(device.getId(), EnergyMeterSupport.now());
|
log.info("新增手工抄表设备 meterId={} type={} address={} initial={}",
|
device.getId(), type, address, request.getInitialReading());
|
return deviceMapper.selectById(device.getId());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void removeDevice(Long id) {
|
EnergyMeterDevice device = getOwnedDevice(id);
|
if (Integer.valueOf(1).equals(device.getIsSeed())) {
|
throw new ServiceException("初始化设备不允许删除，如需停用请编辑设备状态");
|
}
|
if (!EnergyMeterConstants.isManual(device.getSourceType())) {
|
throw new ServiceException("第三方接入设备请使用“停用”，不允许删除");
|
}
|
measurementMapper.delete(new LambdaQueryWrapper<EnergyMeterMeasurement>()
|
.eq(EnergyMeterMeasurement::getMeterId, id));
|
removeById(id);
|
log.info("删除手工抄表设备 meterId={} address={}", id, device.getMeterAddress());
|
}
|
|
@Override
|
public IPage<EnergyMeterMeasurement> pageReadings(Long meterId, long current, long size) {
|
EnergyMeterDevice device = getOwnedDevice(meterId);
|
String readingMetric = EnergyMeterConstants.readingMetric(device.getMeterType());
|
String usageMetric = EnergyMeterConstants.usageMetric(device.getMeterType());
|
long safeSize = Math.min(Math.max(size, 1), 200);
|
Page<EnergyMeterMeasurement> page = new Page<>(Math.max(current, 1), safeSize);
|
LambdaQueryWrapper<EnergyMeterMeasurement> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(EnergyMeterMeasurement::getMeterId, device.getId())
|
.eq(EnergyMeterMeasurement::getMetricCode, readingMetric)
|
.eq(EnergyMeterMeasurement::getGranularity, EnergyMeterConstants.GRANULARITY_POINT)
|
.orderByDesc(EnergyMeterMeasurement::getMeasureTime)
|
.orderByDesc(EnergyMeterMeasurement::getId);
|
IPage<EnergyMeterMeasurement> result = measurementMapper.selectPage(page, wrapper);
|
|
List<EnergyMeterMeasurement> records = result.getRecords();
|
if (!records.isEmpty()) {
|
LocalDateTime maxTime = records.get(0).getMeasureTime();
|
LocalDateTime minTime = records.get(records.size() - 1).getMeasureTime();
|
List<EnergyMeterMeasurement> usages = measurementMapper.selectList(
|
new LambdaQueryWrapper<EnergyMeterMeasurement>()
|
.eq(EnergyMeterMeasurement::getMeterId, device.getId())
|
.eq(EnergyMeterMeasurement::getMetricCode, usageMetric)
|
.eq(EnergyMeterMeasurement::getGranularity, EnergyMeterConstants.GRANULARITY_DAY)
|
.ge(EnergyMeterMeasurement::getMeasureTime, minTime)
|
.le(EnergyMeterMeasurement::getMeasureTime, maxTime));
|
Map<LocalDate, BigDecimal> usageMap = new HashMap<>();
|
for (EnergyMeterMeasurement usage : usages) {
|
usageMap.put(usage.getMeasureTime().toLocalDate(), usage.getMetricValue());
|
}
|
for (EnergyMeterMeasurement record : records) {
|
record.setUsageValue(usageMap.get(record.getMeasureTime().toLocalDate()));
|
record.setMeterName(device.getDisplayName());
|
record.setMeterType(device.getMeterType());
|
record.setMeterAddress(device.getMeterAddress());
|
}
|
}
|
return result;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public MeterReadingResultVO addReading(Long meterId, MeterReadingRequest request) {
|
EnergyMeterDevice device = requireManualDevice(meterId);
|
if (request.getReadingDate() == null) {
|
throw new ServiceException("抄表日期不能为空");
|
}
|
if (request.getReadingValue() == null) {
|
throw new ServiceException("本次表码不能为空");
|
}
|
LocalDate date = request.getReadingDate();
|
LocalDate today = EnergyMeterSupport.today();
|
if (date.isAfter(today)) {
|
throw new ServiceException("抄表日期不能晚于今天");
|
}
|
if (device.getInitialReadingDate() != null && date.isBefore(device.getInitialReadingDate())) {
|
throw new ServiceException("抄表日期不能早于起始表码日期（"
|
+ device.getInitialReadingDate() + "）");
|
}
|
BigDecimal value = request.getReadingValue();
|
if (value.signum() < 0) {
|
throw new ServiceException("本次表码不能为负数");
|
}
|
|
BigDecimal previous = resolvePreviousReading(device, date.atStartOfDay());
|
if (previous != null && value.compareTo(previous) < 0) {
|
throw new ServiceException("本次表码不能小于上期表码（上期 " + previous.stripTrailingZeros().toPlainString() + "）");
|
}
|
|
EnergyMeterMeasurement point = newManualPoint(device, date.atStartOfDay(), value,
|
StringUtils.defaultIfBlank(request.getRemark(), null));
|
measurementMapper.upsertBatch(List.of(point));
|
|
BigDecimal usage = previous == null ? null : value.subtract(previous);
|
upsertUsage(device, date, usage);
|
|
// 若该日期之后已有抄表，重新计算下一期的用量
|
EnergyMeterMeasurement next = measurementMapper.selectNextPoint(device.getId(),
|
EnergyMeterConstants.readingMetric(device.getMeterType()), date.atStartOfDay());
|
if (next != null) {
|
recalcUsage(device, next);
|
}
|
deviceMapper.markCollectSuccess(device.getId(), EnergyMeterSupport.now());
|
|
MeterReadingResultVO result = new MeterReadingResultVO();
|
result.setMeterId(device.getId());
|
result.setMeasureTime(date.atStartOfDay());
|
result.setReadingValue(value);
|
result.setPreviousReading(previous);
|
result.setUsage(usage);
|
result.setUnit(EnergyMeterConstants.unit(device.getMeterType()));
|
return result;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void removeReading(Long meterId, Long measurementId) {
|
EnergyMeterDevice device = requireManualDevice(meterId);
|
EnergyMeterMeasurement record = measurementMapper.selectById(measurementId);
|
if (record == null || !meterId.equals(record.getMeterId())) {
|
throw new ServiceException("抄表记录不存在");
|
}
|
if (!EnergyMeterConstants.GRANULARITY_POINT.equals(record.getGranularity())) {
|
throw new ServiceException("只能删除抄表记录");
|
}
|
if (device.getInitialReadingDate() != null
|
&& device.getInitialReadingDate().equals(record.getMeasureTime().toLocalDate())) {
|
throw new ServiceException("起始表码不允许删除，如需修改请编辑设备");
|
}
|
|
EnergyMeterMeasurement next = measurementMapper.selectNextPoint(device.getId(),
|
EnergyMeterConstants.readingMetric(device.getMeterType()), record.getMeasureTime());
|
measurementMapper.deleteById(measurementId);
|
deleteUsage(device, record.getMeasureTime().toLocalDate());
|
if (next != null) {
|
recalcUsage(device, next);
|
}
|
log.info("删除抄表记录 meterId={} measurementId={} date={}",
|
meterId, measurementId, record.getMeasureTime().toLocalDate());
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public EnergyMeterDevice updateLocal(Long id, MeterUpdateRequest request) {
|
EnergyMeterDevice device = getOwnedDevice(id);
|
LambdaUpdateWrapper<EnergyMeterDevice> wrapper = new LambdaUpdateWrapper<>();
|
wrapper.eq(EnergyMeterDevice::getId, id);
|
if (request.getDisplayName() != null) {
|
if (StringUtils.isBlank(request.getDisplayName())) {
|
throw new ServiceException("显示名称不能为空");
|
}
|
wrapper.set(EnergyMeterDevice::getDisplayName, request.getDisplayName().trim());
|
}
|
if (request.getLocation() != null) {
|
wrapper.set(EnergyMeterDevice::getLocation, request.getLocation());
|
}
|
boolean reEnabled = false;
|
if (request.getEnabled() != null) {
|
if (request.getEnabled() != 0 && request.getEnabled() != 1) {
|
throw new ServiceException("启停用参数不合法");
|
}
|
reEnabled = request.getEnabled() == 1 && !Integer.valueOf(1).equals(device.getEnabled());
|
wrapper.set(EnergyMeterDevice::getEnabled, request.getEnabled());
|
}
|
deviceMapper.update(null, wrapper);
|
EnergyMeterDevice updated = getOwnedDevice(id);
|
if (reEnabled && !EnergyMeterConstants.isManual(updated.getSourceType())) {
|
try {
|
syncService.triggerBackfillGap(updated);
|
} catch (Exception e) {
|
log.warn("设备启用成功但补采批次创建失败 meterId={}: {}", id, e.getMessage());
|
}
|
}
|
enrichDevices(List.of(updated));
|
return updated;
|
}
|
|
@Override
|
public EnergyMeterDevice getOwnedDevice(Long id) {
|
EnergyMeterDevice device = deviceMapper.selectById(id);
|
if (device == null) {
|
throw new ServiceException("设备不存在或已删除");
|
}
|
Long tenantId = EnergyMeterSupport.currentTenantId();
|
if (tenantId != null && device.getTenantId() != null && !tenantId.equals(device.getTenantId())) {
|
throw new ServiceException("无权访问该设备");
|
}
|
return device;
|
}
|
|
@Override
|
public List<EnergyMeterDevice> listEnabledDevices(String meterType) {
|
LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
|
Long tenantId = EnergyMeterSupport.currentTenantId();
|
if (tenantId != null) {
|
wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
|
}
|
if (StringUtils.isNotBlank(meterType)) {
|
wrapper.eq(EnergyMeterDevice::getMeterType, normalizeType(meterType));
|
}
|
wrapper.eq(EnergyMeterDevice::getEnabled, 1)
|
.eq(EnergyMeterDevice::getBindStatus, EnergyMeterConstants.BIND_VERIFIED)
|
.orderByAsc(EnergyMeterDevice::getId);
|
return deviceMapper.selectList(wrapper);
|
}
|
|
@Override
|
public boolean mockMode() {
|
return provider.mockMode();
|
}
|
|
/* ------------------------------------------------------------------ */
|
|
/**
|
* 计算指定日期之前的上一期表码：优先取抄表记录，其次取设备起始表码。
|
*/
|
private BigDecimal resolvePreviousReading(EnergyMeterDevice device, LocalDateTime time) {
|
EnergyMeterMeasurement previous = measurementMapper.selectPreviousPoint(device.getId(),
|
EnergyMeterConstants.readingMetric(device.getMeterType()), time);
|
if (previous != null) {
|
return previous.getMetricValue();
|
}
|
return device.getInitialReading();
|
}
|
|
/**
|
* 重算某条抄表记录对应的日用量（在插入/删除其它抄表记录后调用）。
|
*/
|
private void recalcUsage(EnergyMeterDevice device, EnergyMeterMeasurement point) {
|
BigDecimal previous = resolvePreviousReading(device, point.getMeasureTime());
|
if (previous == null) {
|
deleteUsage(device, point.getMeasureTime().toLocalDate());
|
return;
|
}
|
upsertUsage(device, point.getMeasureTime().toLocalDate(), point.getMetricValue().subtract(previous));
|
}
|
|
private void upsertUsage(EnergyMeterDevice device, LocalDate date, BigDecimal usage) {
|
if (usage == null) {
|
return;
|
}
|
EnergyMeterMeasurement record = new EnergyMeterMeasurement();
|
record.setTenantId(device.getTenantId());
|
record.setMeterId(device.getId());
|
record.setMetricCode(EnergyMeterConstants.usageMetric(device.getMeterType()));
|
record.setGranularity(EnergyMeterConstants.GRANULARITY_DAY);
|
record.setMeasureTime(date.atStartOfDay());
|
record.setMetricValue(usage);
|
record.setUnit(EnergyMeterConstants.unit(device.getMeterType()));
|
record.setSourceApi(EnergyMeterConstants.SOURCE_MANUAL);
|
record.setSourceRecordTime(date.atStartOfDay());
|
record.setCollectedAt(EnergyMeterSupport.now());
|
measurementMapper.upsertBatch(List.of(record));
|
}
|
|
private void deleteUsage(EnergyMeterDevice device, LocalDate date) {
|
measurementMapper.delete(new LambdaQueryWrapper<EnergyMeterMeasurement>()
|
.eq(EnergyMeterMeasurement::getMeterId, device.getId())
|
.eq(EnergyMeterMeasurement::getMetricCode, EnergyMeterConstants.usageMetric(device.getMeterType()))
|
.eq(EnergyMeterMeasurement::getGranularity, EnergyMeterConstants.GRANULARITY_DAY)
|
.eq(EnergyMeterMeasurement::getMeasureTime, date.atStartOfDay()));
|
}
|
|
private EnergyMeterMeasurement newManualPoint(EnergyMeterDevice device, LocalDateTime time,
|
BigDecimal value, String remark) {
|
EnergyMeterMeasurement point = new EnergyMeterMeasurement();
|
point.setTenantId(device.getTenantId());
|
point.setMeterId(device.getId());
|
point.setMetricCode(EnergyMeterConstants.readingMetric(device.getMeterType()));
|
point.setGranularity(EnergyMeterConstants.GRANULARITY_POINT);
|
point.setMeasureTime(time);
|
point.setMetricValue(value);
|
point.setUnit(EnergyMeterConstants.unit(device.getMeterType()));
|
point.setSourceApi(EnergyMeterConstants.SOURCE_MANUAL);
|
point.setSourceRecordTime(time);
|
point.setCollectedAt(EnergyMeterSupport.now());
|
point.setRemark(remark);
|
return point;
|
}
|
|
private EnergyMeterDevice requireManualDevice(Long meterId) {
|
EnergyMeterDevice device = getOwnedDevice(meterId);
|
if (!EnergyMeterConstants.isManual(device.getSourceType())) {
|
throw new ServiceException("该设备为第三方接入，请使用“查表”获取数据");
|
}
|
return device;
|
}
|
|
private void enrichDevices(List<EnergyMeterDevice> devices) {
|
if (devices == null || devices.isEmpty()) {
|
return;
|
}
|
List<Long> ids = devices.stream().map(EnergyMeterDevice::getId).collect(Collectors.toList());
|
Map<Long, EnergyMeterSyncTask> latestTask = new HashMap<>();
|
for (EnergyMeterSyncTask task : taskMapper.selectLatestByMeterIds(ids)) {
|
latestTask.put(task.getMeterId(), task);
|
}
|
LocalDate yesterday = EnergyMeterSupport.today().minusDays(1);
|
LocalDateTime start = yesterday.atStartOfDay();
|
LocalDateTime end = yesterday.plusDays(1).atStartOfDay();
|
|
Map<Long, BigDecimal> usageMap = new HashMap<>();
|
Set<String> types = devices.stream().map(EnergyMeterDevice::getMeterType)
|
.filter(StringUtils::isNotBlank).collect(Collectors.toSet());
|
for (String type : types) {
|
List<Long> typeIds = devices.stream()
|
.filter(d -> type.equals(d.getMeterType()))
|
.map(EnergyMeterDevice::getId).collect(Collectors.toList());
|
if (typeIds.isEmpty()) {
|
continue;
|
}
|
for (MeterUsageRow row : measurementMapper.sumUsageByMeter(typeIds,
|
EnergyMeterConstants.usageMetric(type), start, end)) {
|
usageMap.put(row.getMeterId(), row.getTotal());
|
}
|
}
|
|
for (EnergyMeterDevice device : devices) {
|
boolean manual = EnergyMeterConstants.isManual(device.getSourceType());
|
EnergyMeterSyncTask task = latestTask.get(device.getId());
|
if (task != null) {
|
device.setLastTaskStatus(task.getStatus());
|
device.setLastTaskTime(task.getFinishedAt() != null ? task.getFinishedAt() : task.getStartedAt());
|
}
|
BigDecimal dayUsage = usageMap.get(device.getId());
|
if (dayUsage != null) {
|
device.setLastDayUsage(dayUsage);
|
device.setLastDayUsageDate(yesterday);
|
} else {
|
// 昨天没有用量时（手工抄表按抄表期入账、第三方设备可能只有当天数据），
|
// 退回最近一条用量及其业务日期，避免列表长期显示 "--"
|
EnergyMeterMeasurement latestUsage = measurementMapper.selectLatestPoint(device.getId(),
|
EnergyMeterConstants.usageMetric(device.getMeterType()));
|
if (latestUsage != null) {
|
device.setLastDayUsage(latestUsage.getMetricValue());
|
device.setLastDayUsageDate(latestUsage.getMeasureTime().toLocalDate());
|
}
|
}
|
EnergyMeterMeasurement latest = measurementMapper.selectLatestPoint(device.getId(),
|
EnergyMeterConstants.readingMetric(device.getMeterType()));
|
if (latest != null) {
|
device.setLatestReading(latest.getMetricValue());
|
EnergyMeterMeasurement previous = measurementMapper.selectPreviousPoint(device.getId(),
|
EnergyMeterConstants.readingMetric(device.getMeterType()), latest.getMeasureTime());
|
if (previous != null) {
|
device.setPreviousReading(previous.getMetricValue());
|
} else if (device.getLastDayUsage() != null) {
|
// 只有一条读数时（新装表第一天），用“最新表码 - 当期用量”反推上期表码
|
device.setPreviousReading(latest.getMetricValue().subtract(device.getLastDayUsage()));
|
}
|
}
|
device.setCollectStateText(buildCollectState(device, task));
|
device.setMeterTypeName(EnergyMeterConstants.typeName(device.getMeterType()));
|
device.setSourceTypeName(EnergyMeterConstants.isAutoCollect(device.getSourceType(), device.getSimulated())
|
? "自动采集" : "手工抄表");
|
device.setUnit(EnergyMeterConstants.unit(device.getMeterType()));
|
device.setDeletable(!Integer.valueOf(1).equals(device.getIsSeed()) && manual);
|
}
|
}
|
|
private String buildCollectState(EnergyMeterDevice device, EnergyMeterSyncTask task) {
|
if (EnergyMeterConstants.isSimulated(device.getSimulated())) {
|
return "自动采集";
|
}
|
if (EnergyMeterConstants.isManual(device.getSourceType())) {
|
return device.getLastSuccessAt() == null ? "尚未抄表" : "手工抄表";
|
}
|
if (task == null) {
|
return "尚未采集";
|
}
|
return switch (StringUtils.defaultString(task.getStatus())) {
|
case "SUCCESS" -> "采集成功";
|
case "EMPTY" -> "确认无数据";
|
case "FAILED" -> "采集失败";
|
case "RETRY" -> "等待重试";
|
case "RUNNING" -> "采集中";
|
default -> "待执行";
|
};
|
}
|
|
private EnergyMeterDevice findBinding(String meterType, String address) {
|
LambdaQueryWrapper<EnergyMeterDevice> wrapper = new LambdaQueryWrapper<>();
|
wrapper.eq(EnergyMeterDevice::getMeterType, meterType)
|
.eq(EnergyMeterDevice::getMeterAddress, address);
|
Long tenantId = EnergyMeterSupport.currentTenantId();
|
if (tenantId != null) {
|
wrapper.eq(EnergyMeterDevice::getTenantId, tenantId);
|
}
|
List<EnergyMeterDevice> list = deviceMapper.selectList(wrapper);
|
return list.isEmpty() ? null : list.get(0);
|
}
|
|
private LocalDate resolveStartDate(LocalDate requested, LocalDate existingStart, LocalDate yesterday) {
|
LocalDate latestAllowed = yesterday;
|
LocalDate defaultStart = LocalDate.of(latestAllowed.getYear() - 1, 1, 1);
|
LocalDate start = requested != null ? requested : (existingStart != null ? existingStart : defaultStart);
|
if (start.isAfter(latestAllowed)) {
|
throw new ServiceException("补采起始日期不能晚于昨天");
|
}
|
if (start.isBefore(LocalDate.of(2000, 1, 1))) {
|
throw new ServiceException("补采起始日期过早，请确认供应商允许的历史范围");
|
}
|
return start;
|
}
|
|
|
private String normalizeType(String meterType) {
|
String type = EnergyMeterConstants.canonicalType(meterType);
|
if (type == null) {
|
throw new ServiceException("能源类型只支持水表（WATER）、电表（ELECTRIC）或气表（GAS）");
|
}
|
return type;
|
}
|
}
|
