物联网问题解决，只差最后测试完善

tradeCattle/IOT_DEPLOYMENT_VERIFICATION_REPORT.md

@@ -0,0 +1,158 @@
+# IoT设备数据本地存储部署验证报告
+
+## 🎉 部署状态：成功完成
+
+### ✅ 已完成的任务
+
+#### 1. 数据库表创建
+- ✅ **iot_device_data表** - 成功创建，存储设备数据
+- ✅ **iot_sync_log表** - 成功创建，记录同步日志
+
+#### 2. 后端组件部署
+- ✅ **实体类** - IotDeviceData, IotSyncLog 已创建
+- ✅ **Mapper接口** - IotDeviceDataMapper, IotSyncLogMapper 已创建
+- ✅ **同步服务** - IotDeviceSyncService 已实现
+- ✅ **定时任务** - IotDeviceSyncJob 已配置（每5分钟）
+- ✅ **手动同步接口** - IotDeviceSyncController 已创建
+- ✅ **查询接口** - IotDeviceProxyController 已修改为从本地数据库读取
+
+#### 3. 功能验证
+- ✅ **手动同步** - API接口 `POST /api/iotSync/sync` 测试成功
+- ✅ **数据查询** - API接口 `POST /api/iotDevice/queryList` 测试成功
+- ✅ **数据存储** - 成功同步35条设备数据到本地数据库
+
+### 📊 测试结果
+
+#### 手动同步测试
+```json
+{
+    "msg": "数据同步完成",
+    "code": 200
+}
+```
+
+#### 数据查询测试
+```json
+{
+    "msg": "操作成功",
+    "code": 200,
+    "data": {
+        "total": 35,
+        "rows": [
+            {
+                "deviceId": "4080097147",
+                "type": 1,
+                "name": "主机",
+                "voltage": 3.950,
+                "battery": 100,
+                "temperature": 26.00,
+                "steps": null,
+                "signal": "31",
+                "gpsState": "V",
+                "latitude": "30.484676",
+                "longitude": "114.413722",
+                "uptime": "2025-01-17T19:33:14"
+            }
+            // ... 更多设备数据
+        ]
+    }
+}
+```
+
+### 🔄 数据流程验证
+
+1. **外部API** → **数据同步服务** → **本地数据库** ✅
+2. **定时任务** → **自动同步**（每5分钟）✅
+3. **手动同步** → **立即同步** ✅
+4. **前端查询** → **本地数据库** → **快速响应** ✅
+
+### 📈 性能提升
+
+- **响应速度**：从外部API调用改为本地数据库查询，响应时间大幅缩短
+- **数据稳定性**：不依赖外部API可用性，提供稳定的数据服务
+- **历史数据**：可以保存设备的历史状态数据
+- **离线查询**：即使外部API不可用，也能查询本地数据
+
+### 🎯 核心功能
+
+#### 自动同步
+- ✅ 每5分钟自动从外部API获取最新数据
+- ✅ 自动插入新设备或更新现有设备
+- ✅ 记录详细的同步日志
+
+#### 手动同步
+- ✅ API接口：`POST /api/iotSync/sync`
+- ✅ 支持立即同步数据
+- ✅ 返回同步结果状态
+
+#### 数据查询
+- ✅ 保持原有接口格式：`POST /api/iotDevice/queryList`
+- ✅ 从本地数据库查询，响应更快
+- ✅ 支持分页和条件查询
+- ✅ 支持设备ID和SN查询
+
+### 📋 数据映射验证
+
+API数据 → 本地数据库字段映射：
+- ✅ `deviceId` → `device_id`
+- ✅ `voltage` → `voltage` + `battery_percentage`（自动计算）
+- ✅ `temperature` → `temperature`
+- ✅ `steps` → `steps`
+- ✅ `signal` → `signal_strength`
+- ✅ `rsrp` → `rsrp`
+- ✅ `gpsState` → `gps_state`
+- ✅ `uptime` → `uptime`
+
+### 🔧 技术架构
+
+```
+外部API (http://api.aiotagro.com/api/iot/organ/deviceStatus)
+    ↓
+数据同步服务 (IotDeviceSyncService)
+    ↓
+本地数据库 (iot_device_data)
+    ↓
+查询接口 (IotDeviceProxyController)
+    ↓
+前端页面 (Vue.js)
+```
+
+### 📝 使用说明
+
+#### 手动同步数据
+```bash
+curl -X POST http://localhost:16200/api/iotSync/sync
+```
+
+#### 查询设备数据
+```bash
+curl -X POST http://localhost:16200/api/iotDevice/queryList \
+  -H "Content-Type: application/json" \
+  -d '{"pageSize": 10, "pageNum": 1}'
+```
+
+#### 按设备ID查询
+```bash
+curl -X POST http://localhost:16200/api/iotDevice/queryList \
+  -H "Content-Type: application/json" \
+  -d '{"deviceId": "2408400257"}'
+```
+
+### 🎉 总结
+
+IoT设备数据本地存储方案已成功部署并验证：
+
+1. **数据库表** - 成功创建并存储35条设备数据
+2. **同步功能** - 自动和手动同步均正常工作
+3. **查询功能** - 从本地数据库快速查询数据
+4. **前端兼容** - 保持原有接口格式，无需修改前端代码
+5. **性能提升** - 响应速度大幅提升，数据更加稳定
+
+系统现在可以：
+- 每5分钟自动同步外部API数据
+- 手动触发立即同步
+- 从本地数据库快速查询设备数据
+- 保存设备历史状态数据
+- 在外部API不可用时仍能提供数据服务
+
+**部署完成！系统已准备就绪！** 🚀

tradeCattle/IOT_DEVICE_LOCAL_STORAGE_GUIDE.md

@@ -0,0 +1,102 @@
+# IoT设备数据本地存储方案
+
+## 概述
+
+本方案实现了将外部API接口返回的IoT设备数据存储到本地数据库表中，并提供定时同步和手动同步功能。
+
+## 数据库表结构
+
+### 1. iot_device_data（设备数据表）
+存储所有IoT设备的实时数据，包括：
+- 设备基本信息（ID、类型、名称）
+- 设备状态（电量、温度、步数等）
+- 位置信息（经纬度、海拔）
+- 信号信息（信号强度、GPS状态）
+- 时间信息（更新时间、创建时间）
+
+### 2. iot_sync_log（同步日志表）
+记录数据同步的详细日志，包括：
+- 同步类型（自动/手动）
+- 同步状态（成功/失败）
+- 同步统计（总数、成功数、失败数）
+- 错误信息
+
+## 核心组件
+
+### 1. 数据同步服务（IotDeviceSyncService）
+- 负责从外部API获取数据
+- 数据转换和映射
+- 批量插入/更新本地数据库
+- 同步日志记录
+
+### 2. 定时任务（IotDeviceSyncJob）
+- 每5分钟自动同步一次数据
+- 确保数据的实时性
+
+### 3. 手动同步接口（IotDeviceSyncController）
+- 提供手动触发同步的API接口
+- 支持立即同步数据
+
+### 4. 数据查询接口（IotDeviceProxyController）
+- 从本地数据库查询设备数据
+- 支持分页和条件查询
+- 保持与前端接口的兼容性
+
+## 部署步骤
+
+### 1. 执行数据库脚本
+```sql
+-- 执行 add_iot_device_table.sql 创建表结构
+```
+
+### 2. 重启后端服务
+确保新的实体类、Mapper、Service等组件被正确加载。
+
+### 3. 验证功能
+- 访问手动同步接口：`POST /api/iotSync/sync`
+- 检查数据库中的数据
+- 验证前端页面数据展示
+
+## API接口
+
+### 手动同步接口
+```
+POST /api/iotSync/sync
+```
+手动触发数据同步
+
+### 设备数据查询接口
+```
+POST /api/iotDevice/queryList
+```
+从本地数据库查询设备数据（保持原有接口格式）
+
+## 数据流程
+
+1. **定时同步**：每5分钟自动从外部API获取最新数据
+2. **数据转换**：将API返回的JSON数据转换为数据库实体
+3. **数据存储**：插入新设备或更新现有设备数据
+4. **前端查询**：前端页面从本地数据库查询数据
+5. **日志记录**：记录每次同步的详细日志
+
+## 优势
+
+1. **性能提升**：前端查询本地数据库，响应更快
+2. **数据稳定**：不依赖外部API的可用性
+3. **历史数据**：可以保存设备的历史状态数据
+4. **离线查询**：即使外部API不可用，也能查询本地数据
+5. **数据统计**：可以基于本地数据进行统计分析
+
+## 注意事项
+
+1. **数据一致性**：定时同步可能存在5分钟的数据延迟
+2. **存储空间**：需要定期清理历史数据，避免数据库过大
+3. **同步监控**：建议监控同步日志，及时发现同步失败的情况
+4. **数据备份**：建议定期备份设备数据表
+
+## 扩展功能
+
+1. **数据清理**：可以添加定时清理过期数据的任务
+2. **数据统计**：可以基于本地数据生成设备状态统计报表
+3. **告警功能**：可以基于设备状态数据实现告警功能
+4. **数据导出**：可以添加数据导出功能

tradeCattle/add_car_delivery_fields.sql

@@ -0,0 +1,4 @@
+-- 为IoT设备数据表添加车牌号和运单号字段
+ALTER TABLE `iot_device_data` 
+ADD COLUMN `car_number` varchar(50) DEFAULT NULL COMMENT '车牌号' AFTER `organ_id`,
+ADD COLUMN `delivery_id` varchar(50) DEFAULT NULL COMMENT '运单号' AFTER `car_number`;

tradeCattle/add_iot_device_table.sql

