4g挂牌对接，可以接收到 心跳日志， 上传的音频文件 ，保存到数据库和本地文件

src/main/java/com/rj/service/impl/YhyAudioUploadLogServiceImpl.java

@@ -0,0 +1,227 @@
+package com.rj.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.rj.entity.YhyAudioUploadLog;
+import com.rj.mapper.YhyAudioUploadLogMapper;
+import com.rj.service.IYhyAudioUploadLogService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * <p>
+ * 音频上传日志表 服务实现类
+ * </p>
+ *
+ * @author Auto Generated
+ * @since 2025-01-29
+ */
+@Slf4j
+@Service
+public class YhyAudioUploadLogServiceImpl extends ServiceImpl<YhyAudioUploadLogMapper, YhyAudioUploadLog> implements IYhyAudioUploadLogService {
+
+    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    @Override
+    public Map<String, Object> getYhyAudioUploadLogList(Integer current, Integer size, String deviceNo,
+                                                       String startTime, String endTime,
+                                                       String createStartTime, String createEndTime) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            Page<YhyAudioUploadLog> page = new Page<>(current, size);
+            LambdaQueryWrapper<YhyAudioUploadLog> queryWrapper = buildQueryWrapper(
+                    deviceNo, startTime, endTime, createStartTime, createEndTime);
+
+            Page<YhyAudioUploadLog> yhyAudioUploadLogPage = this.page(page, queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", yhyAudioUploadLogPage.getRecords());
+            result.put("total", yhyAudioUploadLogPage.getTotal());
+            result.put("current", yhyAudioUploadLogPage.getCurrent());
+            result.put("size", yhyAudioUploadLogPage.getSize());
+            result.put("pages", yhyAudioUploadLogPage.getPages());
+        } catch (Exception e) {
+            log.error("查询音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getYhyAudioUploadLogById(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            YhyAudioUploadLog yhyAudioUploadLog = this.getById(id);
+            if (yhyAudioUploadLog != null) {
+                result.put("success", true);
+                result.put("message", "查询成功");
+                result.put("data", yhyAudioUploadLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "音频上传日志不存在");
+            }
+        } catch (Exception e) {
+            log.error("查询音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getYhyAudioUploadLogByDeviceNo(String deviceNo) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            LambdaQueryWrapper<YhyAudioUploadLog> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(YhyAudioUploadLog::getDeviceNo, deviceNo);
+            queryWrapper.orderByDesc(YhyAudioUploadLog::getCreateTime);
+
+            List<YhyAudioUploadLog> yhyAudioUploadLogs = this.list(queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", yhyAudioUploadLogs);
+            result.put("count", yhyAudioUploadLogs.size());
+        } catch (Exception e) {
+            log.error("查询音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> addYhyAudioUploadLog(YhyAudioUploadLog yhyAudioUploadLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            LocalDateTime now = LocalDateTime.now();
+            if (yhyAudioUploadLog.getId() == null || yhyAudioUploadLog.getId().trim().isEmpty()) {
+                yhyAudioUploadLog.setId(UUID.randomUUID().toString());
+            }
+            yhyAudioUploadLog.setCreateTime(now);
+            yhyAudioUploadLog.setUpdateTime(now);
+
+            boolean success = this.save(yhyAudioUploadLog);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "音频上传日志添加成功");
+                result.put("data", yhyAudioUploadLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "音频上传日志添加失败");
+            }
+        } catch (Exception e) {
+            log.error("添加音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "添加异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> updateYhyAudioUploadLog(YhyAudioUploadLog yhyAudioUploadLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            if (yhyAudioUploadLog.getId() == null || yhyAudioUploadLog.getId().trim().isEmpty()) {
+                result.put("success", false);
+                result.put("message", "音频上传日志ID不能为空");
+                return result;
+            }
+
+            yhyAudioUploadLog.setUpdateTime(LocalDateTime.now());
+            boolean success = this.updateById(yhyAudioUploadLog);
+
+            if (success) {
+                result.put("success", true);
+                result.put("message", "音频上传日志信息更新成功");
+                result.put("data", yhyAudioUploadLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "音频上传日志信息更新失败");
+            }
+        } catch (Exception e) {
+            log.error("更新音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "更新异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> deleteYhyAudioUploadLog(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            boolean success = this.removeById(id);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "音频上传日志删除成功");
+            } else {
+                result.put("success", false);
+                result.put("message", "音频上传日志删除失败");
+            }
+        } catch (Exception e) {
+            log.error("删除音频上传日志异常", e);
+            result.put("success", false);
+            result.put("message", "删除异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    /**
+     * 构建查询条件
+     */
+    private LambdaQueryWrapper<YhyAudioUploadLog> buildQueryWrapper(String deviceNo, String startTime,
+                                                                   String endTime, String createStartTime,
+                                                                   String createEndTime) {
+        LambdaQueryWrapper<YhyAudioUploadLog> queryWrapper = new LambdaQueryWrapper<>();
+
+        // 添加设备号查询条件
+        if (deviceNo != null && !deviceNo.trim().isEmpty()) {
+            queryWrapper.eq(YhyAudioUploadLog::getDeviceNo, deviceNo.trim());
+        }
+
+        // 添加开始时间范围查询条件（start_time字段是varchar类型，存储格式：251129185131）
+        if (startTime != null && !startTime.trim().isEmpty()) {
+            queryWrapper.ge(YhyAudioUploadLog::getStartTime, startTime.trim());
+        }
+        if (endTime != null && !endTime.trim().isEmpty()) {
+            queryWrapper.le(YhyAudioUploadLog::getEndTime, endTime.trim());
+        }
+
+        // 添加创建时间范围查询条件
+        if (createStartTime != null && !createStartTime.trim().isEmpty()) {
+            try {
+                LocalDateTime startDateTime = LocalDateTime.parse(createStartTime, DATE_TIME_FORMATTER);
+                queryWrapper.ge(YhyAudioUploadLog::getCreateTime, startDateTime);
+            } catch (Exception e) {
+                log.warn("创建开始时间格式错误: {}", createStartTime);
+                throw new IllegalArgumentException("创建开始时间格式错误，请使用格式：yyyy-MM-dd HH:mm:ss");
+            }
+        }
+        if (createEndTime != null && !createEndTime.trim().isEmpty()) {
+            try {
+                LocalDateTime endDateTime = LocalDateTime.parse(createEndTime, DATE_TIME_FORMATTER);
+                queryWrapper.le(YhyAudioUploadLog::getCreateTime, endDateTime);
+            } catch (Exception e) {
+                log.warn("创建结束时间格式错误: {}", createEndTime);
+                throw new IllegalArgumentException("创建结束时间格式错误，请使用格式：yyyy-MM-dd HH:mm:ss");
+            }
+        }
+
+        // 按创建时间倒序排列
+        queryWrapper.orderByDesc(YhyAudioUploadLog::getCreateTime);
+
+        return queryWrapper;
+    }
+}
+

src/main/java/com/rj/service/impl/YhyDatatypeLogServiceImpl.java

@@ -0,0 +1,224 @@
+package com.rj.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.rj.entity.YhyDatatypeLog;
+import com.rj.mapper.YhyDatatypeLogMapper;
+import com.rj.service.IYhyDatatypeLogService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.rj.common.TimeZoneUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * <p>
+ * 心跳日志表 服务实现类
+ * </p>
+ *
+ * @author Auto Generated
+ * @since 2025-01-01
+ */
+@Slf4j
+@Service
+public class YhyDatatypeLogServiceImpl extends ServiceImpl<YhyDatatypeLogMapper, YhyDatatypeLog> implements IYhyDatatypeLogService {
+
+    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    @Override
+    public Map<String, Object> getYhyDatatypeLogList(Integer current, Integer size, String deviceNo,
+                                                      String dataType, String createStartTime, String createEndTime) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            Page<YhyDatatypeLog> page = new Page<>(current, size);
+            LambdaQueryWrapper<YhyDatatypeLog> queryWrapper = buildQueryWrapper(
+                    deviceNo, dataType, createStartTime, createEndTime);
+
+            Page<YhyDatatypeLog> yhyDatatypeLogPage = this.page(page, queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", yhyDatatypeLogPage.getRecords());
+            result.put("total", yhyDatatypeLogPage.getTotal());
+            result.put("current", yhyDatatypeLogPage.getCurrent());
+            result.put("size", yhyDatatypeLogPage.getSize());
+            result.put("pages", yhyDatatypeLogPage.getPages());
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getYhyDatatypeLogById(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            YhyDatatypeLog yhyDatatypeLog = this.getById(id);
+            if (yhyDatatypeLog != null) {
+                result.put("success", true);
+                result.put("message", "查询成功");
+                result.put("data", yhyDatatypeLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志不存在");
+            }
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getYhyDatatypeLogByDeviceNo(String deviceNo) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            LambdaQueryWrapper<YhyDatatypeLog> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(YhyDatatypeLog::getDeviceNo, deviceNo);
+            queryWrapper.orderByDesc(YhyDatatypeLog::getCreateTime);
+
+            List<YhyDatatypeLog> yhyDatatypeLogs = this.list(queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", yhyDatatypeLogs);
+            result.put("count", yhyDatatypeLogs.size());
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> addYhyDatatypeLog(YhyDatatypeLog yhyDatatypeLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            // 使用配置的时区获取当前时间
+            LocalDateTime now = TimeZoneUtils.now();
+            if (yhyDatatypeLog.getId() == null || yhyDatatypeLog.getId().trim().isEmpty()) {
+                yhyDatatypeLog.setId(UUID.randomUUID().toString());
+            }
+            yhyDatatypeLog.setCreateTime(now);
+            yhyDatatypeLog.setUpdateTime(now);
+
+            boolean success = this.save(yhyDatatypeLog);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志添加成功");
+                result.put("data", yhyDatatypeLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志添加失败");
+            }
+        } catch (Exception e) {
+            log.error("添加心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "添加异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> updateYhyDatatypeLog(YhyDatatypeLog yhyDatatypeLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            if (yhyDatatypeLog.getId() == null || yhyDatatypeLog.getId().trim().isEmpty()) {
+                result.put("success", false);
+                result.put("message", "心跳日志ID不能为空");
+                return result;
+            }
+
+            // 使用配置的时区获取当前时间
+            yhyDatatypeLog.setUpdateTime(TimeZoneUtils.now());
+            boolean success = this.updateById(yhyDatatypeLog);
+
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志信息更新成功");
+                result.put("data", yhyDatatypeLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志信息更新失败");
+            }
+        } catch (Exception e) {
+            log.error("更新心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "更新异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> deleteYhyDatatypeLog(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            boolean success = this.removeById(id);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志删除成功");
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志删除失败");
+            }
+        } catch (Exception e) {
+            log.error("删除心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "删除异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    /**
+     * 构建查询条件
+     */
+    private LambdaQueryWrapper<YhyDatatypeLog> buildQueryWrapper(String deviceNo, String dataType,
+                                                                  String createStartTime, String createEndTime) {
+        LambdaQueryWrapper<YhyDatatypeLog> queryWrapper = new LambdaQueryWrapper<>();
+
+        // 添加查询条件
+        if (deviceNo != null && !deviceNo.trim().isEmpty()) {
+            queryWrapper.eq(YhyDatatypeLog::getDeviceNo, deviceNo.trim());
+        }
+        if (dataType != null && !dataType.trim().isEmpty()) {
+            queryWrapper.eq(YhyDatatypeLog::getDataType, dataType.trim());
+        }
+
+        // 添加创建时间范围查询条件
+        if (createStartTime != null && !createStartTime.trim().isEmpty()) {
+            try {
+                LocalDateTime startTime = LocalDateTime.parse(createStartTime, DATE_TIME_FORMATTER);
+                queryWrapper.ge(YhyDatatypeLog::getCreateTime, startTime);
+            } catch (Exception e) {
+                log.warn("创建开始时间格式错误: {}", createStartTime);
+                throw new IllegalArgumentException("创建开始时间格式错误，请使用格式：yyyy-MM-dd HH:mm:ss");
+            }
+        }
+        if (createEndTime != null && !createEndTime.trim().isEmpty()) {
+            try {
+                LocalDateTime endTime = LocalDateTime.parse(createEndTime, DATE_TIME_FORMATTER);
+                queryWrapper.le(YhyDatatypeLog::getCreateTime, endTime);
+            } catch (Exception e) {
+                log.warn("创建结束时间格式错误: {}", createEndTime);
+                throw new IllegalArgumentException("创建结束时间格式错误，请使用格式：yyyy-MM-dd HH:mm:ss");
+            }
+        }
+
+        // 按创建时间倒序排列
+        queryWrapper.orderByDesc(YhyDatatypeLog::getCreateTime);
+
+        return queryWrapper;
+    }
+
+}
+

src/main/java/com/rj/service/impl/YhyHeartbeatLogServiceImpl.java

@@ -0,0 +1,499 @@
+package com.rj.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.rj.entity.YhyHeartbeatLog;
+import com.rj.mapper.YhyHeartbeatLogMapper;
+import com.rj.service.IYhyHeartbeatLogService;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import java.time.LocalDateTime;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import com.rj.common.TimeZoneUtils;
+
+/**
+ * <p>
+ * 心跳日志表 服务实现类
+ * </p>
+ *
+ * @author Auto Generated
+ * @since 2025-01-01
+ */
+@Slf4j
+@Service
+public class YhyHeartbeatLogServiceImpl extends ServiceImpl<YhyHeartbeatLogMapper, YhyHeartbeatLog> implements IYhyHeartbeatLogService {
+
+    private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    @Autowired
+    private ObjectMapper objectMapper;
+
+    @Override
+    public Map<String, Object> getHeartbeatLogList(Integer current, Integer size, String deviceNo,
+                                                    String deviceStatus, Boolean powerStatus,
+                                                    String heartbeatStartTime, String heartbeatEndTime,
+                                                    String createStartTime, String createEndTime) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            Page<YhyHeartbeatLog> page = new Page<>(current, size);
+            LambdaQueryWrapper<YhyHeartbeatLog> queryWrapper = buildQueryWrapper(
+                    deviceNo, deviceStatus, powerStatus, heartbeatStartTime, heartbeatEndTime,
+                    createStartTime, createEndTime);
+
+            Page<YhyHeartbeatLog> heartbeatLogPage = this.page(page, queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", heartbeatLogPage.getRecords());
+            result.put("total", heartbeatLogPage.getTotal());
+            result.put("current", heartbeatLogPage.getCurrent());
+            result.put("size", heartbeatLogPage.getSize());
+            result.put("pages", heartbeatLogPage.getPages());
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getHeartbeatLogById(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            YhyHeartbeatLog heartbeatLog = this.getById(id);
+            if (heartbeatLog != null) {
+                result.put("success", true);
+                result.put("message", "查询成功");
+                result.put("data", heartbeatLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志不存在");
+            }
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> getHeartbeatLogByDeviceNo(String deviceNo) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            LambdaQueryWrapper<YhyHeartbeatLog> queryWrapper = new LambdaQueryWrapper<>();
+            queryWrapper.eq(YhyHeartbeatLog::getDeviceNo, deviceNo);
+            queryWrapper.orderByDesc(YhyHeartbeatLog::getCreateTime);
+
+            List<YhyHeartbeatLog> heartbeatLogs = this.list(queryWrapper);
+
+            result.put("success", true);
+            result.put("message", "查询成功");
+            result.put("data", heartbeatLogs);
+            result.put("count", heartbeatLogs.size());
+        } catch (Exception e) {
+            log.error("查询心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "查询异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> addHeartbeatLog(YhyHeartbeatLog heartbeatLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            LocalDateTime now = TimeZoneUtils.now();
+            if (heartbeatLog.getId() == null || heartbeatLog.getId().trim().isEmpty()) {
+                heartbeatLog.setId(UUID.randomUUID().toString());
+            }
+            heartbeatLog.setCreateTime(now);
+            heartbeatLog.setUpdateTime(now);
+
+            boolean success = this.save(heartbeatLog);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志添加成功");
+                result.put("data", heartbeatLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志添加失败");
+            }
+        } catch (Exception e) {
+            log.error("添加心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "添加异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> updateHeartbeatLog(YhyHeartbeatLog heartbeatLog) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            if (heartbeatLog.getId() == null || heartbeatLog.getId().trim().isEmpty()) {
+                result.put("success", false);
+                result.put("message", "心跳日志ID不能为空");
+                return result;
+            }
+
+            heartbeatLog.setUpdateTime(TimeZoneUtils.now());
+            boolean success = this.updateById(heartbeatLog);
+
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志信息更新成功");
+                result.put("data", heartbeatLog);
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志信息更新失败");
+            }
+        } catch (Exception e) {
+            log.error("更新心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "更新异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> deleteHeartbeatLog(String id) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            boolean success = this.removeById(id);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志删除成功");
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志删除失败");
+            }
+        } catch (Exception e) {
+            log.error("删除心跳日志异常", e);
+            result.put("success", false);
+            result.put("message", "删除异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> processHeartbeatReport(Map<String, Object> requestData) {
+        Map<String, Object> result = new HashMap<>();
+        try {
+            YhyHeartbeatLog heartbeatLog = new YhyHeartbeatLog();
+            heartbeatLog.setId(UUID.randomUUID().toString());
+
+            // 设置数据类型（从顶层获取，如果没有则使用默认值）
+            String dataType = (String) requestData.get("dataType");
+            if (dataType == null || dataType.trim().isEmpty()) {
+                dataType = "HeartbeatLog";
+            }
+            heartbeatLog.setDataType(dataType);
+
+            // 从顶层获取时间戳
+            Object timeStampObj = requestData.get("timeStamp");
+            if (timeStampObj != null) {
+                heartbeatLog.setTimeStamp(parseDateTime(timeStampObj));
+            }
+
+            // 提取 data 对象（大部分字段在 data 对象内）
+            @SuppressWarnings("unchecked")
+            Map<String, Object> dataMap = (Map<String, Object>) requestData.get("data");
+            
+            // 如果存在 data 对象，优先从 data 中提取字段；否则从顶层提取（保持向后兼容）
+            Map<String, Object> sourceMap = dataMap != null ? dataMap : requestData;
+
+            // 提取设备号（必需字段）- 优先从 data 中获取，如果没有则从顶层获取
+            String deviceNo = null;
+            if (dataMap != null && dataMap.containsKey("deviceNo")) {
+                deviceNo = (String) dataMap.get("deviceNo");
+            }
+            if (deviceNo == null || deviceNo.trim().isEmpty()) {
+                deviceNo = (String) requestData.get("deviceNo");
+            }
+            if (deviceNo == null || deviceNo.trim().isEmpty()) {
+                result.put("success", false);
+                result.put("message", "设备号不能为空");
+                return result;
+            }
+            heartbeatLog.setDeviceNo(deviceNo);
+
+            // 提取设备状态
+            heartbeatLog.setDeviceStatus((String) sourceMap.get("deviceStatus"));
+
+            // 提取电源状态
+            Object powerStatusObj = sourceMap.get("powerStatus");
+            if (powerStatusObj != null) {
+                if (powerStatusObj instanceof Boolean) {
+                    heartbeatLog.setPowerStatus((Boolean) powerStatusObj);
+                } else if (powerStatusObj instanceof Number) {
+                    heartbeatLog.setPowerStatus(((Number) powerStatusObj).intValue() == 1);
+                } else if (powerStatusObj instanceof String) {
+                    heartbeatLog.setPowerStatus("1".equals(powerStatusObj) || "true".equalsIgnoreCase((String) powerStatusObj));
+                }
+            }
+
+            // 提取剩余电量
+            Object remainPowerObj = sourceMap.get("remainPower");
+            if (remainPowerObj != null) {
+                if (remainPowerObj instanceof Number) {
+                    heartbeatLog.setRemainPower(((Number) remainPowerObj).intValue());
+                } else if (remainPowerObj instanceof String) {
+                    try {
+                        heartbeatLog.setRemainPower(Integer.parseInt((String) remainPowerObj));
+                    } catch (NumberFormatException e) {
+                        log.warn("剩余电量格式错误: {}", remainPowerObj);
+                    }
+                }
+            }
+
+            // 提取剩余存储空间
+            Object remainStorageSizeObj = sourceMap.get("remainStorageSize");
+            if (remainStorageSizeObj != null) {
+                if (remainStorageSizeObj instanceof Number) {
+                    heartbeatLog.setRemainStorageSize(((Number) remainStorageSizeObj).longValue());
+                } else if (remainStorageSizeObj instanceof String) {
+                    try {
+                        heartbeatLog.setRemainStorageSize(Long.parseLong((String) remainStorageSizeObj));
+                    } catch (NumberFormatException e) {
+                        log.warn("剩余存储空间格式错误: {}", remainStorageSizeObj);
+                    }
+                }
+            }
+
+            // 提取心跳时间
+            Object heartbeatTimeObj = sourceMap.get("heartbeatTime");
+            if (heartbeatTimeObj != null) {
+                heartbeatLog.setHeartbeatTime(parseDateTime(heartbeatTimeObj));
+            }
+
+            // 提取设备版本
+            heartbeatLog.setDeviceVer((String) sourceMap.get("deviceVer"));
+
+            // 提取扩展信息
+            Object extendObj = sourceMap.get("extend");
+            if (extendObj != null) {
+                try {
+                    heartbeatLog.setExtend(objectMapper.writeValueAsString(extendObj));
+                } catch (Exception e) {
+                    log.warn("序列化extend字段失败", e);
+                    heartbeatLog.setExtend(extendObj.toString());
+                }
+            }
+
+            // 提取主体信息
+            Object bodyObj = sourceMap.get("body");
+            if (bodyObj != null) {
+                try {
+                    heartbeatLog.setBody(objectMapper.writeValueAsString(bodyObj));
+                } catch (Exception e) {
+                    log.warn("序列化body字段失败", e);
+                    heartbeatLog.setBody(bodyObj.toString());
+                }
+            }
+
+            // 提取数据创建时间
+            Object createdTimeObj = sourceMap.get("createdTime");
+            if (createdTimeObj != null) {
+                heartbeatLog.setCreatedTime(parseDateTime(createdTimeObj));
+            }
+
+            // 设置系统创建和更新时间
+            LocalDateTime now = TimeZoneUtils.now();
+            heartbeatLog.setCreateTime(now);
+            heartbeatLog.setUpdateTime(now);
+
+            // 保存到数据库
+            boolean success = this.save(heartbeatLog);
+            if (success) {
+                result.put("success", true);
+                result.put("message", "心跳日志处理成功");
+                result.put("data", heartbeatLog);
+                log.info("心跳日志保存成功，ID: {}, 设备号: {}, 心跳时间: {}", 
+                        heartbeatLog.getId(), heartbeatLog.getDeviceNo(), heartbeatLog.getHeartbeatTime());
+            } else {
+                result.put("success", false);
+                result.put("message", "心跳日志保存失败");
+            }
+        } catch (Exception e) {
+            log.error("处理心跳上报数据异常", e);
+            result.put("success", false);
+            result.put("message", "处理异常：" + e.getMessage());
+        }
+        return result;
+    }
+
+    /**
+     * 解析日期时间
+     * 支持多种时间格式：
+     * - 2025-11-30T09:27:32.3963139
+     * - 2025-11-30T09:27:32.3963443+08:00
+     * - 2025-11-30T01:27:32Z
+     * - 2025-11-30 09:27:32
+     */
+    private LocalDateTime parseDateTime(Object dateTimeObj) {
+        if (dateTimeObj == null) {
+            return null;
+        }
+        if (dateTimeObj instanceof LocalDateTime) {
+            return (LocalDateTime) dateTimeObj;
+        }
+        if (dateTimeObj instanceof String) {
+            String dateTimeStr = (String) dateTimeObj;
+            if (dateTimeStr.trim().isEmpty()) {
+                return null;
+            }
+            
+            try {
+                // 检测是否包含时区信息：以Z结尾，或包含时区偏移格式（+HH:MM 或 -HH:MM）
+                boolean hasTimezone = dateTimeStr.endsWith("Z") || 
+                                     dateTimeStr.matches(".*[+-]\\d{2}:\\d{2}(?:\\d{2})?$");
+                
+                if (hasTimezone) {
+                    // 处理ISO 8601格式，包含时区信息
+                    ZonedDateTime zonedDateTime;
+                    if (dateTimeStr.endsWith("Z")) {
+                        // UTC时间，转换为应用配置的时区
+                        zonedDateTime = ZonedDateTime.parse(dateTimeStr.replace("Z", "+00:00"))
+                                .withZoneSameInstant(TimeZoneUtils.getZoneId());
+                    } else {
+                        // 带时区偏移的时间，转换为应用配置的时区
+                        zonedDateTime = ZonedDateTime.parse(dateTimeStr)
+                                .withZoneSameInstant(TimeZoneUtils.getZoneId());
+                    }
+                    return zonedDateTime.toLocalDateTime();
+                } else {
+                    // 没有时区信息，尝试多种格式解析
+                    // 首先尝试标准格式：yyyy-MM-dd HH:mm:ss
+                    try {
+                        return LocalDateTime.parse(dateTimeStr, DATE_TIME_FORMATTER);
+                    } catch (Exception e1) {
+                        // 尝试ISO格式（不带时区）：2025-11-30T09:27:32.3963139
+                        try {
+                            // 如果有小数点，可能需要处理微秒
+                            if (dateTimeStr.contains(".")) {
+                                String cleanTimeStr = dateTimeStr;
+                                // 移除微秒部分（如果超过6位）
+                                int dotIndex = cleanTimeStr.indexOf(".");
+                                if (dotIndex > 0) {
+                                    String beforeDot = cleanTimeStr.substring(0, dotIndex);
+                                    String afterDot = cleanTimeStr.substring(dotIndex + 1);
+                                    // 如果小数点后有超过9位数字，截取前9位（纳秒精度）
+                                    if (afterDot.length() > 9) {
+                                        afterDot = afterDot.substring(0, 9);
+                                    }
+                                    // 补齐到9位（纳秒）
+                                    while (afterDot.length() < 9) {
+                                        afterDot += "0";
+                                    }
+                                    cleanTimeStr = beforeDot + "." + afterDot;
+                                }
+                                return LocalDateTime.parse(cleanTimeStr);
+                            } else {
+                                return LocalDateTime.parse(dateTimeStr);
+                            }
+                        } catch (Exception e2) {
+                            // 最后尝试：移除T并格式化
+                            try {
+                                String cleanTimeStr = dateTimeStr;
+                                if (cleanTimeStr.contains("T")) {
+                                    cleanTimeStr = cleanTimeStr.replace("T", " ");
+                                }
+                                if (cleanTimeStr.contains(".")) {
+                                    cleanTimeStr = cleanTimeStr.substring(0, cleanTimeStr.indexOf("."));
+                                }
+                                if (cleanTimeStr.length() > 19) {
+                                    cleanTimeStr = cleanTimeStr.substring(0, 19);
+                                }
+                                return LocalDateTime.parse(cleanTimeStr, DATE_TIME_FORMATTER);
+                            } catch (Exception e3) {
+                                log.warn("日期时间格式错误，无法解析: {}", dateTimeStr);
+                                return null;
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.warn("解析日期时间失败: {}, 错误: {}", dateTimeStr, e.getMessage());
+                return null;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 构建查询条件
+     */
+    private LambdaQueryWrapper<YhyHeartbeatLog> buildQueryWrapper(String deviceNo, String deviceStatus,
+                                                                   Boolean powerStatus, String heartbeatStartTime,
+                                                                   String heartbeatEndTime, String createStartTime,
+                                                                   String createEndTime) {
+        LambdaQueryWrapper<YhyHeartbeatLog> queryWrapper = new LambdaQueryWrapper<>();
+
+        // 添加设备号查询条件
+        if (deviceNo != null && !deviceNo.trim().isEmpty()) {
+            queryWrapper.eq(YhyHeartbeatLog::getDeviceNo, deviceNo.trim());
+        }
+
+        // 添加设备状态查询条件
+        if (deviceStatus != null && !deviceStatus.trim().isEmpty()) {
+            queryWrapper.eq(YhyHeartbeatLog::getDeviceStatus, deviceStatus.trim());
+        }
+
+        // 添加电源状态查询条件
+        if (powerStatus != null) {
+            queryWrapper.eq(YhyHeartbeatLog::getPowerStatus, powerStatus);
+        }
+
+        // 添加心跳时间范围查询条件
+        if (heartbeatStartTime != null && !heartbeatStartTime.trim().isEmpty()) {
+            try {
+                LocalDateTime startTime = LocalDateTime.parse(heartbeatStartTime, DATE_TIME_FORMATTER);
+                queryWrapper.ge(YhyHeartbeatLog::getHeartbeatTime, startTime);
+            } catch (Exception e) {
+                log.warn("心跳开始时间格式错误: {}", heartbeatStartTime);
+            }
+        }
+        if (heartbeatEndTime != null && !heartbeatEndTime.trim().isEmpty()) {
+            try {
+                LocalDateTime endTime = LocalDateTime.parse(heartbeatEndTime, DATE_TIME_FORMATTER);
+                queryWrapper.le(YhyHeartbeatLog::getHeartbeatTime, endTime);
+            } catch (Exception e) {
+                log.warn("心跳结束时间格式错误: {}", heartbeatEndTime);
+            }
+        }
+
+        // 添加创建时间范围查询条件
+        if (createStartTime != null && !createStartTime.trim().isEmpty()) {
+            try {
+                LocalDateTime startTime = LocalDateTime.parse(createStartTime, DATE_TIME_FORMATTER);
+                queryWrapper.ge(YhyHeartbeatLog::getCreateTime, startTime);
+            } catch (Exception e) {
+                log.warn("创建开始时间格式错误: {}", createStartTime);
+            }
+        }
+        if (createEndTime != null && !createEndTime.trim().isEmpty()) {
+            try {
+                LocalDateTime endTime = LocalDateTime.parse(createEndTime, DATE_TIME_FORMATTER);
+                queryWrapper.le(YhyHeartbeatLog::getCreateTime, endTime);
+            } catch (Exception e) {
+                log.warn("创建结束时间格式错误: {}", createEndTime);
+            }
+        }
+
+        // 按创建时间倒序排列
+        queryWrapper.orderByDesc(YhyHeartbeatLog::getCreateTime);
+
+        return queryWrapper;
+    }
+}