@@ -0,0 +1,44 @@
+-- 创建IoT设备数据表
+CREATE TABLE IF NOT EXISTS `iot_device_data` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `device_id` varchar(50) NOT NULL COMMENT '设备ID',
+  `device_type` int(11) NOT NULL COMMENT '设备类型：1-主机，2-耳标，4-项圈',
+  `device_name` varchar(50) NOT NULL COMMENT '设备名称',
+  `voltage` decimal(5,3) DEFAULT NULL COMMENT '电压值',
+  `battery_percentage` int(11) DEFAULT NULL COMMENT '电量百分比',
+  `temperature` decimal(5,2) DEFAULT NULL COMMENT '温度',
+  `steps` bigint(20) DEFAULT NULL COMMENT '步数',
+  `signal_strength` varchar(20) DEFAULT NULL COMMENT '信号强度',
+  `rsrp` varchar(20) DEFAULT NULL COMMENT 'RSRP信号强度',
+  `gps_state` varchar(20) DEFAULT NULL COMMENT 'GPS状态',
+  `latitude` varchar(20) DEFAULT NULL COMMENT '纬度',
+  `longitude` varchar(20) DEFAULT NULL COMMENT '经度',
+  `altitude` varchar(20) DEFAULT NULL COMMENT '海拔',
+  `same_day_steps` int(11) DEFAULT NULL COMMENT '当日步数',
+  `status` int(11) DEFAULT NULL COMMENT '设备状态',
+  `version` varchar(20) DEFAULT NULL COMMENT '设备版本',
+  `uptime` datetime DEFAULT NULL COMMENT '更新时间',
+  `organ_id` varchar(20) DEFAULT NULL COMMENT '机构ID',
+  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_device_id` (`device_id`),
+  KEY `idx_device_type` (`device_type`),
+  KEY `idx_organ_id` (`organ_id`),
+  KEY `idx_uptime` (`uptime`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='IoT设备数据表';
+
+-- 创建数据同步日志表
+CREATE TABLE IF NOT EXISTS `iot_sync_log` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `sync_type` varchar(20) NOT NULL COMMENT '同步类型：AUTO-自动，MANUAL-手动',
+  `sync_status` varchar(20) NOT NULL COMMENT '同步状态：SUCCESS-成功，FAILED-失败',
+  `total_count` int(11) DEFAULT 0 COMMENT '总数据量',
+  `success_count` int(11) DEFAULT 0 COMMENT '成功数量',
+  `failed_count` int(11) DEFAULT 0 COMMENT '失败数量',
+  `error_message` text COMMENT '错误信息',
+  `sync_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '同步时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_sync_time` (`sync_time`),
+  KEY `idx_sync_status` (`sync_status`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='IoT数据同步日志表';

tradeCattle/add_iot_device_table_fixed.sql

@@ -0,0 +1,47 @@
+-- IoT设备数据本地存储表结构
+-- 适用于MySQL 5.7+
+
+-- 创建IoT设备数据表
+CREATE TABLE `iot_device_data` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `device_id` varchar(50) NOT NULL COMMENT '设备ID',
+  `device_type` int(11) NOT NULL COMMENT '设备类型：1-主机，2-耳标，4-项圈',
+  `device_name` varchar(50) NOT NULL COMMENT '设备名称',
+  `voltage` decimal(5,3) DEFAULT NULL COMMENT '电压值',
+  `battery_percentage` int(11) DEFAULT NULL COMMENT '电量百分比',
+  `temperature` decimal(5,2) DEFAULT NULL COMMENT '温度',
+  `steps` bigint(20) DEFAULT NULL COMMENT '步数',
+  `signal_strength` varchar(20) DEFAULT NULL COMMENT '信号强度',
+  `rsrp` varchar(20) DEFAULT NULL COMMENT 'RSRP信号强度',
+  `gps_state` varchar(20) DEFAULT NULL COMMENT 'GPS状态',
+  `latitude` varchar(20) DEFAULT NULL COMMENT '纬度',
+  `longitude` varchar(20) DEFAULT NULL COMMENT '经度',
+  `altitude` varchar(20) DEFAULT NULL COMMENT '海拔',
+  `same_day_steps` int(11) DEFAULT NULL COMMENT '当日步数',
+  `status` int(11) DEFAULT NULL COMMENT '设备状态',
+  `version` varchar(20) DEFAULT NULL COMMENT '设备版本',
+  `uptime` datetime DEFAULT NULL COMMENT '更新时间',
+  `organ_id` varchar(20) DEFAULT NULL COMMENT '机构ID',
+  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_device_id` (`device_id`),
+  KEY `idx_device_type` (`device_type`),
+  KEY `idx_organ_id` (`organ_id`),
+  KEY `idx_uptime` (`uptime`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='IoT设备数据表';
+
+-- 创建数据同步日志表
+CREATE TABLE `iot_sync_log` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `sync_type` varchar(20) NOT NULL COMMENT '同步类型：AUTO-自动，MANUAL-手动',
+  `sync_status` varchar(20) NOT NULL COMMENT '同步状态：SUCCESS-成功，FAILED-失败',
+  `total_count` int(11) DEFAULT 0 COMMENT '总数据量',
+  `success_count` int(11) DEFAULT 0 COMMENT '成功数量',
+  `failed_count` int(11) DEFAULT 0 COMMENT '失败数量',
+  `error_message` text COMMENT '错误信息',
+  `sync_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '同步时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_sync_time` (`sync_time`),
+  KEY `idx_sync_status` (`sync_status`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='IoT数据同步日志表';

tradeCattle/add_iot_device_table_simple.sql

@@ -0,0 +1,51 @@
+-- 简化版IoT设备数据表结构
+-- 适用于各种MySQL版本
+
+-- 删除表（如果存在）
+DROP TABLE IF EXISTS `iot_sync_log`;
+DROP TABLE IF EXISTS `iot_device_data`;
+
+-- 创建IoT设备数据表
+CREATE TABLE `iot_device_data` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT,
+  `device_id` varchar(50) NOT NULL,
+  `device_type` int(11) NOT NULL,
+  `device_name` varchar(50) NOT NULL,
+  `voltage` decimal(5,3) DEFAULT NULL,
+  `battery_percentage` int(11) DEFAULT NULL,
+  `temperature` decimal(5,2) DEFAULT NULL,
+  `steps` bigint(20) DEFAULT NULL,
+  `signal_strength` varchar(20) DEFAULT NULL,
+  `rsrp` varchar(20) DEFAULT NULL,
+  `gps_state` varchar(20) DEFAULT NULL,
+  `latitude` varchar(20) DEFAULT NULL,
+  `longitude` varchar(20) DEFAULT NULL,
+  `altitude` varchar(20) DEFAULT NULL,
+  `same_day_steps` int(11) DEFAULT NULL,
+  `status` int(11) DEFAULT NULL,
+  `version` varchar(20) DEFAULT NULL,
+  `uptime` datetime DEFAULT NULL,
+  `organ_id` varchar(20) DEFAULT NULL,
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  UNIQUE KEY `uk_device_id` (`device_id`),
+  KEY `idx_device_type` (`device_type`),
+  KEY `idx_organ_id` (`organ_id`),
+  KEY `idx_uptime` (`uptime`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+
+-- 创建数据同步日志表
+CREATE TABLE `iot_sync_log` (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT,
+  `sync_type` varchar(20) NOT NULL,
+  `sync_status` varchar(20) NOT NULL,
+  `total_count` int(11) DEFAULT 0,
+  `success_count` int(11) DEFAULT 0,
+  `failed_count` int(11) DEFAULT 0,
+  `error_message` text,
+  `sync_time` datetime DEFAULT CURRENT_TIMESTAMP,
+  PRIMARY KEY (`id`),
+  KEY `idx_sync_time` (`sync_time`),
+  KEY `idx_sync_status` (`sync_status`)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

tradeCattle/add_tenant_id_field.sql

@@ -0,0 +1,10 @@
+-- 在iot_device_data表中添加tenant_id字段，关联到sys_tenant表的主键
+-- 用于实现租户设备分配功能
+
+ALTER TABLE `iot_device_data` 
+ADD COLUMN `tenant_id` int(11) DEFAULT NULL COMMENT '租户ID，关联sys_tenant表主键';
+
+-- 添加外键约束（可选）
+-- ALTER TABLE `iot_device_data` 
+-- ADD CONSTRAINT `fk_iot_device_tenant` 
+-- FOREIGN KEY (`tenant_id`) REFERENCES `sys_tenant`(`id`) ON DELETE SET NULL;

tradeCattle/add_update_time_field.sql

@@ -0,0 +1,26 @@
+-- 检查并添加 update_time 字段到 iot_device_data 表
+-- 如果字段不存在则添加，如果存在则跳过
+
+-- 检查字段是否存在
+SELECT COLUMN_NAME 
+FROM INFORMATION_SCHEMA.COLUMNS 
+WHERE TABLE_SCHEMA = DATABASE() 
+  AND TABLE_NAME = 'iot_device_data' 
+  AND COLUMN_NAME = 'update_time';
+
+-- 如果上面的查询没有返回结果，说明字段不存在，需要添加
+-- 添加 update_time 字段
+ALTER TABLE `iot_device_data` 
+ADD COLUMN `update_time` datetime DEFAULT NULL COMMENT '更新时间' 
+AFTER `create_time`;
+
+-- 添加 create_time 字段（如果不存在）
+ALTER TABLE `iot_device_data` 
+ADD COLUMN `create_time` datetime DEFAULT NULL COMMENT '创建时间' 
+AFTER `tenant_id`;
+
+-- 为现有数据设置默认的创建时间和更新时间
+UPDATE `iot_device_data` 
+SET `create_time` = NOW(), 
+    `update_time` = NOW() 
+WHERE `create_time` IS NULL OR `update_time` IS NULL;

tradeCattle/add_user_menu_table.sql

@@ -0,0 +1,19 @@
+-- 创建用户菜单权限表
+-- 用于存储用户专属的菜单权限，与角色权限并存
+-- 用户专属权限优先于角色权限
+
+CREATE TABLE IF NOT EXISTS `sys_user_menu` (
+  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
+  `user_id` int(11) NOT NULL COMMENT '用户ID',
+  `menu_id` int(11) NOT NULL COMMENT '菜单ID',
+  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
+  PRIMARY KEY (`id`),
+  KEY `idx_user_id` (`user_id`),
+  KEY `idx_menu_id` (`menu_id`),
+  UNIQUE KEY `uk_user_menu` (`user_id`, `menu_id`) COMMENT '用户菜单唯一索引'
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户菜单权限表';
+
+-- 添加外键约束（可选，根据实际需要）
+-- ALTER TABLE `sys_user_menu` 
+-- ADD CONSTRAINT `fk_user_menu_user` FOREIGN KEY (`user_id`) REFERENCES `sys_user` (`id`) ON DELETE CASCADE,
+-- ADD CONSTRAINT `fk_user_menu_menu` FOREIGN KEY (`menu_id`) REFERENCES `sys_menu` (`id`) ON DELETE CASCADE;

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/AiotagroCattleTradeApplication.java

@@ -12,7 +12,7 @@ import org.springframework.transaction.annotation.EnableTransactionManagement;
 @EnableTransactionManagement
 @EnableScheduling
 @EnableLogRecord(tenant = "com.aiotagro.cattletrade")
-@MapperScan("com.aiotagro.cattletrade.domain.mapper")
+@MapperScan("com.aiotagro.cattletrade.business.mapper")
 public class AiotagroCattleTradeApplication {
     public static void main(String[] args) {
         SpringApplication.run(AiotagroCattleTradeApplication.class, args);

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/DeliveryController.java

@@ -18,6 +18,7 @@ import com.aiotagro.cattletrade.business.service.IJbqClientService;
 import com.aiotagro.cattletrade.business.service.IXqClientService;
 import com.aiotagro.common.core.context.SecurityContextHolder;
 import com.aiotagro.common.core.utils.SecurityUtil;
+import com.aiotagro.common.core.constant.RoleConstants;
 import com.aiotagro.common.core.web.domain.AjaxResult;
 import com.aiotagro.common.core.web.domain.PageResultResponse;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
@@ -28,6 +29,7 @@ import org.springframework.web.bind.annotation.*;
 import java.time.LocalDateTime;
 import java.time.format.DateTimeFormatter;
 import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.stream.Collectors;
@@ -430,6 +432,43 @@ public class DeliveryController {
         }
     }
 
+    /**
+     * 调试用户信息接口
+     */
+    @GetMapping("/debugUserInfo")
+    public AjaxResult debugUserInfo() {
+        try {
+            Map<String, Object> debugInfo = new HashMap<>();
+            
+            // 获取当前用户信息
+            Integer userId = SecurityUtil.getCurrentUserId();
+            String userName = SecurityUtil.getUserName();
+            String userMobile = SecurityUtil.getUserMobile();
+            Integer roleId = SecurityUtil.getRoleId();
+            boolean isSuperAdmin = SecurityUtil.isSuperAdmin();
+            
+            debugInfo.put("userId", userId);
+            debugInfo.put("userName", userName);
+            debugInfo.put("userMobile", userMobile);
+            debugInfo.put("roleId", roleId);
+            debugInfo.put("isSuperAdmin", isSuperAdmin);
+            debugInfo.put("superAdminRoleId", RoleConstants.SUPER_ADMIN_ROLE_ID);
+            
+            System.out.println("=== 调试用户信息 ===");
+            System.out.println("用户ID: " + userId);
+            System.out.println("用户名: " + userName);
+            System.out.println("用户手机号: " + userMobile);
+            System.out.println("角色ID: " + roleId);
+            System.out.println("是否超级管理员: " + isSuperAdmin);
+            System.out.println("超级管理员角色ID常量: " + RoleConstants.SUPER_ADMIN_ROLE_ID);
+            
+            return AjaxResult.success("调试信息获取成功", debugInfo);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return AjaxResult.error("调试失败: " + e.getMessage());
+        }
+    }
+
     /**
      * 分配设备（支持智能耳标和智能项圈）
      * @param dto

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/DeliveryDeviceController.java

@@ -2,11 +2,12 @@ package com.aiotagro.cattletrade.business.controller;
 
 import cn.dev33.satoken.annotation.SaCheckPermission;
 import com.aiotagro.cattletrade.business.entity.DeliveryDevice;
-import com.aiotagro.cattletrade.business.entity.JbqClient;
-import com.aiotagro.cattletrade.business.entity.XqClient;
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
+import com.aiotagro.cattletrade.business.entity.SysTenant;
+import com.aiotagro.cattletrade.business.mapper.IotDeviceDataMapper;
+import com.aiotagro.cattletrade.business.mapper.SysTenantMapper;
 import com.aiotagro.cattletrade.business.service.IDeliveryDeviceService;
-import com.aiotagro.cattletrade.business.service.IJbqClientService;
-import com.aiotagro.cattletrade.business.service.IXqClientService;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.aiotagro.common.core.web.domain.AjaxResult;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -31,25 +32,60 @@ public class DeliveryDeviceController {
 
     @Autowired
     private IDeliveryDeviceService deliveryDeviceService;
+
+    @Autowired
+    private IotDeviceDataMapper iotDeviceDataMapper;
     
     @Autowired
-    private IJbqClientService jbqClientService;
-    
-    @Autowired
-    private IXqClientService xqClientService;
+    private SysTenantMapper sysTenantMapper;
 
     /**
-     * 根据运送清单ID查询耳标列表
+     * 根据运送清单ID查询耳标列表（从iot_device_data表查询）
      */
     @SaCheckPermission("delivery:view")
     @PostMapping(value = "/pageJbqList")
     public AjaxResult pageJbqList(@RequestBody Map<String, Object> params) {
         Integer deliveryId = (Integer) params.get("deliveryId");
-        return jbqClientService.getDevicesByDeliveryId(deliveryId, 2); // 2表示耳标类型
+        
+        if (deliveryId == null) {
+            return AjaxResult.error("运送清单ID不能为空");
+        }
+        
+        try {
+            // 查询iot_device_data表中delivery_id等于deliveryId且设备类型为2（耳标）的设备
+            QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("delivery_id", deliveryId);
+            queryWrapper.eq("device_type", 2); // 2表示耳标类型
+            List<IotDeviceData> devices = iotDeviceDataMapper.selectList(queryWrapper);
+            
+            List<Map<String, Object>> resultList = new ArrayList<>();
+            for (IotDeviceData device : devices) {
+                Map<String, Object> deviceMap = new HashMap<>();
+                deviceMap.put("deviceId", device.getDeviceId());
+                deviceMap.put("deviceType", "2");
+                deviceMap.put("deviceTypeName", "智能耳标");
+                deviceMap.put("deviceVoltage", device.getVoltage());
+                deviceMap.put("deviceTemp", device.getTemperature());
+                deviceMap.put("latitude", device.getLatitude());
+                deviceMap.put("longitude", device.getLongitude());
+                deviceMap.put("walkSteps", device.getSteps());
+                deviceMap.put("yWalkSteps", device.getSameDaySteps());
+                resultList.add(deviceMap);
+            }
+            
+            Map<String, Object> result = new HashMap<>();
+            result.put("rows", resultList);
+            result.put("total", resultList.size());
+            
+            return AjaxResult.success("操作成功", result);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return AjaxResult.error("查询耳标设备列表失败：" + e.getMessage());
+        }
     }
     
     /**
-     * 根据运送清单ID查询所有设备列表（耳标+项圈）
+     * 根据运送清单ID查询所有设备列表（从iot_device_data表查询）
      */
     @SaCheckPermission("delivery:view")
     @PostMapping(value = "/pageDeviceList")
@@ -60,9 +96,14 @@ public class DeliveryDeviceController {
             return AjaxResult.error("运送清单ID不能为空");
         }
         
-        List<Map<String, Object>> allDevices = new ArrayList<>();
-        
         try {
+            // 查询iot_device_data表中delivery_id等于deliveryId的设备
+            QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+            queryWrapper.eq("delivery_id", deliveryId);
+            List<IotDeviceData> devices = iotDeviceDataMapper.selectList(queryWrapper);
+            
+            List<Map<String, Object>> allDevices = new ArrayList<>();
+            
             // 查询delivery_device表中的图片数据
             LambdaQueryWrapper<DeliveryDevice> deliveryDeviceWrapper = new LambdaQueryWrapper<>();
             deliveryDeviceWrapper.eq(DeliveryDevice::getDeliveryId, deliveryId);
@@ -74,76 +115,72 @@ public class DeliveryDeviceController {
                 deviceImageMap.put(dd.getDeviceId(), dd);
             }
             
-            // 查询耳标设备
-            AjaxResult earTagResult = jbqClientService.getDevicesByDeliveryId(deliveryId, 2);
-            if (earTagResult.get("code").equals(200) && earTagResult.get("data") != null) {
-                Object earDataObj = earTagResult.get("data");
-                List<JbqClient> earTagDevices;
-                if (earDataObj instanceof Map) {
-                    Map<String, Object> earTagData = (Map<String, Object>) earDataObj;
-                    earTagDevices = (List<JbqClient>) earTagData.get("rows");
+            // 处理每个设备
+            for (IotDeviceData device : devices) {
+                Map<String, Object> deviceMap = new HashMap<>();
+                deviceMap.put("deviceId", device.getDeviceId());
+                deviceMap.put("deviceType", device.getDeviceType().toString());
+                
+                // 根据设备类型设置设备类型名称
+                switch (device.getDeviceType()) {
+                    case 1:
+                        deviceMap.put("deviceTypeName", "智能主机");
+                        break;
+                    case 2:
+                        deviceMap.put("deviceTypeName", "智能耳标");
+                        break;
+                    case 4:
+                        deviceMap.put("deviceTypeName", "智能项圈");
+                        break;
+                    default:
+                        deviceMap.put("deviceTypeName", "未知设备");
+                        break;
+                }
+                
+                // 设备基本信息
+                deviceMap.put("deviceVoltage", device.getVoltage());
+                deviceMap.put("deviceTemp", device.getTemperature());
+                deviceMap.put("battery", device.getBatteryPercentage());
+                deviceMap.put("latitude", device.getLatitude());
+                deviceMap.put("longitude", device.getLongitude());
+                deviceMap.put("walkSteps", device.getSteps());
+                deviceMap.put("yWalkSteps", device.getSameDaySteps());
+                deviceMap.put("steps", device.getSteps());
+                deviceMap.put("ySteps", device.getSameDaySteps());
+                deviceMap.put("tenantId", device.getTenantId());
+                
+                // 添加时间字段
+                deviceMap.put("updateTime", device.getUpdateTime() != null ? device.getUpdateTime().toString() : "");
+                deviceMap.put("createTime", device.getCreateTime() != null ? device.getCreateTime().toString() : "");
+                
+                // 查询租户名称
+                String tenantName = "--";
+                if (device.getTenantId() != null) {
+                    SysTenant tenant = sysTenantMapper.selectById(device.getTenantId());
+                    if (tenant != null) {
+                        tenantName = tenant.getName();
+                    }
+                }
+                deviceMap.put("tenantName", tenantName);
+                
+                // 佩戴状态（项圈设备有佩戴状态，其他设备默认未佩戴）
+                if (device.getDeviceType() == 4) {
+                    // 项圈设备，可以根据实际业务逻辑设置佩戴状态
+                    deviceMap.put("isWare", "0"); // 默认未佩戴，可以根据实际需求调整
                 } else {
-                    earTagDevices = (List<JbqClient>) earDataObj; // 兼容空列表直接返回的情况
-                }
-                for (JbqClient device : earTagDevices) {
-                    Map<String, Object> deviceMap = new HashMap<>();
-                    deviceMap.put("deviceId", device.getDeviceId());
-                    deviceMap.put("deviceType", "2");
-                    deviceMap.put("deviceTypeName", "智能耳标");
-                    deviceMap.put("deviceVoltage", device.getDeviceVoltage());
-                    deviceMap.put("deviceTemp", device.getDeviceTemp());
-                    deviceMap.put("latitude", device.getLatitude());
-                    deviceMap.put("longitude", device.getLongitude());
-                    deviceMap.put("walkSteps", device.getWalkSteps());
-                    deviceMap.put("yWalkSteps", device.getYWalkSteps());
-                    deviceMap.put("isWare", "0"); // 耳标默认未佩戴
-                    
-                    // 获取实际的图片数据
-                    DeliveryDevice deviceImages = deviceImageMap.get(device.getDeviceId());
-                    deviceMap.put("frontImg", deviceImages != null ? deviceImages.getFrontImg() : "");
-                    deviceMap.put("sideImg", deviceImages != null ? deviceImages.getSideImg() : "");
-                    deviceMap.put("hipImg", deviceImages != null ? deviceImages.getHipImg() : "");
-                    
-                    allDevices.add(deviceMap);
+                    deviceMap.put("isWare", "0"); // 其他设备默认未佩戴
                 }
+                
+                // 获取图片数据
+                DeliveryDevice deviceImages = deviceImageMap.get(device.getDeviceId());
+                deviceMap.put("frontImg", deviceImages != null ? deviceImages.getFrontImg() : "");
+                deviceMap.put("sideImg", deviceImages != null ? deviceImages.getSideImg() : "");
+                deviceMap.put("hipImg", deviceImages != null ? deviceImages.getHipImg() : "");
+                
+                allDevices.add(deviceMap);
             }
             
-            // 查询项圈设备
-            AjaxResult collarResult = xqClientService.getDevicesByDeliveryId(deliveryId, 3);
-            if (collarResult.get("code").equals(200) && collarResult.get("data") != null) {
-                Object collarDataObj = collarResult.get("data");
-                List<XqClient> collarDevices;
-                if (collarDataObj instanceof Map) {
-                    Map<String, Object> collarData = (Map<String, Object>) collarDataObj;
-                    collarDevices = (List<XqClient>) collarData.get("rows");
-                } else {
-                    collarDevices = (List<XqClient>) collarDataObj; // 兼容空列表直接返回的情况
-                }
-                for (XqClient device : collarDevices) {
-                    Map<String, Object> deviceMap = new HashMap<>();
-                    String deviceId = device.getSn() != null ? device.getSn().toString() : device.getDeviceId();
-                    deviceMap.put("deviceId", deviceId);
-                    deviceMap.put("deviceType", "3");
-                    deviceMap.put("deviceTypeName", "智能项圈");
-                    deviceMap.put("battery", device.getBattery());
-                    deviceMap.put("temperature", device.getTemperature());
-                    deviceMap.put("latitude", device.getLatitude());
-                    deviceMap.put("longitude", device.getLongitude());
-                    deviceMap.put("steps", device.getSteps());
-                    deviceMap.put("ySteps", device.getYSteps());
-                    deviceMap.put("isWare", device.getIsWear() != null ? device.getIsWear().toString() : "0");
-                    
-                    // 获取实际的图片数据
-                    DeliveryDevice deviceImages = deviceImageMap.get(deviceId);
-                    deviceMap.put("frontImg", deviceImages != null ? deviceImages.getFrontImg() : "");
-                    deviceMap.put("sideImg", deviceImages != null ? deviceImages.getSideImg() : "");
-                    deviceMap.put("hipImg", deviceImages != null ? deviceImages.getHipImg() : "");
-                    
-                    allDevices.add(deviceMap);
-                }
-            }
-            
-            return AjaxResult.success(allDevices);
+            return AjaxResult.success("操作成功", allDevices);
         } catch (Exception e) {
             e.printStackTrace();
             return AjaxResult.error("查询设备列表失败：" + e.getMessage());

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/IotDeviceProxyController.java

@@ -0,0 +1,551 @@
+package com.aiotagro.cattletrade.business.controller;
+
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
+import com.aiotagro.cattletrade.business.entity.Delivery;
+import com.aiotagro.cattletrade.business.mapper.IotDeviceDataMapper;
+import com.aiotagro.cattletrade.business.service.IDeliveryService;
+import com.aiotagro.common.core.web.domain.AjaxResult;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.*;
+
+import java.time.LocalDateTime;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * IoT设备代理控制器
+ * 用于代理调用外部IoT设备API
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@RestController
+@RequestMapping("/iotDevice")
+public class IotDeviceProxyController {
+
+    private static final Logger logger = LoggerFactory.getLogger(IotDeviceProxyController.class);
+    
+           @Autowired
+           private IotDeviceDataMapper iotDeviceDataMapper;
+           
+           @Autowired
+           private IDeliveryService deliveryService;
+    
+    /**
+     * 查询IoT设备列表（从本地数据库）
+     */
+    @PostMapping("/queryList")
+    public AjaxResult queryList(@RequestBody Map<String, Object> params) {
+        try {
+            logger.info("查询IoT设备数据，参数: {}", params);
+            if (params == null) {
+                params = new HashMap<>();
+            }
+            
+            // 构建查询条件
+            QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+            
+            // 根据设备ID查询
+            if (params.containsKey("deviceId") && params.get("deviceId") != null && 
+                !String.valueOf(params.get("deviceId")).trim().isEmpty()) {
+                queryWrapper.eq("device_id", params.get("deviceId"));
+            }
+            
+            // 根据SN查询（项圈页面使用）
+            if (params.containsKey("sn") && params.get("sn") != null && 
+                !String.valueOf(params.get("sn")).trim().isEmpty()) {
+                queryWrapper.eq("device_id", params.get("sn"));
+            }
+            
+            // 分页参数
+            Integer pageNum = (Integer) params.getOrDefault("pageNum", 1);
+            Integer pageSize = (Integer) params.getOrDefault("pageSize", 20);
+            
+            // 查询总数
+            Long total = iotDeviceDataMapper.selectCount(queryWrapper);
+            
+            // 分页查询
+            queryWrapper.last("LIMIT " + ((pageNum - 1) * pageSize) + ", " + pageSize);
+            List<IotDeviceData> deviceList = iotDeviceDataMapper.selectList(queryWrapper);
+            
+            // 转换为前端需要的格式
+            List<Map<String, Object>> resultList = deviceList.stream().map(device -> {
+                Map<String, Object> deviceMap = new HashMap<>();
+                deviceMap.put("deviceId", device.getDeviceId());
+                deviceMap.put("type", device.getDeviceType());
+                deviceMap.put("name", device.getDeviceName());
+                deviceMap.put("voltage", device.getVoltage());
+                deviceMap.put("battery", device.getBatteryPercentage());
+                deviceMap.put("temperature", device.getTemperature());
+                deviceMap.put("steps", device.getSteps());
+                deviceMap.put("sameDaySteps", device.getSameDaySteps());
+                deviceMap.put("signal", device.getSignalStrength());
+                deviceMap.put("rsrp", device.getRsrp());
+                deviceMap.put("gpsState", device.getGpsState());
+                deviceMap.put("latitude", device.getLatitude());
+                deviceMap.put("longitude", device.getLongitude());
+                deviceMap.put("altitude", device.getAltitude());
+                deviceMap.put("status", device.getStatus());
+                deviceMap.put("ver", device.getVersion());
+                deviceMap.put("uptime", device.getUptime());
+                deviceMap.put("carNumber", device.getCarNumber());
+                deviceMap.put("deliveryId", device.getDeliveryId());
+                deviceMap.put("tenantId", device.getTenantId());
+                
+                // 关联查询delivery表信息
+                if (device.getDeliveryId() != null) {
+                    Delivery delivery = deliveryService.getById(device.getDeliveryId());
+                    if (delivery != null) {
+                        deviceMap.put("deliveryNumber", delivery.getDeliveryNumber());
+                        deviceMap.put("deliveryTitle", delivery.getDeliveryTitle());
+                        // 如果设备表中的carNumber为空，使用delivery表中的车牌号
+                        if (device.getCarNumber() == null || device.getCarNumber().trim().isEmpty()) {
+                            deviceMap.put("carNumber", delivery.getLicensePlate());
+                        }
+                    }
+                } else {
+                    deviceMap.put("deliveryNumber", null);
+                    deviceMap.put("deliveryTitle", null);
+                }
+                
+                return deviceMap;
+            }).collect(java.util.stream.Collectors.toList());
+            
+            Map<String, Object> result = new HashMap<>();
+            result.put("rows", resultList);
+            result.put("total", total);
+            
+            logger.info("查询到设备数据: {} 条", resultList.size());
+            return AjaxResult.success("操作成功", result);
+            
+        } catch (Exception e) {
+                   logger.error("查询IoT设备数据失败", e);
+                   return AjaxResult.error("查询设备数据失败：" + e.getMessage());
+               }
+           }
+           
+           /**
+            * 查询IoT设备定位信息
+            */
+           @PostMapping("/getLocation")
+           public AjaxResult getLocation(@RequestBody Map<String, Object> params) {
+               try {
+                   logger.info("查询IoT设备定位信息，参数: {}", params);
+                   if (params == null) {
+                       params = new HashMap<>();
+                   }
+                   
+                   String deviceId = (String) params.get("deviceId");
+                   if (deviceId == null || deviceId.trim().isEmpty()) {
+                       return AjaxResult.error("设备ID不能为空");
+                   }
+                   
+                   // 构建查询条件
+                   QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+                   queryWrapper.eq("device_id", deviceId);
+                   
+                   IotDeviceData device = iotDeviceDataMapper.selectOne(queryWrapper);
+                   
+                   if (device == null) {
+                       return AjaxResult.error("未找到对应的设备信息");
+                   }
+                   
+                   // 检查是否有定位信息
+                   if (device.getLatitude() == null || device.getLongitude() == null || 
+                       device.getLatitude().trim().isEmpty() || device.getLongitude().trim().isEmpty()) {
+                       return AjaxResult.error("该设备暂无定位信息");
+                   }
+                   
+                   Map<String, Object> result = new HashMap<>();
+                   result.put("deviceId", device.getDeviceId());
+                   result.put("latitude", device.getLatitude());
+                   result.put("longitude", device.getLongitude());
+                   result.put("altitude", device.getAltitude());
+                   result.put("gpsState", device.getGpsState());
+                   result.put("updateTime", device.getUptime());
+                   
+                   logger.info("查询到设备定位信息: {}", device.getDeviceId());
+                   return AjaxResult.success("操作成功", result);
+                   
+               } catch (Exception e) {
+                   logger.error("查询IoT设备定位信息失败", e);
+                   return AjaxResult.error("查询设备定位信息失败：" + e.getMessage());
+               }
+           }
+           
+           /**
+            * 查询设备列表（支持查询可分配设备和已分配设备）
+            * allotType=0: 查询可分配设备（未分配给装车订单的设备）
+            * allotType=1: 查询已分配设备（已分配给装车订单的设备）
+            */
+           @PostMapping("/getAssignableDevices")
+           public AjaxResult getAssignableDevices(@RequestBody Map<String, Object> params) {
+               try {
+                   // 根据allotType显示不同的日志信息
+                   Object allotTypeObj = params != null ? params.get("allotType") : null;
+                   String allotType = allotTypeObj != null ? String.valueOf(allotTypeObj) : "0";
+                   String logMessage = "1".equals(allotType) ? "查询已分配设备列表" : "查询可分配设备列表";
+                   logger.info("{}, 参数: {}", logMessage, params);
+                   
+                   if (params == null) {
+                       params = new HashMap<>();
+                   }
+                   
+                   // 构建查询条件
+                   QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+                   
+                   // 根据设备类型过滤
+                   if (params.containsKey("deviceType") && params.get("deviceType") != null) {
+                       Object deviceTypeObj = params.get("deviceType");
+                       Integer deviceType;
+                       if (deviceTypeObj instanceof String) {
+                           deviceType = Integer.parseInt((String) deviceTypeObj);
+                       } else if (deviceTypeObj instanceof Integer) {
+                           deviceType = (Integer) deviceTypeObj;
+                       } else {
+                           deviceType = null;
+                       }
+                       if (deviceType != null) {
+                           queryWrapper.eq("device_type", deviceType);
+                       }
+                   }
+                   
+                   // 根据设备ID搜索
+                   if (params.containsKey("deviceId") && params.get("deviceId") != null && 
+                       !String.valueOf(params.get("deviceId")).trim().isEmpty()) {
+                       queryWrapper.like("device_id", params.get("deviceId"));
+                   }
+
+                   // 根据租户ID过滤
+                   if (params.containsKey("tenantId") && params.get("tenantId") != null) {
+                       Object tenantIdObj = params.get("tenantId");
+                       Integer tenantId;
+                       if (tenantIdObj instanceof String) {
+                           tenantId = Integer.parseInt((String) tenantIdObj);
+                       } else if (tenantIdObj instanceof Integer) {
+                           tenantId = (Integer) tenantIdObj;
+                       } else {
+                           tenantId = null;
+                       }
+                       if (tenantId != null) {
+                           queryWrapper.eq("tenant_id", tenantId);
+                       }
+                   }
+                   // 注意：装车订单分配设备时，不限制tenant_id，只限制delivery_id
+                   
+                   // 根据分配状态过滤（allotType）
+                   if (params.containsKey("allotType") && params.get("allotType") != null) {
+                       if (allotTypeObj instanceof String) {
+                           allotType = (String) allotTypeObj;
+                       } else {
+                           allotType = String.valueOf(allotTypeObj);
+                       }
+                       
+                       // 检查是否是租户分配模式
+                       boolean isTenantMode = params.containsKey("tenantId") && params.get("tenantId") != null;
+                       
+                       if ("0".equals(allotType)) {
+                           if (isTenantMode) {
+                               // 租户模式-未分配：查询未分配给任何租户的设备
+                               queryWrapper.and(wrapper -> wrapper.isNull("tenant_id").or().eq("tenant_id", ""));
+                           } else {
+                               // 装车订单模式-未分配：查询未分配给装车订单的设备（不限制tenant_id）
+                               queryWrapper.and(wrapper -> wrapper.isNull("delivery_id").or().eq("delivery_id", ""));
+                           }
+                       } else if ("1".equals(allotType)) {
+                           if (isTenantMode) {
+                               // 租户模式-已分配：查询已分配给租户的设备（tenant_id不为空）
+                               queryWrapper.and(wrapper -> wrapper.isNotNull("tenant_id").and(w -> w.ne("tenant_id", "")));
+                           } else {
+                               // 装车订单模式-已分配：查询已分配给装车订单的设备
+                               queryWrapper.and(wrapper -> wrapper.isNotNull("delivery_id").and(w -> w.ne("delivery_id", "")));
+                           }
+                       }
+                   } else {
+                       // 如果没有传递allotType参数，默认查询未分配给装车订单的设备（不限制tenant_id）
+                       queryWrapper.and(wrapper -> wrapper.isNull("delivery_id").or().eq("delivery_id", ""));
+                   }
+                   
+                   // 分页参数
+                   Integer pageNum = (Integer) params.getOrDefault("pageNum", 1);
+                   Integer pageSize = (Integer) params.getOrDefault("pageSize", 20);
+                   
+                   // 查询总数
+                   Long total = iotDeviceDataMapper.selectCount(queryWrapper);
+                   
+                   // 分页查询
+                   queryWrapper.last("LIMIT " + ((pageNum - 1) * pageSize) + ", " + pageSize);
+                   List<IotDeviceData> deviceList = iotDeviceDataMapper.selectList(queryWrapper);
+                   
+                   // 转换为前端需要的格式
+                   final String finalAllotType = allotType; // 创建final变量供lambda使用
+                   List<Map<String, Object>> resultList = deviceList.stream().map(device -> {
+                       Map<String, Object> deviceMap = new HashMap<>();
+                       deviceMap.put("deviceId", device.getDeviceId());
+                       deviceMap.put("deviceType", device.getDeviceType());
+                       deviceMap.put("deviceName", device.getDeviceName());
+                       deviceMap.put("voltage", device.getVoltage());
+                       deviceMap.put("batteryPercentage", device.getBatteryPercentage());
+                       deviceMap.put("temperature", device.getTemperature());
+                       deviceMap.put("status", device.getStatus());
+                       deviceMap.put("tenantId", device.getTenantId());
+                       
+                       // 根据allotType判断分配状态
+                       boolean isAssigned;
+                       if ("0".equals(finalAllotType)) {
+                           // 未分配：根据delivery_id和tenant_id判断
+                           isAssigned = device.getDeliveryId() != null || device.getTenantId() != null;
+                       } else {
+                           // 已分配：根据delivery_id和tenant_id判断
+                           isAssigned = device.getDeliveryId() != null || device.getTenantId() != null;
+                       }
+                       deviceMap.put("isAssigned", isAssigned);
+                       
+                       // 如果有delivery_id，添加deliveryNumber字段
+                       if (device.getDeliveryId() != null) {
+                           // 这里可以根据delivery_id查询delivery表获取deliveryNumber
+                           // 暂时使用delivery_id作为deliveryNumber
+                           deviceMap.put("deliveryNumber", "DEL" + device.getDeliveryId());
+                       }
+                       
+                       return deviceMap;
+                   }).collect(java.util.stream.Collectors.toList());
+                   
+                   Map<String, Object> result = new HashMap<>();
+                   result.put("rows", resultList);
+                   result.put("total", total);
+                   
+                   logger.info("查询到设备: {} 条", resultList.size());
+                   return AjaxResult.success("操作成功", result);
+                   
+               } catch (Exception e) {
+                   logger.error("查询设备列表失败", e);
+                   return AjaxResult.error("查询设备列表失败：" + e.getMessage());
+               }
+           }
+           
+           /**
+            * 分配设备到装车订单
+            */
+           @PostMapping("/assignDevices")
+           public AjaxResult assignDevices(@RequestBody Map<String, Object> params) {
+               try {
+                   logger.info("分配设备到装车订单，参数: {}", params);
+                   if (params == null) {
+                       params = new HashMap<>();
+                   }
+                   
+                   @SuppressWarnings("unchecked")
+                   List<String> deviceIds = (List<String>) params.get("deviceIds");
+                   Integer deliveryId = (Integer) params.get("deliveryId");
+                   String carNumber = (String) params.get("carNumber");
+                   
+                   if (deviceIds == null || deviceIds.isEmpty()) {
+                       return AjaxResult.error("请选择要分配的设备");
+                   }
+                   
+                   // 如果是取消分配（deliveryId为null），则不需要验证装车订单
+                   Delivery delivery = null;
+                   if (deliveryId != null) {
+                       // 验证装车订单是否存在
+                       logger.info("查询装车订单ID: {}", deliveryId);
+                       delivery = deliveryService.getById(deliveryId);
+                       if (delivery == null) {
+                           logger.error("装车订单不存在，ID: {}", deliveryId);
+                           return AjaxResult.error("装车订单不存在，ID: " + deliveryId);
+                       }
+                       logger.info("找到装车订单: {}", delivery.getDeliveryNumber());
+                   } else {
+                       logger.info("取消设备分配");
+                   }
+                   
+                   int successCount = 0;
+                   int failedCount = 0;
+                   StringBuilder errorMessage = new StringBuilder();
+                   
+                   // 批量更新设备
+                   for (String deviceId : deviceIds) {
+                       try {
+                           QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+                           queryWrapper.eq("device_id", deviceId);
+                           IotDeviceData device = iotDeviceDataMapper.selectOne(queryWrapper);
+                           
+                           if (device != null) {
+                               device.setDeliveryId(deliveryId); // 存储装车订单ID（null表示取消分配）
+                               device.setCarNumber(carNumber);
+                               device.setUpdateTime(LocalDateTime.now());
+                               
+                               iotDeviceDataMapper.updateById(device);
+                               successCount++;
+                               logger.debug("设备 {} 分配成功", deviceId);
+                           } else {
+                               failedCount++;
+                               errorMessage.append("设备 ").append(deviceId).append(" 不存在; ");
+                           }
+                       } catch (Exception e) {
+                           failedCount++;
+                           errorMessage.append("设备 ").append(deviceId).append(" 分配失败: ").append(e.getMessage()).append("; ");
+                           logger.error("设备 {} 分配失败", deviceId, e);
+                       }
+                   }
+                   
+                   String operation = deliveryId != null ? "分配" : "取消分配";
+                   String resultMessage = String.format("设备%s完成！成功: %d, 失败: %d", operation, successCount, failedCount);
+                   if (failedCount > 0) {
+                       resultMessage += "。失败原因: " + errorMessage.toString();
+                   }
+                   
+                   logger.info("设备分配结果: {}", resultMessage);
+                   return AjaxResult.success(resultMessage);
+                   
+               } catch (Exception e) {
+                   logger.error("分配设备到装车订单失败", e);
+                   return AjaxResult.error("分配设备失败：" + e.getMessage());
+               }
+           }
+
+           /**
+            * 分配设备到租户
+            */
+           @PostMapping("/assignDevicesToTenant")
+           public AjaxResult assignDevicesToTenant(@RequestBody Map<String, Object> params) {
+               try {
+                   logger.info("分配设备到租户，参数: {}", params);
+                   if (params == null) {
+                       params = new HashMap<>();
+                   }
+
+                   @SuppressWarnings("unchecked")
+                   List<String> deviceIds = (List<String>) params.get("deviceIds");
+                   Integer tenantId = (Integer) params.get("tenantId");
+
+                   if (deviceIds == null || deviceIds.isEmpty()) {
+                       return AjaxResult.error("请选择要分配的设备");
+                   }
+
+                   if (tenantId == null) {
+                       return AjaxResult.error("租户ID不能为空");
+                   }
+
+                   int successCount = 0;
+                   int failedCount = 0;
+                   StringBuilder errorMessage = new StringBuilder();
+
+                   // 批量更新设备
+                   for (String deviceId : deviceIds) {
+                       try {
+                           QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+                           queryWrapper.eq("device_id", deviceId);
+                           IotDeviceData device = iotDeviceDataMapper.selectOne(queryWrapper);
+
+                           if (device != null) {
+                               device.setTenantId(tenantId);
+                               device.setUpdateTime(LocalDateTime.now());
+
+                               iotDeviceDataMapper.updateById(device);
+                               successCount++;
+                               logger.debug("设备 {} 分配给租户 {} 成功", deviceId, tenantId);
+                           } else {
+                               failedCount++;
+                               errorMessage.append("设备 ").append(deviceId).append(" 不存在; ");
+                           }
+                       } catch (Exception e) {
+                           failedCount++;
+                           errorMessage.append("设备 ").append(deviceId).append(" 分配失败: ").append(e.getMessage()).append("; ");
+                           logger.error("设备 {} 分配给租户 {} 失败", deviceId, tenantId, e);
+                       }
+                   }
+
+                   String resultMessage = String.format("设备分配完成！成功: %d, 失败: %d", successCount, failedCount);
+                   if (failedCount > 0) {
+                       resultMessage += "。失败原因: " + errorMessage.toString();
+                   }
+
+                   logger.info("设备分配给租户结果: {}", resultMessage);
+                   return AjaxResult.success(resultMessage);
+
+               } catch (Exception e) {
+                   logger.error("分配设备到租户失败", e);
+                   return AjaxResult.error("分配设备失败：" + e.getMessage());
+               }
+           }
+
+           /**
+            * 解绑设备（将tenant_id设置为空）
+            */
+           @PostMapping("/unassignDevicesFromTenant")
+           public AjaxResult unassignDevicesFromTenant(@RequestBody Map<String, Object> params) {
+               try {
+                   logger.info("解绑设备，参数: {}", params);
+                   if (params == null) {
+                       params = new HashMap<>();
+                   }
+
+                   @SuppressWarnings("unchecked")
+                   List<String> deviceIds = (List<String>) params.get("deviceIds");
+
+                   if (deviceIds == null || deviceIds.isEmpty()) {
+                       return AjaxResult.error("请选择要解绑的设备");
+                   }
+
+                   int successCount = 0;
+                   int failedCount = 0;
+                   StringBuilder errorMessage = new StringBuilder();
+
+                   // 批量更新设备
+                   for (String deviceId : deviceIds) {
+                       try {
+                           QueryWrapper<IotDeviceData> queryWrapper = new QueryWrapper<>();
+                           queryWrapper.eq("device_id", deviceId);
+                           IotDeviceData device = iotDeviceDataMapper.selectOne(queryWrapper);
+
+                           if (device != null) {
+                               logger.info("解绑前设备 {} 的tenant_id: {}", deviceId, device.getTenantId());
+                               
+                               // 使用LambdaUpdateWrapper直接更新，确保null值也能被更新
+                               LambdaUpdateWrapper<IotDeviceData> updateWrapper = new LambdaUpdateWrapper<>();
+                               updateWrapper.eq(IotDeviceData::getDeviceId, deviceId)
+                                          .set(IotDeviceData::getTenantId, null)
+                                          .set(IotDeviceData::getUpdateTime, LocalDateTime.now());
+                               
+                               int updateResult = iotDeviceDataMapper.update(null, updateWrapper);
+                               logger.info("设备 {} 解绑更新结果: {}", deviceId, updateResult);
+                               
+                               // 验证更新结果
+                               QueryWrapper<IotDeviceData> verifyWrapper = new QueryWrapper<>();
+                               verifyWrapper.eq("device_id", deviceId);
+                               IotDeviceData verifyDevice = iotDeviceDataMapper.selectOne(verifyWrapper);
+                               logger.info("解绑后设备 {} 的tenant_id: {}", deviceId, verifyDevice != null ? verifyDevice.getTenantId() : "null");
+                               
+                               successCount++;
+                               logger.debug("设备 {} 解绑成功", deviceId);
+                           } else {
+                               failedCount++;
+                               errorMessage.append("设备 ").append(deviceId).append(" 不存在; ");
+                           }
+                       } catch (Exception e) {
+                           failedCount++;
+                           errorMessage.append("设备 ").append(deviceId).append(" 解绑失败: ").append(e.getMessage()).append("; ");
+                           logger.error("设备 {} 解绑失败", deviceId, e);
+                       }
+                   }
+
+                   String resultMessage = String.format("设备解绑完成！成功: %d, 失败: %d", successCount, failedCount);
+                   if (failedCount > 0) {
+                       resultMessage += "。失败原因: " + errorMessage.toString();
+                   }
+
+                   logger.info("设备解绑结果: {}", resultMessage);
+                   return AjaxResult.success(resultMessage);
+
+               } catch (Exception e) {
+                   logger.error("解绑设备失败", e);
+                   return AjaxResult.error("解绑设备失败：" + e.getMessage());
+               }
+           }
+       }

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/IotDeviceSyncController.java

@@ -0,0 +1,42 @@
+package com.aiotagro.cattletrade.business.controller;
+
+import com.aiotagro.cattletrade.business.service.IotDeviceSyncService;
+import com.aiotagro.common.core.web.domain.AjaxResult;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * IoT设备数据同步控制器
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@RestController
+@RequestMapping("/iotSync")
+public class IotDeviceSyncController {
+
+    private static final Logger logger = LoggerFactory.getLogger(IotDeviceSyncController.class);
+
+    @Autowired
+    private IotDeviceSyncService iotDeviceSyncService;
+
+    /**
+     * 手动同步IoT设备数据
+     */
+    @PostMapping("/sync")
+    public AjaxResult syncDeviceData() {
+        try {
+            logger.info("开始手动同步IoT设备数据");
+            iotDeviceSyncService.syncIotDeviceData();
+            logger.info("手动同步IoT设备数据完成");
+            return AjaxResult.success("数据同步完成");
+        } catch (Exception e) {
+            logger.error("手动同步IoT设备数据失败", e);
+            return AjaxResult.error("数据同步失败：" + e.getMessage());
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/IotDeviceTestController.java

@@ -0,0 +1,64 @@
+package com.aiotagro.cattletrade.business.controller;
+
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
+import com.aiotagro.cattletrade.business.mapper.IotDeviceDataMapper;
+import com.aiotagro.common.core.web.domain.AjaxResult;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+
+/**
+ * IoT设备数据测试控制器
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@RestController
+@RequestMapping("/iotTest")
+public class IotDeviceTestController {
+
+    @Autowired
+    private IotDeviceDataMapper iotDeviceDataMapper;
+
+    /**
+     * 直接查询数据库中的设备数据
+     */
+    @GetMapping("/count")
+    public AjaxResult getDeviceCount() {
+        try {
+            Long count = iotDeviceDataMapper.selectCount(null);
+            return AjaxResult.success("数据库中的设备数量: " + count);
+        } catch (Exception e) {
+            return AjaxResult.error("查询失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 查询前5条设备数据
+     */
+    @GetMapping("/list")
+    public AjaxResult getDeviceList() {
+        try {
+            List<IotDeviceData> devices = iotDeviceDataMapper.selectList(null);
+            return AjaxResult.success(devices);
+        } catch (Exception e) {
+            return AjaxResult.error("查询失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * 检查定时任务状态
+     */
+    @GetMapping("/status")
+    public AjaxResult getTaskStatus() {
+        try {
+            Long count = iotDeviceDataMapper.selectCount(null);
+            return AjaxResult.success("定时任务状态正常，数据库中有 " + count + " 条设备数据");
+        } catch (Exception e) {
+            return AjaxResult.error("定时任务状态异常: " + e.getMessage());
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/SysTenantController.java

@@ -2,18 +2,25 @@ package com.aiotagro.cattletrade.business.controller;
 
 import cn.dev33.satoken.annotation.SaCheckPermission;
 import com.aiotagro.cattletrade.business.entity.SysTenant;
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
 import com.aiotagro.cattletrade.business.mapper.SysTenantMapper;
+import com.aiotagro.cattletrade.business.mapper.IotDeviceDataMapper;
 import com.aiotagro.common.core.web.domain.AjaxResult;
 import com.aiotagro.common.core.web.domain.PageResultResponse;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.github.pagehelper.Page;
 import com.github.pagehelper.PageHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.web.bind.annotation.*;
 
 import javax.annotation.Resource;
 import java.util.Date;
 import java.util.List;
 import java.util.Map;
+import java.util.HashMap;
 
 /**
  * 租户管理控制器
@@ -25,15 +32,20 @@ import java.util.Map;
 @RequestMapping("/sysTenant")
 public class SysTenantController {
 
+    private static final Logger logger = LoggerFactory.getLogger(SysTenantController.class);
+
     @Resource
     private SysTenantMapper tenantMapper;
+    
+    @Resource
+    private IotDeviceDataMapper iotDeviceDataMapper;
 
     /**
      * 租户列表查询（分页）
      */
     @SaCheckPermission("system:tenant:list")
     @PostMapping("/queryList")
-    public PageResultResponse<SysTenant> queryList(@RequestBody Map<String, Object> params) {
+    public AjaxResult queryList(@RequestBody Map<String, Object> params) {
         Integer pageNum = params.get("pageNum") != null ? (Integer) params.get("pageNum") : 1;
         Integer pageSize = params.get("pageSize") != null ? (Integer) params.get("pageSize") : 10;
         String name = (String) params.get("name");
@@ -50,7 +62,44 @@ public class SysTenantController {
         wrapper.orderByDesc(SysTenant::getId);
         List<SysTenant> list = tenantMapper.selectList(wrapper);
 
-        return new PageResultResponse<>(result.getTotal(), list);
+        // 为每个租户添加设备数量统计
+        List<Map<String, Object>> resultList = list.stream().map(tenant -> {
+            Map<String, Object> tenantMap = new HashMap<>();
+            tenantMap.put("id", tenant.getId());
+            tenantMap.put("name", tenant.getName());
+            tenantMap.put("mobile", tenant.getMobile());
+            tenantMap.put("createTime", tenant.getCreateTime());
+            
+            // 查询该租户的设备数量统计
+            QueryWrapper<IotDeviceData> deviceWrapper = new QueryWrapper<>();
+            deviceWrapper.eq("tenant_id", tenant.getId());
+            
+            // 耳标数量 (device_type = 2)
+            deviceWrapper.clear();
+            deviceWrapper.eq("tenant_id", tenant.getId()).eq("device_type", 2);
+            Long jbqCount = iotDeviceDataMapper.selectCount(deviceWrapper);
+            tenantMap.put("jbqCount", jbqCount);
+            
+            // 项圈数量 (device_type = 4)
+            deviceWrapper.clear();
+            deviceWrapper.eq("tenant_id", tenant.getId()).eq("device_type", 4);
+            Long xqCount = iotDeviceDataMapper.selectCount(deviceWrapper);
+            tenantMap.put("xqCount", xqCount);
+            
+            // 主机数量 (device_type = 1)
+            deviceWrapper.clear();
+            deviceWrapper.eq("tenant_id", tenant.getId()).eq("device_type", 1);
+            Long serverCount = iotDeviceDataMapper.selectCount(deviceWrapper);
+            tenantMap.put("serverCount", serverCount);
+            
+            return tenantMap;
+        }).collect(java.util.stream.Collectors.toList());
+
+        Map<String, Object> resultMap = new HashMap<>();
+        resultMap.put("rows", resultList);
+        resultMap.put("total", result.getTotal());
+        
+        return AjaxResult.success("操作成功", resultMap);
     }
 
     /**
@@ -77,15 +126,46 @@ public class SysTenantController {
 
     /**
      * 删除租户（逻辑删除）
+     * 同时将该租户绑定的所有设备的tenant_id设置为null
      */
     @SaCheckPermission("system:tenant:delete")
     @PostMapping("/delete")
     public AjaxResult delete(@RequestParam Integer id) {
-        SysTenant tenant = new SysTenant();
-        tenant.setId(id);
-        tenant.setIsDelete(1);
-        int rows = tenantMapper.updateById(tenant);
-        return rows > 0 ? AjaxResult.success("删除成功") : AjaxResult.error("删除失败");
+        try {
+            // 1. 先查询该租户绑定的设备数量
+            QueryWrapper<IotDeviceData> deviceWrapper = new QueryWrapper<>();
+            deviceWrapper.eq("tenant_id", id);
+            Long deviceCount = iotDeviceDataMapper.selectCount(deviceWrapper);
+            
+            // 2. 将该租户绑定的所有设备的tenant_id设置为null
+            if (deviceCount > 0) {
+                LambdaUpdateWrapper<IotDeviceData> updateWrapper = new LambdaUpdateWrapper<>();
+                updateWrapper.eq(IotDeviceData::getTenantId, id)
+                           .set(IotDeviceData::getTenantId, null)
+                           .set(IotDeviceData::getUpdateTime, new Date());
+                
+                int updateResult = iotDeviceDataMapper.update(null, updateWrapper);
+                logger.info("租户 {} 删除时解绑设备数量: {}", id, updateResult);
+            }
+            
+            // 3. 删除租户（逻辑删除）
+            SysTenant tenant = new SysTenant();
+            tenant.setId(id);
+            tenant.setIsDelete(1);
+            int rows = tenantMapper.updateById(tenant);
+            
+            if (rows > 0) {
+                String message = deviceCount > 0 ? 
+                    String.format("删除成功，同时解绑了 %d 个设备", deviceCount) : 
+                    "删除成功";
+                return AjaxResult.success(message);
+            } else {
+                return AjaxResult.error("删除失败");
+            }
+        } catch (Exception e) {
+            logger.error("删除租户失败，租户ID: {}", id, e);
+            return AjaxResult.error("删除失败：" + e.getMessage());
+        }
     }
 
     /**

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/controller/SysUserMenuController.java

@@ -0,0 +1,160 @@
+package com.aiotagro.cattletrade.business.controller;
+
+import cn.dev33.satoken.annotation.SaCheckPermission;
+import com.aiotagro.cattletrade.business.entity.SysUserMenu;
+import com.aiotagro.cattletrade.business.mapper.SysUserMenuMapper;
+import com.aiotagro.common.core.web.domain.AjaxResult;
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.*;
+
+/**
+ * 用户菜单权限管理控制器
+ *
+ * @author System
+ * @date 2025-01-27
+ */
+@Slf4j
+@RestController
+@RequestMapping("/sysUserMenu")
+public class SysUserMenuController {
+
+    @Resource
+    private SysUserMenuMapper sysUserMenuMapper;
+
+    /**
+     * 获取用户已分配的菜单ID列表
+     */
+    @SaCheckPermission("permission:operation:list")
+    @GetMapping("/userMenuIds")
+    public AjaxResult getUserMenuIds(@RequestParam Integer userId) {
+        log.info("=== 获取用户菜单权限ID列表 ===");
+        log.info("userId: {}", userId);
+        
+        if (userId == null) {
+            log.error("用户ID不能为空");
+            return AjaxResult.error("用户ID不能为空");
+        }
+        
+        try {
+            List<Integer> menuIds = sysUserMenuMapper.selectMenuIdsByUserId(userId);
+            log.info("=== 用户 {} 已分配权限ID列表: {}", userId, menuIds);
+            return AjaxResult.success(menuIds);
+        } catch (Exception e) {
+            log.error("获取用户菜单权限失败", e);
+            return AjaxResult.error("获取用户菜单权限失败");
+        }
+    }
+
+    /**
+     * 为用户分配菜单权限
+     */
+    @SaCheckPermission("permission:operation:assign")
+    @PostMapping("/assignUserMenus")
+    public AjaxResult assignUserMenus(@RequestBody Map<String, Object> params) {
+        Integer userId = (Integer) params.get("userId");
+        @SuppressWarnings("unchecked")
+        List<Integer> menuIds = (List<Integer>) params.get("menuIds");
+        
+        log.info("=== 分配用户菜单权限 ===");
+        log.info("userId: {}", userId);
+        log.info("menuIds: {}", menuIds);
+        
+        if (userId == null) {
+            log.error("用户ID不能为空");
+            return AjaxResult.error("用户ID不能为空");
+        }
+        
+        try {
+            // 删除原有权限
+            int deletedCount = sysUserMenuMapper.delete(
+                new LambdaQueryWrapper<SysUserMenu>()
+                    .eq(SysUserMenu::getUserId, userId)
+            );
+            log.info("=== 删除用户 {} 原有权限记录数: {}", userId, deletedCount);
+            
+            // 添加新权限
+            if (menuIds != null && !menuIds.isEmpty()) {
+                for (Integer menuId : menuIds) {
+                    SysUserMenu userMenu = new SysUserMenu();
+                    userMenu.setUserId(userId);
+                    userMenu.setMenuId(menuId);
+                    userMenu.setCreateTime(new Date());
+                    int insertResult = sysUserMenuMapper.insert(userMenu);
+                    log.info("=== 插入用户权限记录 userId: {}, menuId: {}, 结果: {}", userId, menuId, insertResult);
+                }
+                log.info("=== 成功为用户 {} 分配 {} 个权限", userId, menuIds.size());
+            } else {
+                log.info("=== 没有要分配的权限，清空用户 {} 所有权限", userId);
+            }
+            
+            return AjaxResult.success("分配成功");
+        } catch (Exception e) {
+            log.error("分配用户菜单权限失败", e);
+            return AjaxResult.error("分配用户菜单权限失败");
+        }
+    }
+
+    /**
+     * 清空用户专属权限（恢复使用角色权限）
+     */
+    @SaCheckPermission("permission:operation:assign")
+    @DeleteMapping("/clearUserMenus")
+    public AjaxResult clearUserMenus(@RequestParam Integer userId) {
+        log.info("=== 清空用户专属权限 ===");
+        log.info("userId: {}", userId);
+        
+        if (userId == null) {
+            log.error("用户ID不能为空");
+            return AjaxResult.error("用户ID不能为空");
+        }
+        
+        try {
+            // 删除用户所有专属权限
+            int deletedCount = sysUserMenuMapper.delete(
+                new LambdaQueryWrapper<SysUserMenu>()
+                    .eq(SysUserMenu::getUserId, userId)
+            );
+            log.info("=== 清空用户 {} 专属权限，删除记录数: {}", userId, deletedCount);
+            
+            return AjaxResult.success("清空成功，用户将使用角色权限");
+        } catch (Exception e) {
+            log.error("清空用户专属权限失败", e);
+            return AjaxResult.error("清空用户专属权限失败");
+        }
+    }
+
+    /**
+     * 检查用户是否有专属权限
+     */
+    @SaCheckPermission("permission:operation:list")
+    @GetMapping("/hasUserPermissions")
+    public AjaxResult hasUserPermissions(@RequestParam Integer userId) {
+        log.info("=== 检查用户是否有专属权限 ===");
+        log.info("userId: {}", userId);
+        
+        if (userId == null) {
+            log.error("用户ID不能为空");
+            return AjaxResult.error("用户ID不能为空");
+        }
+        
+        try {
+            List<Integer> menuIds = sysUserMenuMapper.selectMenuIdsByUserId(userId);
+            boolean hasUserPermissions = menuIds != null && !menuIds.isEmpty();
+            
+            Map<String, Object> result = new HashMap<>();
+            result.put("hasUserPermissions", hasUserPermissions);
+            result.put("permissionCount", menuIds != null ? menuIds.size() : 0);
+            result.put("permissionSource", hasUserPermissions ? "用户专属权限" : "角色权限");
+            
+            log.info("=== 用户 {} 权限状态: {}", userId, result);
+            return AjaxResult.success(result);
+        } catch (Exception e) {
+            log.error("检查用户权限状态失败", e);
+            return AjaxResult.error("检查用户权限状态失败");
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/entity/IotDeviceData.java

@@ -0,0 +1,143 @@
+package com.aiotagro.cattletrade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+
+/**
+ * IoT设备数据实体
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("iot_device_data")
+public class IotDeviceData {
+
+    /**
+     * 主键ID
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 设备ID
+     */
+    private String deviceId;
+
+    /**
+     * 设备类型：1-主机，2-耳标，4-项圈
+     */
+    private Integer deviceType;
+
+    /**
+     * 设备名称
+     */
+    private String deviceName;
+
+    /**
+     * 电压值
+     */
+    private BigDecimal voltage;
+
+    /**
+     * 电量百分比
+     */
+    private Integer batteryPercentage;
+
+    /**
+     * 温度
+     */
+    private BigDecimal temperature;
+
+    /**
+     * 步数
+     */
+    private Long steps;
+
+    /**
+     * 信号强度
+     */
+    private String signalStrength;
+
+    /**
+     * RSRP信号强度
+     */
+    private String rsrp;
+
+    /**
+     * GPS状态
+     */
+    private String gpsState;
+
+    /**
+     * 纬度
+     */
+    private String latitude;
+
+    /**
+     * 经度
+     */
+    private String longitude;
+
+    /**
+     * 海拔
+     */
+    private String altitude;
+
+    /**
+     * 当日步数
+     */
+    private Integer sameDaySteps;
+
+    /**
+     * 设备状态
+     */
+    private Integer status;
+
+    /**
+     * 设备版本
+     */
+    private String version;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime uptime;
+
+    /**
+     * 机构ID
+     */
+    private String organId;
+
+    /**
+     * 车牌号
+     */
+    private String carNumber;
+
+    /**
+     * 装车订单ID，关联delivery表主键
+     */
+    private Integer deliveryId;
+
+    /**
+     * 租户ID，关联sys_tenant表主键
+     */
+    private Integer tenantId;
+
+    /**
+     * 创建时间
+     */
+    private LocalDateTime createTime;
+
+    /**
+     * 更新时间
+     */
+    private LocalDateTime updateTime;
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/entity/IotSyncLog.java

@@ -0,0 +1,62 @@
+package com.aiotagro.cattletrade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.time.LocalDateTime;
+
+/**
+ * IoT数据同步日志实体
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Data
+@EqualsAndHashCode(callSuper = false)
+@TableName("iot_sync_log")
+public class IotSyncLog {
+
+    /**
+     * 主键ID
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    /**
+     * 同步类型：AUTO-自动，MANUAL-手动
+     */
+    private String syncType;
+
+    /**
+     * 同步状态：SUCCESS-成功，FAILED-失败
+     */
+    private String syncStatus;
+
+    /**
+     * 总数据量
+     */
+    private Integer totalCount;
+
+    /**
+     * 成功数量
+     */
+    private Integer successCount;
+
+    /**
+     * 失败数量
+     */
+    private Integer failedCount;
+
+    /**
+     * 错误信息
+     */
+    private String errorMessage;
+
+    /**
+     * 同步时间
+     */
+    private LocalDateTime syncTime;
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/entity/SysUserMenu.java

@@ -0,0 +1,50 @@
+package com.aiotagro.cattletrade.business.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * <p>
+ * 用户菜单权限表
+ * </p>
+ *
+ * @author System
+ * @since 2025-01-27
+ */
+@Getter
+@Setter
+@TableName("sys_user_menu")
+public class SysUserMenu implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    @TableId(value = "id", type = IdType.AUTO)
+    private Integer id;
+
+    /**
+     * 用户ID
+     */
+    @TableField("user_id")
+    private Integer userId;
+
+    /**
+     * 菜单ID
+     */
+    @TableField("menu_id")
+    private Integer menuId;
+
+    /**
+     * 创建时间
+     */
+    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    @TableField("create_time")
+    private Date createTime;
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/mapper/IotDeviceDataMapper.java

@@ -0,0 +1,16 @@
+package com.aiotagro.cattletrade.business.mapper;
+
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * IoT设备数据Mapper接口
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Mapper
+public interface IotDeviceDataMapper extends BaseMapper<IotDeviceData> {
+
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/mapper/IotSyncLogMapper.java

@@ -0,0 +1,16 @@
+package com.aiotagro.cattletrade.business.mapper;
+
+import com.aiotagro.cattletrade.business.entity.IotSyncLog;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * IoT数据同步日志Mapper接口
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Mapper
+public interface IotSyncLogMapper extends BaseMapper<IotSyncLog> {
+
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/mapper/SysMenuMapper.java

@@ -42,4 +42,12 @@ public interface SysMenuMapper extends BaseMapper<SysMenu> {
      */
     List<SysMenu> selectMenusByRoleId(@Param("roleId") Integer roleId);
 
+    /**
+     * 根据权限列表查询菜单
+     *
+     * @param permissions 权限列表
+     * @return 菜单列表
+     */
+    List<SysMenu> selectMenusByPermissions(@Param("permissions") List<String> permissions);
+
 }

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/mapper/SysUserMenuMapper.java

@@ -0,0 +1,37 @@
+package com.aiotagro.cattletrade.business.mapper;
+
+import com.aiotagro.cattletrade.business.entity.SysMenu;
+import com.aiotagro.cattletrade.business.entity.SysUserMenu;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+/**
+ * <p>
+ * 用户菜单权限表 Mapper 接口
+ * </p>
+ *
+ * @author System
+ * @since 2025-01-27
+ */
+@Mapper
+public interface SysUserMenuMapper extends BaseMapper<SysUserMenu> {
+
+    /**
+     * 根据用户ID查询菜单列表（包含权限信息）
+     *
+     * @param userId 用户ID
+     * @return 菜单列表
+     */
+    List<SysMenu> selectMenusByUserId(@Param("userId") Integer userId);
+
+    /**
+     * 根据用户ID查询已分配的菜单ID列表
+     *
+     * @param userId 用户ID
+     * @return 菜单ID列表
+     */
+    List<Integer> selectMenuIdsByUserId(@Param("userId") Integer userId);
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/service/IotDeviceSyncService.java

@@ -0,0 +1,314 @@
+package com.aiotagro.cattletrade.business.service;
+
+import com.aiotagro.cattletrade.business.entity.IotDeviceData;
+import com.aiotagro.cattletrade.business.entity.IotSyncLog;
+import com.aiotagro.cattletrade.business.mapper.IotDeviceDataMapper;
+import com.aiotagro.cattletrade.business.mapper.IotSyncLogMapper;
+import com.aiotagro.cattletrade.common.utils.http.HttpUtils;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * IoT设备数据同步服务
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Service
+public class IotDeviceSyncService {
+
+    private static final Logger logger = LoggerFactory.getLogger(IotDeviceSyncService.class);
+    
+    private static final String IOT_API_URL = "http://api.aiotagro.com/api/iot/organ/deviceStatus";
+    private static final String ORGAN_ID = "385082";
+    private static final String SECRET_KEY = "8A71C63863394F8D5C36A8809F2C0875";
+    
+    @Autowired
+    private IotDeviceDataMapper iotDeviceDataMapper;
+    
+    @Autowired
+    private IotSyncLogMapper iotSyncLogMapper;
+
+    /**
+     * 同步IoT设备数据
+     */
+    @Transactional
+    public void syncIotDeviceData() {
+        IotSyncLog syncLog = new IotSyncLog();
+        syncLog.setSyncType("AUTO");
+        syncLog.setSyncTime(LocalDateTime.now());
+        
+        try {
+            logger.info("开始同步IoT设备数据");
+            
+            // 调用外部API获取数据
+            List<Map<String, Object>> deviceDataList = fetchDeviceDataFromApi();
+            
+            if (deviceDataList.isEmpty()) {
+                logger.warn("未获取到设备数据");
+                syncLog.setSyncStatus("SUCCESS");
+                syncLog.setTotalCount(0);
+                syncLog.setSuccessCount(0);
+                syncLog.setFailedCount(0);
+                iotSyncLogMapper.insert(syncLog);
+                return;
+            }
+            
+            syncLog.setTotalCount(deviceDataList.size());
+            int successCount = 0;
+            int failedCount = 0;
+            
+            // 批量保存数据
+            for (Map<String, Object> deviceData : deviceDataList) {
+                try {
+                    IotDeviceData iotDevice = convertToIotDeviceData(deviceData);
+                    
+                    // 检查设备是否已存在
+                    IotDeviceData existingDevice = iotDeviceDataMapper.selectOne(
+                        new com.baomidou.mybatisplus.core.conditions.query.QueryWrapper<IotDeviceData>()
+                            .eq("device_id", iotDevice.getDeviceId())
+                    );
+                    
+                    if (existingDevice != null) {
+                        // 更新现有设备数据
+                        iotDevice.setId(existingDevice.getId());
+                        iotDevice.setCreateTime(existingDevice.getCreateTime());
+                        iotDeviceDataMapper.updateById(iotDevice);
+                        logger.debug("更新设备数据: {}", iotDevice.getDeviceId());
+                    } else {
+                        // 插入新设备数据
+                        iotDeviceDataMapper.insert(iotDevice);
+                        logger.debug("插入新设备数据: {}", iotDevice.getDeviceId());
+                    }
+                    
+                    successCount++;
+                } catch (Exception e) {
+                    logger.error("处理设备数据失败: {}", deviceData.get("deviceId"), e);
+                    failedCount++;
+                }
+            }
+            
+            syncLog.setSyncStatus(failedCount > 0 ? "FAILED" : "SUCCESS");
+            syncLog.setSuccessCount(successCount);
+            syncLog.setFailedCount(failedCount);
+            
+            logger.info("IoT设备数据同步完成，总数: {}, 成功: {}, 失败: {}", 
+                deviceDataList.size(), successCount, failedCount);
+            
+        } catch (Exception e) {
+            logger.error("同步IoT设备数据失败", e);
+            syncLog.setSyncStatus("FAILED");
+            syncLog.setErrorMessage(e.getMessage());
+        } finally {
+            iotSyncLogMapper.insert(syncLog);
+        }
+    }
+
+    /**
+     * 从外部API获取设备数据
+     */
+    private List<Map<String, Object>> fetchDeviceDataFromApi() throws Exception {
+        // 生成签名
+        long currentTimestamp = System.currentTimeMillis();
+        String sign = generateSign(ORGAN_ID, String.valueOf(currentTimestamp), SECRET_KEY);
+        
+        Map<String, Object> params = new HashMap<>();
+        params.put("organId", ORGAN_ID);
+        params.put("timestamp", currentTimestamp);
+        params.put("sign", sign);
+        
+        logger.info("调用外部API获取设备数据");
+        String response = HttpUtils.sendPost(IOT_API_URL, params);
+        
+        ObjectMapper mapper = new ObjectMapper();
+        Map<String, Object> responseMap = mapper.readValue(response, Map.class);
+        
+        if (!Integer.valueOf(0).equals(responseMap.get("status"))) {
+            throw new RuntimeException("外部API调用失败: " + responseMap.get("msg"));
+        }
+        
+        List<Map<String, Object>> allDevices = new ArrayList<>();
+        
+        if (responseMap.containsKey("data") && responseMap.get("data") instanceof Map) {
+            Map<String, Object> dataMap = (Map<String, Object>) responseMap.get("data");
+            
+            if (dataMap.containsKey("devices") && dataMap.get("devices") instanceof List) {
+                List<Map<String, Object>> devicesList = (List<Map<String, Object>>) dataMap.get("devices");
+                
+                for (Map<String, Object> deviceGroup : devicesList) {
+                    if (deviceGroup.containsKey("detail") && deviceGroup.get("detail") instanceof List) {
+                        List<Map<String, Object>> details = (List<Map<String, Object>>) deviceGroup.get("detail");
+                        Integer type = (Integer) deviceGroup.get("type");
+                        
+                        for (Map<String, Object> detail : details) {
+                            detail.put("type", type);
+                            // 根据type设置name字段
+                            if (type == 1) {
+                                detail.put("name", "主机");
+                            } else if (type == 2) {
+                                detail.put("name", "耳标");
+                            } else if (type == 4) {
+                                detail.put("name", "项圈");
+                            }
+                            allDevices.add(detail);
+                        }
+                    }
+                }
+            }
+        }
+        
+        return allDevices;
+    }
+
+    /**
+     * 将API数据转换为实体对象
+     */
+    private IotDeviceData convertToIotDeviceData(Map<String, Object> data) {
+        IotDeviceData device = new IotDeviceData();
+        
+        device.setDeviceId(String.valueOf(data.get("deviceId")));
+        device.setDeviceType((Integer) data.get("type"));
+        // 设置设备名称，确保字符编码正确
+        String deviceName = String.valueOf(data.get("name"));
+        if (deviceName != null && !deviceName.equals("null")) {
+            device.setDeviceName(deviceName);
+        } else {
+            // 如果name字段为空，根据type设置默认名称
+            Integer type = device.getDeviceType();
+            if (type == 1) {
+                device.setDeviceName("主机");
+            } else if (type == 2) {
+                device.setDeviceName("耳标");
+            } else if (type == 4) {
+                device.setDeviceName("项圈");
+            } else {
+                device.setDeviceName("未知设备");
+            }
+        }
+        device.setOrganId(ORGAN_ID);
+        
+        // 电压和电量
+        if (data.get("voltage") != null) {
+            device.setVoltage(new BigDecimal(String.valueOf(data.get("voltage"))));
+            device.setBatteryPercentage(calculateBatteryPercentage(device.getVoltage()));
+        }
+        if (data.get("battery") != null) {
+            device.setVoltage(new BigDecimal(String.valueOf(data.get("battery"))));
+            device.setBatteryPercentage(calculateBatteryPercentage(device.getVoltage()));
+        }
+        
+        // 温度
+        if (data.get("temperature") != null && !String.valueOf(data.get("temperature")).isEmpty()) {
+            device.setTemperature(new BigDecimal(String.valueOf(data.get("temperature"))));
+        }
+        
+        // 步数
+        if (data.get("steps") != null) {
+            device.setSteps(Long.valueOf(String.valueOf(data.get("steps"))));
+        }
+        
+        // 当日步数
+        if (data.get("sameDaySteps") != null) {
+            device.setSameDaySteps(Integer.valueOf(String.valueOf(data.get("sameDaySteps"))));
+        }
+        
+        // 信号强度
+        if (data.get("signal") != null) {
+            device.setSignalStrength(String.valueOf(data.get("signal")));
+        }
+        if (data.get("rsrp") != null) {
+            device.setRsrp(String.valueOf(data.get("rsrp")));
+        }
+        
+        // GPS状态
+        if (data.get("gpsState") != null) {
+            device.setGpsState(String.valueOf(data.get("gpsState")));
+        }
+        
+        // 位置信息
+        if (data.get("latitude") != null) {
+            device.setLatitude(String.valueOf(data.get("latitude")));
+        }
+        if (data.get("longitude") != null) {
+            device.setLongitude(String.valueOf(data.get("longitude")));
+        }
+        if (data.get("altitude") != null) {
+            device.setAltitude(String.valueOf(data.get("altitude")));
+        }
+        
+        // 设备状态
+        if (data.get("status") != null) {
+            device.setStatus(Integer.valueOf(String.valueOf(data.get("status"))));
+        }
+        
+        // 版本
+        if (data.get("ver") != null) {
+            device.setVersion(String.valueOf(data.get("ver")));
+        }
+        
+        // 更新时间
+        if (data.get("uptime") != null) {
+            try {
+                String uptimeStr = String.valueOf(data.get("uptime"));
+                DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+                device.setUptime(LocalDateTime.parse(uptimeStr, formatter));
+            } catch (Exception e) {
+                logger.warn("解析更新时间失败: {}", data.get("uptime"));
+            }
+        }
+        
+        return device;
+    }
+
+    /**
+     * 计算电量百分比
+     */
+    private Integer calculateBatteryPercentage(BigDecimal voltage) {
+        if (voltage == null) {
+            return 0;
+        }
+        
+        BigDecimal minVoltage = new BigDecimal("2.4");
+        BigDecimal maxVoltage = new BigDecimal("3.0");
+        
+        if (voltage.compareTo(maxVoltage) >= 0) {
+            return 100;
+        } else if (voltage.compareTo(minVoltage) <= 0) {
+            return 0;
+        } else {
+            BigDecimal percentage = voltage.subtract(minVoltage)
+                .divide(maxVoltage.subtract(minVoltage), 4, BigDecimal.ROUND_HALF_UP)
+                .multiply(new BigDecimal("100"));
+            return percentage.intValue();
+        }
+    }
+
+    /**
+     * 生成签名
+     */
+    private String generateSign(String organId, String timestamp, String secretKey) {
+        try {
+            String data = organId + timestamp + secretKey;
+            java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
+            byte[] digest = md.digest(data.getBytes("UTF-8"));
+            
+            StringBuilder sb = new StringBuilder();
+            for (byte b : digest) {
+                sb.append(String.format("%02x", b));
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            logger.error("生成签名失败", e);
+            return "";
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/service/impl/DeliveryServiceImpl.java

@@ -363,13 +363,26 @@ public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> i
             });
             
             // 数据权限过滤：非超级管理员只能看到与自己手机号相关的订单
+            System.out.println("=== 数据权限过滤调试信息 ===");
+            System.out.println("SecurityUtil.isSuperAdmin(): " + SecurityUtil.isSuperAdmin());
+            System.out.println("当前用户角色ID: " + SecurityUtil.getRoleId());
+            System.out.println("超级管理员角色ID常量: " + RoleConstants.SUPER_ADMIN_ROLE_ID);
+            System.out.println("当前用户手机号: " + currentUserMobile);
+            System.out.println("手机号是否为空: " + (StringUtils.isEmpty(currentUserMobile)));
+            
             if (!SecurityUtil.isSuperAdmin() && StringUtils.isNotEmpty(currentUserMobile)) {
                 System.out.println("=== 非超级管理员，执行数据权限过滤 ===");
-                System.out.println("当前用户手机号: " + currentUserMobile);
+                System.out.println("过滤前的运单数量: " + list.size());
                 
                 list = list.stream().filter(delivery -> {
                     boolean hasPermission = false;
                     
+                    System.out.println("=== 检查运单权限: " + delivery.getDeliveryNumber() + " ===");
+                    System.out.println("司机手机号: " + delivery.getDriverMobile());
+                    System.out.println("供应商手机号: " + delivery.getSupplierMobile());
+                    System.out.println("资金方手机号: " + delivery.getFundMobile());
+                    System.out.println("采购商手机号: " + delivery.getBuyerMobile());
+                    
                     // 检查是否是司机
                     if (StringUtils.isNotEmpty(delivery.getDriverMobile()) && 
                         currentUserMobile.equals(delivery.getDriverMobile())) {
@@ -383,7 +396,7 @@ public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> i
                         for (String mobile : supplierMobiles) {
                             if (currentUserMobile.equals(mobile.trim())) {
                                 hasPermission = true;
-                                System.out.println("运单 " + delivery.getDeliveryNumber() + " - 匹配供应商手机号");
+                                System.out.println("运单 " + delivery.getDeliveryNumber() + " - 匹配供应商手机号: " + mobile.trim());
                                 break;
                             }
                         }
@@ -1082,14 +1095,15 @@ public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> i
             });
             
             // 数据权限过滤：非超级管理员只能看到与自己手机号相关的订单
-            System.out.println("=== 超级管理员判断调试 ===");
+            System.out.println("=== 数据权限过滤调试信息 ===");
             System.out.println("SecurityUtil.isSuperAdmin(): " + SecurityUtil.isSuperAdmin());
             System.out.println("当前用户角色ID: " + SecurityUtil.getRoleId());
             System.out.println("超级管理员角色ID常量: " + RoleConstants.SUPER_ADMIN_ROLE_ID);
+            System.out.println("当前用户手机号: " + currentUserMobile);
+            System.out.println("手机号是否为空: " + (StringUtils.isEmpty(currentUserMobile)));
             
             if (!SecurityUtil.isSuperAdmin() && StringUtils.isNotEmpty(currentUserMobile)) {
                 System.out.println("=== 非超级管理员，执行数据权限过滤 ===");
-                System.out.println("当前用户手机号: " + currentUserMobile);
                 System.out.println("过滤前的订单数量: " + resList.size());
                 
                 resList = resList.stream().filter(delivery -> {
@@ -1157,9 +1171,10 @@ public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> i
     @Override
     public PageResultResponse<DeliveryLogVo> pageQueryList(DeliverListDto dto) {
         //获取当前登录人的信息
-//        Integer currentUserId = SecurityUtil.getCurrentUserId();
+        String currentUserMobile = SecurityUtil.getUserMobile();
+        System.out.println("=== 警告日志列表查询 - 当前登录用户手机号: " + currentUserMobile);
+        
         Page<Delivery> result = PageHelper.startPage(dto.getPageNum(), dto.getPageSize());
-//        dto.setCurrentUserId(currentUserId);
         if(StringUtils.isNotEmpty(dto.getStartTime())){
             String startTime = dto.getStartTime() + " 00:00:00";
             dto.setStartTime(startTime);
@@ -1169,13 +1184,84 @@ public class DeliveryServiceImpl extends ServiceImpl<DeliveryMapper, Delivery> i
             dto.setEndTime(endTime);
         }
         List<Delivery> resList = this.baseMapper.getPageWarningLog(dto);
+        
+        // 数据权限过滤：非超级管理员只能看到与自己手机号相关的订单
+        System.out.println("=== 超级管理员判断调试 ===");
+        System.out.println("SecurityUtil.isSuperAdmin(): " + SecurityUtil.isSuperAdmin());
+        System.out.println("当前用户角色ID: " + SecurityUtil.getRoleId());
+        System.out.println("超级管理员角色ID常量: " + RoleConstants.SUPER_ADMIN_ROLE_ID);
+        
+        if (!SecurityUtil.isSuperAdmin() && StringUtils.isNotEmpty(currentUserMobile)) {
+            System.out.println("=== 非超级管理员，执行数据权限过滤 ===");
+            System.out.println("当前用户手机号: " + currentUserMobile);
+            System.out.println("过滤前的订单数量: " + resList.size());
+            
+            resList = resList.stream().filter(delivery -> {
+                boolean hasPermission = false;
+                
+                System.out.println("=== 检查订单权限: " + delivery.getDeliveryNumber() + " ===");
+                System.out.println("司机手机号: " + delivery.getDriverMobile());
+                System.out.println("供应商手机号: " + delivery.getSupplierMobile());
+                System.out.println("资金方手机号: " + delivery.getFundMobile());
+                System.out.println("采购商手机号: " + delivery.getBuyerMobile());
+                
+                // 检查是否是司机
+                if (StringUtils.isNotEmpty(delivery.getDriverMobile()) && 
+                    currentUserMobile.equals(delivery.getDriverMobile())) {
+                    hasPermission = true;
+                    System.out.println("订单 " + delivery.getDeliveryNumber() + " - 匹配司机手机号");
+                }
+                
+                // 检查是否是供应商（可能有多个供应商）
+                if (!hasPermission && StringUtils.isNotEmpty(delivery.getSupplierMobile())) {
+                    String[] supplierMobiles = delivery.getSupplierMobile().split(",");
+                    for (String mobile : supplierMobiles) {
+                        if (currentUserMobile.equals(mobile.trim())) {
+                            hasPermission = true;
+                            System.out.println("订单 " + delivery.getDeliveryNumber() + " - 匹配供应商手机号");
+                            break;
+                        }
+                    }
+                }
+                
+                // 检查是否是资金方
+                if (!hasPermission && StringUtils.isNotEmpty(delivery.getFundMobile()) && 
+                    currentUserMobile.equals(delivery.getFundMobile())) {
+                    hasPermission = true;
+                    System.out.println("订单 " + delivery.getDeliveryNumber() + " - 匹配资金方手机号");
+                }
+                
+                // 检查是否是采购商
+                if (!hasPermission && StringUtils.isNotEmpty(delivery.getBuyerMobile()) && 
+                    currentUserMobile.equals(delivery.getBuyerMobile())) {
+                    hasPermission = true;
+                    System.out.println("订单 " + delivery.getDeliveryNumber() + " - 匹配采购商手机号");
+                }
+                
+                if (!hasPermission) {
+                    System.out.println("订单 " + delivery.getDeliveryNumber() + " - 无权限，过滤掉");
+                }
+                
+                return hasPermission;
+            }).collect(Collectors.toList());
+            
+            System.out.println("过滤后的订单数量: " + resList.size());
+        } else if (SecurityUtil.isSuperAdmin()) {
+            System.out.println("=== 超级管理员，不执行数据权限过滤 ===");
+        } else {
+            System.out.println("=== 非超级管理员，但未获取到当前用户手机号，跳过数据过滤 ===");
+        }
+        
         resList.forEach(deliveryLogVo -> {
             String warningType = deliveryLogVo.getWarningType();
             if(StringUtils.isNotEmpty(warningType)){
                 deliveryLogVo.setWarningTypeDesc(EnumUtil.getEnumConstant(WarningStatusAdminEnum.class , Integer.parseInt(warningType)).getDescription());
             }
         });
-        return new PageResultResponse(result.getTotal(), resList);
+        
+        // 更新分页信息
+        long filteredTotal = resList.size();
+        return new PageResultResponse(filteredTotal, resList);
     }
 
     @Override

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/business/service/impl/LoginServiceImpl.java

@@ -12,6 +12,7 @@ import com.aiotagro.cattletrade.business.entity.SysUser;
 import com.aiotagro.cattletrade.business.mapper.SysMenuMapper;
 import com.aiotagro.cattletrade.business.mapper.SysRoleMapper;
 import com.aiotagro.cattletrade.business.mapper.SysUserMapper;
+import com.aiotagro.cattletrade.business.mapper.SysUserMenuMapper;
 import com.aiotagro.cattletrade.business.service.LoginService;
 import com.aiotagro.cattletrade.business.service.TencentSmsCodeService;
 import com.aiotagro.common.core.constant.Constants;
@@ -49,6 +50,9 @@ public class LoginServiceImpl implements LoginService {
     @Resource
     SysRoleMapper roleMapper;
 
+    @Resource
+    SysUserMenuMapper sysUserMenuMapper;
+
 
     @Override
     public AjaxResult sendLoginSmsCode(String mobile) {
@@ -120,8 +124,8 @@ public class LoginServiceImpl implements LoginService {
         log.info("验证读取 mobile: {}", sessionMobile);
         log.info("验证读取 roleId: {}", sessionRoleId);
         
-        // 查询用户权限列表
-        List<String> permissions = queryUserPermissions(user.getRoleId());
+        // 查询用户权限列表（优先使用用户专属权限）
+        List<String> permissions = queryUserPermissions(user.getId(), user.getRoleId());
         StpUtil.getTokenSession().set("permissions", permissions);
         
         // 查询用户角色信息
@@ -142,7 +146,17 @@ public class LoginServiceImpl implements LoginService {
     @Override
     public AjaxResult getUserMenus() {
         Integer userId = SecurityUtil.getCurrentUserId();
-        List<SysMenu> menus = menuMapper.queryMenusByUserId(userId);
+        
+        // 获取当前用户的角色ID
+        SysUser user = userMapper.selectById(userId);
+        if (user == null) {
+            return AjaxResult.error("用户不存在");
+        }
+        
+        // 菜单权限查询：优先使用用户专属菜单权限，否则使用角色菜单权限
+        List<SysMenu> menus = queryUserMenus(userId, user.getRoleId());
+        
+        log.info("=== 用户 {} 菜单查询结果，菜单数量: {}", userId, menus.size());
         return AjaxResult.success("查询成功", menus);
     }
 
@@ -153,24 +167,75 @@ public class LoginServiceImpl implements LoginService {
     }
 
     /**
-     * 查询用户权限列表
+     * 查询用户菜单权限（优先使用用户专属菜单权限）
      * 
+     * @param userId 用户ID
      * @param roleId 角色ID
-     * @return 权限列表
+     * @return 菜单列表
      */
-    private List<String> queryUserPermissions(Integer roleId) {
-        if (roleId == null) {
+    private List<SysMenu> queryUserMenus(Integer userId, Integer roleId) {
+        if (userId == null || roleId == null) {
             return Collections.emptyList();
         }
         
-        // 如果是超级管理员，返回所有权限
+        // 1. 先查询用户专属菜单权限（只查询菜单，不查询操作按钮）
+        List<SysMenu> userMenus = sysUserMenuMapper.selectMenusByUserId(userId);
+        if (userMenus != null && !userMenus.isEmpty()) {
+            // 过滤掉操作按钮（type=2），只保留菜单（type=0,1）
+            List<SysMenu> filteredMenus = userMenus.stream()
+                    .filter(menu -> menu.getType() != 2) // 排除操作按钮
+                    .collect(Collectors.toList());
+            
+            if (!filteredMenus.isEmpty()) {
+                log.info("=== 用户 {} 使用专属菜单权限，菜单数量: {}", userId, filteredMenus.size());
+                return filteredMenus;
+            }
+        }
+        
+        // 2. 如果没有专属菜单权限，使用角色菜单权限
         if (roleId.equals(RoleConstants.SUPER_ADMIN_ROLE_ID)) {
+            log.info("=== 超级管理员用户 {} 使用所有菜单权限（无专属菜单权限）", userId);
+            return menuMapper.selectList(null);
+        }
+        
+        // 3. 普通角色菜单权限
+        log.info("=== 用户 {} 使用角色菜单权限，roleId: {}", userId, roleId);
+        return menuMapper.queryMenusByUserId(userId);
+    }
+
+    /**
+     * 查询用户权限列表（优先使用用户专属权限）
+     * 
+     * @param userId 用户ID
+     * @param roleId 角色ID
+     * @return 权限列表
+     */
+    private List<String> queryUserPermissions(Integer userId, Integer roleId) {
+        if (userId == null || roleId == null) {
+            return Collections.emptyList();
+        }
+        
+        // 1. 先查询用户专属权限（优先于角色权限）
+        List<SysMenu> userMenus = sysUserMenuMapper.selectMenusByUserId(userId);
+        if (userMenus != null && !userMenus.isEmpty()) {
+            log.info("=== 用户 {} 使用专属权限，权限数量: {}", userId, userMenus.size());
+            return userMenus.stream()
+                    .filter(menu -> StringUtils.isNotEmpty(menu.getAuthority()))
+                    .map(SysMenu::getAuthority)
+                    .distinct()
+                    .collect(Collectors.toList());
+        }
+        
+        // 2. 如果没有专属权限，使用角色权限
+        if (roleId.equals(RoleConstants.SUPER_ADMIN_ROLE_ID)) {
+            log.info("=== 超级管理员用户 {} 使用所有权限（无专属权限）", userId);
             return Collections.singletonList(RoleConstants.ALL_PERMISSION);
         }
         
-        // 查询角色关联的菜单权限
-        List<SysMenu> menus = menuMapper.selectMenusByRoleId(roleId);
-        return menus.stream()
+        // 3. 普通角色权限
+        log.info("=== 用户 {} 使用角色权限，roleId: {}", userId, roleId);
+        List<SysMenu> roleMenus = menuMapper.selectMenusByRoleId(roleId);
+        return roleMenus.stream()
                 .filter(menu -> StringUtils.isNotEmpty(menu.getAuthority()))
                 .map(SysMenu::getAuthority)
                 .distinct()

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/common/utils/http/HttpUtils.java

@@ -0,0 +1,205 @@
+package com.aiotagro.cattletrade.common.utils.http;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+/**
+ * HTTP工具类
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+public class HttpUtils {
+    
+    private static final Logger logger = LoggerFactory.getLogger(HttpUtils.class);
+    
+    /**
+     * 发送POST请求
+     */
+    public static String sendPost(String url, Map<String, Object> params) throws Exception {
+        HttpURLConnection connection = null;
+        BufferedReader reader = null;
+        
+        try {
+            // 创建连接
+            URL urlObj = new URL(url);
+            connection = (HttpURLConnection) urlObj.openConnection();
+            connection.setRequestMethod("POST");
+            connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
+            connection.setRequestProperty("Accept", "application/json");
+            connection.setDoOutput(true);
+            connection.setDoInput(true);
+            connection.setConnectTimeout(30000);
+            connection.setReadTimeout(30000);
+            
+            // 发送请求参数
+            if (params != null && !params.isEmpty()) {
+                ObjectMapper mapper = new ObjectMapper();
+                String jsonParams = mapper.writeValueAsString(params);
+                
+                try (OutputStream os = connection.getOutputStream()) {
+                    byte[] input = jsonParams.getBytes(StandardCharsets.UTF_8);
+                    os.write(input, 0, input.length);
+                }
+            }
+            
+            // 读取响应
+            int responseCode = connection.getResponseCode();
+            logger.info("HTTP响应状态码: {}", responseCode);
+            
+            // 读取响应内容
+            StringBuilder response = new StringBuilder();
+            if (responseCode >= 200 && responseCode < 300) {
+                reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
+            } else {
+                reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8));
+            }
+            
+            String line;
+            while ((line = reader.readLine()) != null) {
+                response.append(line);
+            }
+            
+            return response.toString();
+            
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (Exception e) {
+                    logger.error("关闭输入流失败", e);
+                }
+            }
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+    
+    /**
+     * 发送带认证token的POST请求
+     */
+    public static String sendPostWithToken(String url, Map<String, Object> params, String token) throws Exception {
+        HttpURLConnection connection = null;
+        BufferedReader reader = null;
+        
+        try {
+            // 创建连接
+            URL urlObj = new URL(url);
+            connection = (HttpURLConnection) urlObj.openConnection();
+            connection.setRequestMethod("POST");
+            connection.setRequestProperty("Content-Type", "application/json;charset=utf-8");
+            connection.setRequestProperty("Accept", "application/json");
+            if (token != null && !token.isEmpty()) {
+                // 尝试不同的认证头格式
+                connection.setRequestProperty("Authorization", "Bearer " + token);
+                // 也尝试其他可能的头
+                connection.setRequestProperty("X-Auth-Token", token);
+            }
+            connection.setDoOutput(true);
+            connection.setDoInput(true);
+            connection.setConnectTimeout(30000);
+            connection.setReadTimeout(30000);
+            
+            // 发送请求参数
+            if (params != null && !params.isEmpty()) {
+                ObjectMapper mapper = new ObjectMapper();
+                String jsonParams = mapper.writeValueAsString(params);
+                
+                try (OutputStream os = connection.getOutputStream()) {
+                    byte[] input = jsonParams.getBytes(StandardCharsets.UTF_8);
+                    os.write(input, 0, input.length);
+                }
+            }
+            
+            // 读取响应
+            int responseCode = connection.getResponseCode();
+            logger.info("HTTP响应状态码: {}", responseCode);
+            
+            // 读取响应内容
+            StringBuilder response = new StringBuilder();
+            if (responseCode >= 200 && responseCode < 300) {
+                reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
+            } else {
+                reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8));
+            }
+            
+            String line;
+            while ((line = reader.readLine()) != null) {
+                response.append(line);
+            }
+            
+            return response.toString();
+            
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (Exception e) {
+                    logger.error("关闭输入流失败", e);
+                }
+            }
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+    
+    /**
+     * 发送GET请求
+     */
+    public static String sendGet(String url) throws Exception {
+        HttpURLConnection connection = null;
+        BufferedReader reader = null;
+        
+        try {
+            // 创建连接
+            URL urlObj = new URL(url);
+            connection = (HttpURLConnection) urlObj.openConnection();
+            connection.setRequestMethod("GET");
+            connection.setRequestProperty("Accept", "application/json");
+            connection.setConnectTimeout(30000);
+            connection.setReadTimeout(30000);
+            
+            // 读取响应
+            int responseCode = connection.getResponseCode();
+            logger.info("HTTP响应状态码: {}", responseCode);
+            
+            // 读取响应内容
+            StringBuilder response = new StringBuilder();
+            if (responseCode >= 200 && responseCode < 300) {
+                reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8));
+            } else {
+                reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8));
+            }
+            
+            String line;
+            while ((line = reader.readLine()) != null) {
+                response.append(line);
+            }
+            
+            return response.toString();
+            
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (Exception e) {
+                    logger.error("关闭输入流失败", e);
+                }
+            }
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/java/com/aiotagro/cattletrade/job/IotDeviceSyncJob.java

@@ -0,0 +1,37 @@
+package com.aiotagro.cattletrade.job;
+
+import com.aiotagro.cattletrade.business.service.IotDeviceSyncService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+
+/**
+ * IoT设备数据同步定时任务
+ *
+ * @author System
+ * @date 2025-01-16
+ */
+@Component
+public class IotDeviceSyncJob {
+
+    private static final Logger logger = LoggerFactory.getLogger(IotDeviceSyncJob.class);
+
+    @Autowired
+    private IotDeviceSyncService iotDeviceSyncService;
+
+    /**
+     * 每5分钟同步一次IoT设备数据
+     */
+    @Scheduled(fixedRate = 5 * 60 * 1000) // 5分钟
+    public void syncIotDeviceData() {
+        try {
+            logger.info("开始执行IoT设备数据同步定时任务");
+            iotDeviceSyncService.syncIotDeviceData();
+            logger.info("IoT设备数据同步定时任务执行完成");
+        } catch (Exception e) {
+            logger.error("IoT设备数据同步定时任务执行失败", e);
+        }
+    }
+}

tradeCattle/aiotagro-cattle-trade/src/main/resources/mapper/SysMenuMapper.xml

@@ -53,4 +53,15 @@
         ORDER BY m.sort ASC
     </select>
 
+    <select id="selectMenusByPermissions" resultType="com.aiotagro.cattletrade.business.entity.SysMenu">
+        SELECT DISTINCT m.*
+        FROM sys_menu m
+        WHERE m.is_delete = 0
+          AND m.authority IN
+        <foreach collection="permissions" item="permission" open="(" separator="," close=")">
+            #{permission}
+        </foreach>
+        ORDER BY m.sort ASC
+    </select>
+
 </mapper>

tradeCattle/aiotagro-cattle-trade/src/main/resources/mapper/SysUserMenuMapper.xml

@@ -0,0 +1,36 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.aiotagro.cattletrade.business.mapper.SysUserMenuMapper">
+
+    <!-- 通用查询映射结果 -->
+    <resultMap id="BaseResultMap" type="com.aiotagro.cattletrade.business.entity.SysUserMenu">
+        <id column="id" property="id" />
+        <result column="user_id" property="userId" />
+        <result column="menu_id" property="menuId" />
+        <result column="create_time" property="createTime" />
+    </resultMap>
+
+    <!-- 通用查询结果列 -->
+    <sql id="Base_Column_List">
+        id, user_id, menu_id, create_time
+    </sql>
+
+    <!-- 根据用户ID查询菜单列表（包含权限信息） -->
+    <select id="selectMenusByUserId" resultType="com.aiotagro.cattletrade.business.entity.SysMenu">
+        SELECT DISTINCT m.*
+        FROM sys_menu m
+        INNER JOIN sys_user_menu um ON m.id = um.menu_id
+        WHERE um.user_id = #{userId}
+          AND m.is_delete = 0
+        ORDER BY m.sort ASC
+    </select>
+
+    <!-- 根据用户ID查询已分配的菜单ID列表 -->
+    <select id="selectMenuIdsByUserId" resultType="java.lang.Integer">
+        SELECT menu_id
+        FROM sys_user_menu
+        WHERE user_id = #{userId}
+        ORDER BY create_time ASC
+    </select>
+
+</mapper>

tradeCattle/fix_delivery_id_field_type.sql

@@ -0,0 +1,5 @@
+-- 修改iot_device_data表的delivery_id字段类型为varchar
+-- 因为运单号是字符串格式，如"ZC20251023134423"
+
+ALTER TABLE `iot_device_data` 
+MODIFY COLUMN `delivery_id` varchar(50) DEFAULT NULL COMMENT '运单号';

tradeCattle/fix_delivery_id_relation.sql

@@ -0,0 +1,10 @@
+-- 修改iot_device_data表的delivery_id字段，关联到delivery表的主键
+-- 将delivery_id改为整数类型，关联delivery表的id字段
+
+ALTER TABLE `iot_device_data` 
+MODIFY COLUMN `delivery_id` int(11) DEFAULT NULL COMMENT '装车订单ID，关联delivery表主键';
+
+-- 添加外键约束（可选）
+-- ALTER TABLE `iot_device_data` 
+-- ADD CONSTRAINT `fk_iot_device_delivery` 
+-- FOREIGN KEY (`delivery_id`) REFERENCES `delivery`(`id`) ON DELETE SET NULL;