//! H5 用户端 API //! //! 提供微信扫码充电的 H5 页面所需的全部后端接口： //! - GET /api/dashboard — 首页仪表盘数据 //! - GET /api/cabinets — 设备列表（按项目过滤） //! - GET /api/cabinets/:id — 设备详情（含仓板+仓体状态） //! - GET /api/cabinets/abstract/:aid — 通过抽象ID查设备（扫码入口，免认证） //! - GET /api/compartments/:id — 仓体/通道详情 //! - POST /api/charge/start — 开始充电 //! - POST /api/charge/stop — 停止充电 //! - POST /api/door/open — 开门 //! - GET /api/cabinets/scan/:abstract_id — 扫码验证 //! - GET /api/my-organizations — 当前用户可见的组织（仅需登录；工厂全量 / 客户仅本组织） use axum::extract::{Multipart, Path, Query, State}; use axum::Json; use redis; use serde::{Deserialize, Serialize}; use serde_json::{json, Value}; use std::collections::HashMap; use std::io::Write; use uuid::Uuid; use crate::commands::{AppState, DeviceCommand, ROUTE_DEV_ID_FIELD}; use crate::error::AppError; use crate::middleware::auth::{self, CurrentUser}; use super::cabinet_tree::{derive_channel_flags, ChannelCounts}; // --------------------------------------------------------------------------- // 请求体定义 // --------------------------------------------------------------------------- /// 充电控制请求体（开始/停止充电、开门共用） #[derive(Debug, Deserialize)] pub(crate) struct CompartmentActionInput { compartment_id: i64, } /// 问题反馈请求体 #[derive(Debug, Deserialize)] pub(crate) struct FeedbackInput { /// 反馈内容 content: String, /// 联系方式（可选） contact: Option, /// 图片URL列表（可选） images: Option>, } /// 设备列表查询参数 #[derive(Debug, Deserialize)] pub(crate) struct CabinetListQuery { project_id: Option, org_id: Option, } /// 仪表盘查询参数 #[derive(Debug, Deserialize)] pub(crate) struct DashboardQuery { org_id: Option, } // --------------------------------------------------------------------------- // 行映射结构体 // --------------------------------------------------------------------------- /// 项目简要信息行 #[derive(Debug, sqlx::FromRow)] struct ProjectRow { id: i64, name: String, } /// 柜子列表行（含通道统计） /// /// ⚠️ 这里**只保留 DB 能给准的三个计数**（`channel_count` / `idle_count` / `charging_count`）。 /// `full_count` / `fault_count` 不在此结构体里 —— `compartments.status` 全仓只写 0/1（占用语义）， /// DB 永远给不出充满/故障，它们只能由 Redis 通道状态派生（见 [`CabinetRealtimeMaps::counts`]）。 #[derive(Debug, sqlx::FromRow)] struct H5CabinetRow { id: i64, abstract_id: String, name: Option, status: i8, project_id: Option, imei: Option, iccid: Option, address: Option, latitude: Option, longitude: Option, channel_count: i64, idle_count: i64, charging_count: i64, } /// 仓控板行 #[derive(Debug, sqlx::FromRow)] struct H5CabinBoardRow { id: i64, board_id: i8, status: i8, } /// 仓体行 #[derive(Debug, sqlx::FromRow)] struct H5CompartmentRow { id: i64, channel_id: i8, status: i8, } /// 充电记录简要行 #[derive(Debug, sqlx::FromRow)] struct ChargeRecordBriefRow { id: i64, start_time: Option, end_time: Option, energy: Option, } /// 柜子 IMEI + 仓控板 + 通道查询行（用于指令下发） #[derive(Debug, sqlx::FromRow)] struct CabinetImeiRow { cabinet_id: i64, imei: String, board_id: i8, channel_id: i8, } // --------------------------------------------------------------------------- // 仪表盘 // --------------------------------------------------------------------------- /// 数据范围（项目级）过滤片段：`cond` 以 ` AND ` 开头（拼在已有 WHERE 之后），`binds` 顺序与占位符一致 /// /// 未配置数据范围（或总管理员）时 `cond` 为空串、`binds` 为空 ⇒ 各统计 SQL 与今天逐字一致。 struct ScopeFilter<'a> { cond: &'a str, binds: &'a [String], } /// 构造作用于 `projects p` 的数据范围过滤片段 fn scope_filter_for_projects(scope: &crate::middleware::auth::UserScope) -> (String, Vec) { scope.project_condition("p.id") } /// 仪表盘首页 /// /// GET /api/h5/dashboard — H5 首页仪表盘数据（带组织隔离 + 数据范围） pub async fn get_dashboard( user: CurrentUser, State(state): State, Query(query): Query, ) -> Result, AppError> { let pool = &state.mysql; // 根据角色确定组织过滤条件 // 总管理员可通过 org_id 参数切换组织 let is_super = user.role_level >= 2 && query.org_id.is_none(); let org_id = query.org_id.or(user.organization_id); // 数据范围（项目级）：总管理员豁免；未配置 = 不限制（片段为空） let (scope_cond, scope_binds) = scope_filter_for_projects(&user.effective_scope()); let scope = ScopeFilter { cond: &scope_cond, binds: &scope_binds }; // 统计在线柜子数（带组织隔离；**以 Redis 为准**，与 `cabinets.status` 配置态无关） let online_cabinets = count_online_cabinets(&state, is_super, org_id, &scope).await?; // 统计总通道数（带组织隔离） let total_channels = count_total_compartments(pool, is_super, org_id, &scope).await?; // 统计充电中仓体数（带组织隔离） let charging_count = count_compartments_by_status(pool, is_super, org_id, 1, &scope).await?; // 统计空闲仓体数（带组织隔离）：`status = 0` = 空闲（占用语义，DB 给得准） let idle_channels = count_compartments_by_status(pool, is_super, org_id, 0, &scope).await?; // 充满 / 故障：**DB 给不出**（`compartments.status` 只写 0/1，2/3 永不出现）， // 只能由通道实时状态派生 —— 与设备列表/PC 设备卡片同一套规则（`derive_channel_flags`）。 // 拿不到 Redis 数据（设备离线 / 无通道键 / Redis 不可用）时按 0 计，不猜测。 let (full_count, fault_count) = count_derived_full_fault(&state, is_super, org_id, &scope).await; // `fault_channels` 与 `fault_count` 同源同义（历史字段名重复），一并给派生值 let fault_channels = fault_count; // 今日充电次数（带组织隔离） let today_charge_count = count_today_charges(pool, is_super, org_id, &scope).await?; // 今日充电量（kWh，带组织隔离） let today_energy = sum_today_energy(pool, is_super, org_id, &scope).await?; // 今日充电时长（小时，带组织隔离） let today_charge_hours = sum_today_charge_hours(pool, is_super, org_id, &scope).await?; // 故障告警（取最近10条故障仓体，返回项目名+柜名） let alerts = fetch_fault_alerts(pool, is_super, org_id, &scope).await?; // 项目摘要（带组织过滤 + 数据范围） let projects = fetch_project_summaries(pool, &user, org_id).await?; Ok(Json(json!({ "code": 0, "data": { "online_cabinets": online_cabinets, "total_channels": total_channels, "charging_count": charging_count, "idle_channels": idle_channels, "full_count": full_count, "fault_channels": fault_channels, "fault_count": fault_count, "today_charge_count": today_charge_count, "today_energy_kwh": today_energy, "today_charge_hours": today_charge_hours, "alerts": alerts, "projects": projects, }, "message": "ok" }))) } /// 设备级 HMGET 的**字段清单**（顺序 = pipeline 命令顺序 = 解析下标）。 /// /// 下标：`rssi`(0) / `pow_fail_dc`(1) / `pow_fail_ac`(2) / `temp`(3) / /// `cabinet_status1`(4) / `cabinet_status2`(5) / **`online`(6，追加在末尾)**。 /// ⚠️ 新增字段**只能追加在末尾**（前面的下标被下面的解析逐一对齐）。 const CABINET_HMGET_FIELDS: [&str; 7] = [ "rssi", "pow_fail_dc", "pow_fail_ac", "temp", "cabinet_status1", "cabinet_status2", // 实时在线：字段名直接取自 `cabinet_tree`（与设备列表 `is_online` 同一常量，跨模块同源） super::cabinet_tree::DEVICE_ONLINE_FIELD, ]; /// 在线字段在 [`CABINET_HMGET_FIELDS`] 中的下标（追加在末尾） const CABINET_HMGET_ONLINE_IDX: usize = 6; /// 首页「在线设备」的**取数 SQL**：只取可见柜的 IMEI，在线与否交给 Redis 判定。 /// /// **不含任何 `status` 条件** —— `cabinets.status` 是启用/禁用**配置态**， /// 全仓没有任何写入方会把它写成 0（离线），拿它统计会在"一台设备都没连"时 /// 返回"全部在线"。此处只负责按组织隔离 + 数据范围取出 IMEI。 fn online_cabinet_imeis_sql(is_super: bool, scope_cond: &str) -> String { if is_super { "SELECT cab.imei FROM cabinets cab WHERE cab.imei IS NOT NULL".to_string() } else { format!( r#"SELECT cab.imei FROM cabinets cab INNER JOIN projects p ON cab.project_id = p.id WHERE cab.imei IS NOT NULL AND p.organization_id = ?{}"#, scope_cond ) } } /// 统计在线柜子数（**以 Redis 为准**，带组织隔离 + 数据范围） /// /// # 为什么不再用 `cabinets.status = 1` /// `cabinets.status` 是启用/禁用**配置态**（`2` = 禁用，其余 = 启用）， /// 全仓**没有任何写入方会把它写成 0（离线）** ⇒ 按它统计会在"一台设备都没连"时 /// 依然返回"全部在线"。现在改为：先按组织隔离 + 范围取出可见柜的 IMEI， /// 再用一次 pipeline 查 `device:{imei}.online`（判据与设备列表 `is_online` 同一纯函数 /// [`cabinet_tree::is_device_online`]）。 async fn count_online_cabinets( state: &AppState, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result { // 总管理员：全部柜子的 IMEI，不带任何组织条件（豁免） if is_super { return finish_online_count(state, online_cabinet_imeis_sql(true, ""), Vec::new()).await; } // 客户侧账号**无组织归属 ⇒ 空集**（绝不退化成"全部"），与 `visible_org_scope` 同口径 let Some(oid) = org_id else { return Ok(0); }; // 组织隔离 + 数据范围（绑定顺序 = 占位符顺序：先组织，再范围） let mut binds: Vec = vec![oid.to_string()]; binds.extend(scope.binds.iter().cloned()); finish_online_count(state, online_cabinet_imeis_sql(false, scope.cond), binds).await } /// 执行在线取数 SQL，并按 Redis 判据统计在线台数（`binds` 顺序 = 占位符顺序） async fn finish_online_count( state: &AppState, sql: String, binds: Vec, ) -> Result { let mut query = sqlx::query_scalar::<_, Option>(&sql); for bind in &binds { query = query.bind(bind); } let imeis: Vec = query .fetch_all(&state.mysql) .await? .into_iter() .flatten() .collect(); // Redis 一次 pipeline 批量判定（**零 N 次单查**），口径同设备列表 is_online Ok(super::cabinet_tree::count_online_devices(state, &imeis).await) } /// 统计总仓体数（带组织隔离 + 数据范围） async fn count_total_compartments( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result { if !is_super && org_id.is_none() { return Ok(0); } let count: i64 = if is_super { sqlx::query_scalar( r#"SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets c ON cb.cabinet_id = c.id WHERE c.status = 1"#, ) .fetch_one(pool) .await? } else { let sql = format!( r#"SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets c ON cb.cabinet_id = c.id JOIN projects p ON c.project_id = p.id WHERE c.status = 1 AND p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, i64>(&sql).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_one(pool).await? }; Ok(count) } /// 按状态统计仓体数（带组织隔离 + 数据范围，通过 cabin_boards → cabinets → projects 链路） async fn count_compartments_by_status( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, status: i8, scope: &ScopeFilter<'_>, ) -> Result { if !is_super && org_id.is_none() { return Ok(0); } let count: i64 = if is_super { sqlx::query_scalar("SELECT COUNT(*) FROM compartments WHERE status = ?") .bind(status) .fetch_one(pool) .await? } else { let sql = format!( r#"SELECT COUNT(*) FROM compartments comp INNER JOIN cabin_boards cb ON comp.cabin_board_id = cb.id INNER JOIN cabinets cab ON cb.cabinet_id = cab.id INNER JOIN projects p ON cab.project_id = p.id WHERE comp.status = ? AND p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, i64>(&sql).bind(status).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_one(pool).await? }; Ok(count) } /// 统计范围内的「充满 / 故障」通道数（**由通道实时状态派生**，带组织隔离） /// /// 为什么不能用 SQL：`compartments.status` 只表达**占用**语义（`0 空闲 / 1 充电中`）， /// 平台从不写 2/3，所以 `WHERE comp.status = 2/3` 永远返回 0 —— 这正是首页统计行 /// "充满""故障"恒为 0 的原因。改为：按可见范围取柜子 → 拼通道 key → 一次 pipeline /// 读 `batt_status`/`pow_status` → 复用 `cabinet_tree::derive_channel_counts` /// 的优先级（fault > full > charging > idle）分区计数。 /// /// 可见范围与 [`count_compartments_by_status`] 保持一致：总管理员 = 全部柜子；否则 = 本组织项目下的柜子。 /// **拿不到 Redis 数据时按 0 计**（离线 / 无通道键 / Redis 不可用），绝不猜测。 async fn count_derived_full_fault( state: &AppState, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> (i64, i64) { let cabinet_ids = match fetch_scope_cabinet_ids(&state.mysql, is_super, org_id, scope).await { Ok(ids) => ids, Err(e) => { tracing::error!("[h5] 首页计数：柜子范围查询失败，充满/故障按 0 计 err={}", e); return (0, 0); } }; let entries = match super::cabinet_tree::fetch_channel_keys(&state.mysql, &cabinet_ids).await { Ok(entries) => entries, Err(e) => { tracing::error!("[h5] 首页计数：通道 key 查询失败，充满/故障按 0 计 err={}", e); return (0, 0); } }; let counts: HashMap = super::cabinet_tree::derive_counts_by_cabinet(state, &entries).await; counts .values() .fold((0_i64, 0_i64), |(full, fault), c| (full + c.2, fault + c.3)) } /// 取统计范围内的柜子 ID：总管理员 = 全部柜子；组织用户 = 本组织**且落在数据范围内**的柜子；无组织 = 空集 /// （口径与 [`count_compartments_by_status`] 完全一致） async fn fetch_scope_cabinet_ids( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result, sqlx::Error> { if is_super { return sqlx::query_scalar("SELECT id FROM cabinets").fetch_all(pool).await; } match org_id { Some(oid) => { let sql = format!( r#"SELECT c.id FROM cabinets c INNER JOIN projects p ON c.project_id = p.id WHERE p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, i64>(&sql).bind(oid); for bind in scope.binds { query = query.bind(bind); } query.fetch_all(pool).await } // `organization_id` 为 NULL 的客户侧账号看不到任何设备（空集，不是报错，也不退化成"全部"） None => Ok(Vec::new()), } } /// 今日充电次数（带组织隔离 + 数据范围） async fn count_today_charges( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result { if !is_super && org_id.is_none() { return Ok(0); } let count: i64 = if is_super { sqlx::query_scalar( "SELECT COUNT(*) FROM charge_records WHERE DATE(start_time) = CURDATE()", ) .fetch_one(pool) .await? } else { let sql = format!( r#"SELECT COUNT(*) FROM charge_records cr INNER JOIN cabinets cab ON cr.cabinet_id = cab.id INNER JOIN projects p ON cab.project_id = p.id WHERE DATE(cr.start_time) = CURDATE() AND p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, i64>(&sql).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_one(pool).await? }; Ok(count) } /// 今日充电量（kWh，带组织隔离 + 数据范围） async fn sum_today_energy( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result { if !is_super && org_id.is_none() { return Ok(0); } let energy: Option = if is_super { sqlx::query_scalar( "SELECT CAST(COALESCE(SUM(energy), 0) AS SIGNED) FROM charge_records WHERE DATE(start_time) = CURDATE()", ) .fetch_one(pool) .await? } else { let sql = format!( r#"SELECT CAST(COALESCE(SUM(cr.energy), 0) AS SIGNED) FROM charge_records cr INNER JOIN cabinets cab ON cr.cabinet_id = cab.id INNER JOIN projects p ON cab.project_id = p.id WHERE DATE(cr.start_time) = CURDATE() AND p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, Option>(&sql).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_one(pool).await? }; Ok(energy.unwrap_or(0)) } /// 今日充电时长（秒，带组织隔离 + 数据范围） async fn sum_today_charge_hours( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result { if !is_super && org_id.is_none() { return Ok(0); } // 计算总秒数（未结束的记录用 NOW() 代替 end_time） let total_seconds: Option = if is_super { sqlx::query_scalar( r#"SELECT CAST(COALESCE(SUM( TIMESTAMPDIFF(SECOND, start_time, COALESCE(end_time, NOW())) ), 0) AS SIGNED) FROM charge_records WHERE DATE(start_time) = CURDATE()"#, ) .fetch_one(pool) .await? } else { let sql = format!( r#"SELECT CAST(COALESCE(SUM( TIMESTAMPDIFF(SECOND, cr.start_time, COALESCE(cr.end_time, NOW())) ), 0) AS SIGNED) FROM charge_records cr INNER JOIN cabinets cab ON cr.cabinet_id = cab.id INNER JOIN projects p ON cab.project_id = p.id WHERE DATE(cr.start_time) = CURDATE() AND p.organization_id = ?{}"#, scope.cond ); let mut query = sqlx::query_scalar::<_, Option>(&sql).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_one(pool).await? }; Ok(total_seconds.unwrap_or(0)) } /// 获取故障告警列表（返回项目名+柜名+通道号，带组织隔离 + 数据范围） async fn fetch_fault_alerts( pool: &sqlx::MySqlPool, is_super: bool, org_id: Option, scope: &ScopeFilter<'_>, ) -> Result, AppError> { if !is_super && org_id.is_none() { return Ok(vec![]); } let base_sql = if is_super { r#"SELECT IFNULL(p.name, '') AS project, IFNULL(cab.name, cab.abstract_id) AS cabinet, comp.channel_id FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets cab ON cb.cabinet_id = cab.id LEFT JOIN projects p ON cab.project_id = p.id WHERE comp.status = 2 ORDER BY comp.updated_at DESC LIMIT 10"# .to_string() } else { format!( r#"SELECT IFNULL(p.name, '') AS project, IFNULL(cab.name, cab.abstract_id) AS cabinet, comp.channel_id FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets cab ON cb.cabinet_id = cab.id INNER JOIN projects p ON cab.project_id = p.id WHERE comp.status = 2 AND p.organization_id = ?{} ORDER BY comp.updated_at DESC LIMIT 10"#, scope.cond ) }; let rows: Vec<(String, String, i8)> = if is_super { sqlx::query_as(&base_sql).fetch_all(pool).await? } else { let mut query = sqlx::query_as::<_, (String, String, i8)>(&base_sql).bind(org_id.unwrap()); for bind in scope.binds { query = query.bind(bind); } query.fetch_all(pool).await? }; Ok(rows .into_iter() .map(|(project, cabinet, channel)| { json!({ "project": project, "cabinet": cabinet, "channel": channel, "alert_type": "fault", }) }) .collect()) } // --- 项目摘要 SQL（由函数体原样搬移，WHERE/JOIN/SELECT 未改动） --- /// 指定组织下的项目 const PROJECTS_BY_ORG_SQL: &str = "SELECT id, name FROM projects WHERE organization_id = ? ORDER BY id"; /// 全部项目（总管理员未指定组织时） const PROJECTS_ALL_SQL: &str = "SELECT id, name FROM projects ORDER BY id"; /// 项目下柜子数量 const PROJECT_CABINET_COUNT_SQL: &str = "SELECT COUNT(*) FROM cabinets WHERE project_id = ?"; /// 项目下充电中仓体数量 const PROJECT_CHARGING_COUNT_SQL: &str = r#"SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets cab ON cb.cabinet_id = cab.id WHERE cab.project_id = ? AND comp.status = 1"#; /// 项目下空闲仓体数量 const PROJECT_IDLE_COUNT_SQL: &str = r#"SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets cab ON cb.cabinet_id = cab.id WHERE cab.project_id = ? AND comp.status = 0"#; /// 项目下故障仓体数量 const PROJECT_FAULT_COUNT_SQL: &str = r#"SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id JOIN cabinets cab ON cb.cabinet_id = cab.id WHERE cab.project_id = ? AND comp.status = 2"#; /// 查询用户可见的项目摘要（含柜子/充电/空闲/故障统计） async fn fetch_project_summaries( pool: &sqlx::MySqlPool, user: &CurrentUser, org_id: Option, ) -> Result, AppError> { let projects = fetch_visible_projects(pool, user, org_id).await?; let mut result = Vec::with_capacity(projects.len()); for p in &projects { result.push(fetch_project_summary(pool, p).await?); } Ok(result) } /// 获取用户可见的项目（优先使用查询参数 org_id） /// /// **数据范围（项目级）**：组织隔离给出"哪些组织的项目"，再按 `CurrentUser::scope` /// 过滤掉范围外的项目（未配置 = 不限制；总管理员豁免）。 async fn fetch_visible_projects( pool: &sqlx::MySqlPool, user: &CurrentUser, org_id: Option, ) -> Result, AppError> { let filter_org = org_id.or(user.organization_id); let projects: Vec = if user.role_level >= 2 { if let Some(oid) = filter_org { sqlx::query_as::<_, ProjectRow>(PROJECTS_BY_ORG_SQL) .bind(oid) .fetch_all(pool) .await? } else { sqlx::query_as::<_, ProjectRow>(PROJECTS_ALL_SQL) .fetch_all(pool) .await? } } else if let Some(org_id) = user.organization_id { sqlx::query_as::<_, ProjectRow>(PROJECTS_BY_ORG_SQL) .bind(org_id) .fetch_all(pool) .await? } else { vec![] }; let scope = user.effective_scope(); if scope.is_unrestricted() { return Ok(projects); } Ok(projects .into_iter() .filter(|p| scope.allows_project(Some(p.id))) .collect()) } /// 汇总单个项目的柜子数 / 充电中 / 空闲 / 故障仓体数 async fn fetch_project_summary( pool: &sqlx::MySqlPool, p: &ProjectRow, ) -> Result { let cabinet_count: i64 = sqlx::query_scalar(PROJECT_CABINET_COUNT_SQL) .bind(p.id) .fetch_one(pool) .await?; let charging: i64 = sqlx::query_scalar(PROJECT_CHARGING_COUNT_SQL) .bind(p.id) .fetch_one(pool) .await?; let idle: i64 = sqlx::query_scalar(PROJECT_IDLE_COUNT_SQL) .bind(p.id) .fetch_one(pool) .await?; let fault: i64 = sqlx::query_scalar(PROJECT_FAULT_COUNT_SQL) .bind(p.id) .fetch_one(pool) .await?; Ok(json!({ "id": p.id, "name": p.name, "cabinet_count": cabinet_count, "charging": charging, "idle": idle, "fault": fault, })) } // --------------------------------------------------------------------------- // 可见组织（小程序专用） // --------------------------------------------------------------------------- /// 可见组织行（**只暴露必要字段**：`id` / `name`） /// /// 字段名与 `GET /api/organizations`（管理端 `OrganizationRow`）保持一致，便于前端复用同一类型； /// 但**故意不带** `parent_id` / `disabled` 等管理端字段 —— 小程序只需要渲染组织名。 #[derive(Debug, Serialize, sqlx::FromRow)] struct VisibleOrganizationRow { id: i64, name: String, } /// 工厂侧（总管理员）可见全部组织 const VISIBLE_ORGS_ALL_SQL: &str = "SELECT id, name FROM organizations ORDER BY id"; /// 客户侧用户只可见自己所属组织（`users.organization_id`） const VISIBLE_ORGS_BY_ID_SQL: &str = "SELECT id, name FROM organizations WHERE id = ?"; /// 可见组织范围（由 [`visible_org_scope`] 依据角色算出；纯数据，便于单测） #[derive(Debug, PartialEq, Eq)] enum VisibleOrgScope { /// 工厂/总管理员：全部组织 All, /// 组织管理员/操作员：仅本组织 Own(i64), /// 无组织归属：空集（**返回空数组，不报错**） Empty, } /// 角色等级 + 所属组织 → 可见组织范围（纯函数，组织隔离的唯一判定点） /// /// **组织可见性口径（全系统统一，见 AGENTS.md「组织架构」）：** /// - `role_level >= 2`（工厂/总管理员）→ 全部组织； /// - 其他（组织管理员 `1` / 操作员 `0`）→ 仅 `users.organization_id` 指向的那一个组织； /// - `organization_id` 为 NULL → 空集。 fn visible_org_scope(role_level: i32, organization_id: Option) -> VisibleOrgScope { if role_level >= 2 { return VisibleOrgScope::All; } match organization_id { Some(org_id) => VisibleOrgScope::Own(org_id), None => VisibleOrgScope::Empty, } } /// GET /api/my-organizations — 当前登录用户**可见**的组织列表（小程序「选择组织」用） /// /// **权限：仅需登录**（与 `GET /api/dashboard` 一致，内部按角色做组织隔离）， /// **不校验 `org:view`** —— 操作员（`normal_user`）的授权清单里没有该权限码 /// （`db/migrate.rs::seed_roles`），沿用管理端接口会 403、组织弹层永远为空。 /// /// **隔离（核心安全边界）**：响应只包含当前用户有权看到的组织 —— /// 工厂（`role_level >= 2`）全量；客户侧（组织管理员/操作员）**只有自己所属组织**， /// 绝不把全量组织泄露给客户角色。 /// /// 管理端的 `GET /api/organizations`（`org:view` + 全量）语义保持原样，不做任何改动。 pub async fn list_my_organizations( user: CurrentUser, State(state): State, ) -> Result, AppError> { let pool = &state.mysql; let rows: Vec = match visible_org_scope(user.role_level, user.organization_id) { // 工厂：全部组织 VisibleOrgScope::All => { sqlx::query_as::<_, VisibleOrganizationRow>(VISIBLE_ORGS_ALL_SQL) .fetch_all(pool) .await? } // 客户侧：**唯一的组织过滤点** —— `WHERE id = ` VisibleOrgScope::Own(org_id) => { sqlx::query_as::<_, VisibleOrganizationRow>(VISIBLE_ORGS_BY_ID_SQL) .bind(org_id) .fetch_all(pool) .await? } // 无组织归属：空数组（不是错误） VisibleOrgScope::Empty => Vec::new(), }; // 包装格式与 `GET /api/organizations` 完全一致（`data` 直接是组织数组，字段 id/name） Ok(Json(json!({ "code": 0, "data": rows, "message": "ok" }))) } // --------------------------------------------------------------------------- // 设备列表 // --------------------------------------------------------------------------- // --- 设备列表 SQL（由原函数体逐字搬移；`channel_count` / `idle_count` / `charging_count` 子查询与 CAST 未改动） --- // // ⚠️ **口径变更（产品决定，本次）**：`compartments.status` 只表达**占用**语义 // （`0 空闲 / 1 充电中` —— 平台只写这两个值，全仓没有任何写入点会写 2/3）， // "充满 / 故障"**不落库**。因此这 5 条分支 SQL（按项目 / 项目+组织 / 组织 / 全部 / 本组织） // 里的 `full_count` / `fault_count` 子查询（`comp.status = 2 / 3`）已**整体删除** // —— 它们在 DB 里恒为 0，留着只是白白多跑两次子查询；改为由通道实时状态派生： // [`load_cabinet_realtime`] 批量读通道状态 → `cabinet_tree::derive_channel_counts` // → [`build_cabinet_list`] 写回响应。**5 条分支共用同一条派生链路，一处在、处处在。** // 响应字段名 `full_count` / `fault_count`（以及 `idle_count` / `charging_count`）**保持不变**。 /// 项目过滤 + 总管理员（不带组织条件） const CABINETS_BY_PROJECT_SQL: &str = r#"SELECT c.id, c.abstract_id, c.name, c.status, c.imei, c.iccid, c.project_id, c.address, CAST(c.latitude AS CHAR) AS latitude, CAST(c.longitude AS CHAR) AS longitude, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id) as channel_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 0) as idle_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 1) as charging_count FROM cabinets c WHERE c.project_id = ?"#; /// 项目过滤 + 企业管理员（额外校验项目归属组织） const CABINETS_BY_PROJECT_AND_ORG_SQL: &str = r#"SELECT c.id, c.abstract_id, c.name, c.status, c.imei, c.iccid, c.project_id, c.address, CAST(c.latitude AS CHAR) AS latitude, CAST(c.longitude AS CHAR) AS longitude, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id) as channel_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 0) as idle_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 1) as charging_count FROM cabinets c INNER JOIN projects p ON c.project_id = p.id WHERE c.project_id = ? AND p.organization_id = ?"#; /// 总管理员按组织过滤 const CABINETS_BY_ORG_SQL: &str = r#"SELECT c.id, c.abstract_id, c.name, c.status, c.imei, c.iccid, c.project_id, c.address, CAST(c.latitude AS CHAR) AS latitude, CAST(c.longitude AS CHAR) AS longitude, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id) as channel_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 0) as idle_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 1) as charging_count FROM cabinets c INNER JOIN projects p ON c.project_id = p.id WHERE p.organization_id = ?"#; /// 总管理员查看全部 const CABINETS_ALL_SQL: &str = r#"SELECT c.id, c.abstract_id, c.name, c.status, c.imei, c.iccid, c.project_id, c.address, CAST(c.latitude AS CHAR) AS latitude, CAST(c.longitude AS CHAR) AS longitude, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id) as channel_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 0) as idle_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 1) as charging_count FROM cabinets c"#; /// 企业管理员只看本组织 const CABINETS_BY_USER_ORG_SQL: &str = r#"SELECT c.id, c.abstract_id, c.name, c.status, c.imei, c.iccid, c.project_id, c.address, CAST(c.latitude AS CHAR) AS latitude, CAST(c.longitude AS CHAR) AS longitude, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id) as channel_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 0) as idle_count, (SELECT COUNT(*) FROM compartments comp JOIN cabin_boards cb ON comp.cabin_board_id = cb.id WHERE cb.cabinet_id = c.id AND comp.status = 1) as charging_count FROM cabinets c INNER JOIN projects p ON c.project_id = p.id WHERE p.organization_id = ?"#; /// 柜子所属组织是否禁用（前端徽标用，`{}` 处填入 `?` 占位符列表） const PROJECT_ORG_DISABLED_SQL: &str = r#"SELECT p.id, IFNULL(o.disabled, 0) FROM projects p LEFT JOIN organizations o ON p.organization_id = o.id WHERE p.id IN ({})"#; /// 设备列表的 Redis 实时状态（按 IMEI 索引） #[derive(Default)] struct CabinetRealtimeMaps { rssi: HashMap>, dc: HashMap>, ac: HashMap>, temp: HashMap>, /// 设备在线（Redis `device:{imei}` 的 `online` 字段） /// /// 判据与 PC 设备列表的 `is_online` **同源**（`cabinet_tree::device_online_flag`）： /// `Some(true)` 在线 / `Some(false)` 明确离线 / `None` = **无数据**（键或字段不存在）。 /// ⚠️ 与 DB 的 `cabinets.status`（启用/禁用**配置态**）**没有任何关系** —— /// 小程序卡片不得再用 `cab.status` 推断在线。 online: HashMap>, /// **柜级**柜体状态1（协议 §3.8，2 位小写 hex 原样透出；`"10"` = 柜门打开） /// /// 取不到（Redis 缺字段 / 设备离线 / Redis 不可用）→ `None` → 响应 `null`， /// **绝不落 `"00"`**（`"00"` 是"全部正常"的有效值）。位域解析在前端纯函数里做。 status1: HashMap>, /// **柜级**柜体状态2（协议 §3.8，bit0 声光报警 / bit1 柜门打开超时） status2: HashMap>, /// 柜子ID → 通道派生四计数 `(idle, charging, full, fault)` /// /// 只有 `.2`（充满）/ `.3`（故障）会被写进响应：`idle_count` / `charging_count` /// 用 DB 的占用值（`compartments.status` 0/1），**派生值不覆盖它们**。 /// 表里没有的柜子（无通道 / Redis 不可用）→ 调用方按 `(0,0,0,0)` 处理， /// **离线无法判定，充满数与故障数一律记 0**。 counts: HashMap, } /// GET /api/h5/cabinets — H5 设备列表（可按项目过滤，带组织隔离） pub async fn get_cabinets( user: CurrentUser, State(state): State, Query(query): Query, ) -> Result, AppError> { // 权限校验 auth::check_permission(&user, "device:view")?; let pool = &state.mysql; // 组织隔离查询：设备基础信息 + 通道统计 let rows = fetch_cabinet_rows(pool, &user, query.project_id, query.org_id).await?; // 从Redis批量查RSSI + pow_fail + temp let realtime = load_cabinet_realtime(&state, &rows).await; // 查询柜子所属组织是否禁用（用于前端徽标） let org_disabled_map = load_org_disabled_map(pool, &rows).await; let list = build_cabinet_list(rows, &realtime, &org_disabled_map); Ok(Json(json!({ "code": 0, "data": list, "message": "ok" }))) } /// 按「项目 / 角色」优先级查询用户可见的柜子行（分支顺序与原实现逐条对应） /// /// 最后统一叠加**数据范围（项目级）**的内存过滤：未配置范围时原样返回（与今天完全一致）。 async fn fetch_cabinet_rows( pool: &sqlx::MySqlPool, user: &CurrentUser, project_id: Option, org_id: Option, ) -> Result, AppError> { let rows = if let Some(pid) = project_id { // 按项目过滤（同时验证组织权限） fetch_cabinet_rows_by_project(pool, user, pid).await? } else if user.role_level >= 2 { // 总管理员：按组织过滤或看全部 fetch_cabinet_rows_for_admin(pool, org_id).await? } else if let Some(org_id) = user.organization_id { // 企业管理员只看本组织 sqlx::query_as::<_, H5CabinetRow>(CABINETS_BY_USER_ORG_SQL) .bind(org_id) .fetch_all(pool) .await? } else { vec![] }; Ok(retain_in_scope(rows, user)) } /// 数据范围（项目级）内存过滤：未配置范围 / 总管理员时原样返回 fn retain_in_scope(rows: Vec, user: &CurrentUser) -> Vec { let scope = user.effective_scope(); if scope.is_unrestricted() { return rows; } rows.into_iter() .filter(|row| scope.allows_project(row.project_id)) .collect() } /// 项目过滤分支：总管理员不带组织条件，企业管理员额外校验项目归属组织 async fn fetch_cabinet_rows_by_project( pool: &sqlx::MySqlPool, user: &CurrentUser, pid: i64, ) -> Result, AppError> { if user.role_level >= 2 { let rows = sqlx::query_as::<_, H5CabinetRow>(CABINETS_BY_PROJECT_SQL) .bind(pid) .fetch_all(pool) .await?; Ok(rows) } else if let Some(org_id) = user.organization_id { let rows = sqlx::query_as::<_, H5CabinetRow>(CABINETS_BY_PROJECT_AND_ORG_SQL) .bind(pid) .bind(org_id) .fetch_all(pool) .await?; Ok(rows) } else { Ok(vec![]) } } /// 总管理员分支：指定组织则按组织过滤，否则查看全部 async fn fetch_cabinet_rows_for_admin( pool: &sqlx::MySqlPool, org_id: Option, ) -> Result, AppError> { if let Some(oid) = org_id { let rows = sqlx::query_as::<_, H5CabinetRow>(CABINETS_BY_ORG_SQL) .bind(oid) .fetch_all(pool) .await?; Ok(rows) } else { let rows = sqlx::query_as::<_, H5CabinetRow>(CABINETS_ALL_SQL) .fetch_all(pool) .await?; Ok(rows) } } /// HMGET 结果里的柜级 hex 位域取值（协议 §3.8）：`None` / 空串 / 纯空白都算"无数据" /// （→ 响应 `null`），**绝不落 `"00"`**（`"00"` 是"全部正常"的有效值，与"没数据"必须区分）。 /// 非空值**原样返回**，不解析、不改写大小写 —— 位域解析统一由前端纯函数完成。 fn pick_non_empty_hex(raw: Option<&Option>) -> Option { raw.and_then(|v| v.as_ref()) .map(|v| v.trim()) .filter(|v| !v.is_empty()) .map(str::to_string) } /// 从 Redis 批量读取柜子实时状态（Pipeline HMGET，1 次网络往返）/// /// 注意：柜级 pipeline 只对带 IMEI 的行下发命令，结果按「行下标」对齐， /// 与重构前的行为完全一致（这是既有约定，不做修正）。 /// /// 通道级派生计数（[`CabinetRealtimeMaps::counts`]）单独走**自己的一条 pipeline**， /// 键由 DB 的「板号 + 通道号」拼出（`cabinet_tree::fetch_channel_keys`）， /// 因此不受上面那条「按行下标对齐」的历史约定影响，5 条分支 SQL 全部共用本函数。 async fn load_cabinet_realtime(state: &AppState, rows: &[H5CabinetRow]) -> CabinetRealtimeMaps { let mut maps = CabinetRealtimeMaps::default(); if let Ok(client) = redis::Client::open(state.redis_url.as_str()) { // 使用多路复用连接（MultiplexedConnection），替代已废弃的 aio::Connection if let Ok(mut conn) = client.get_multiplexed_async_connection().await { let mut pipe = redis::pipe(); for r in rows { if let Some(ref imei) = r.imei { let key = format!("device:{imei}"); // ⚠️ 字段顺序由 CABINET_HMGET_FIELDS 唯一决定，与下面的下标解析一一对应 pipe.cmd("HMGET").arg(&key).arg(&CABINET_HMGET_FIELDS); } } if !rows.is_empty() { let results: Vec>> = match pipe.query_async(&mut conn).await { Ok(r) => r, Err(e) => { tracing::error!("[h5] Redis pipeline查询失败: {}", e); Vec::new() } }; for (i, r) in rows.iter().enumerate() { if let Some(ref imei) = r.imei { if let Some(vals) = results.get(i) { maps.rssi.insert(imei.clone(), vals.get(0).and_then(|v| v.as_ref()).and_then(|v| v.parse::().ok())); maps.dc.insert(imei.clone(), vals.get(1).and_then(|v| v.as_ref()).map(|v| v == "1")); maps.ac.insert(imei.clone(), vals.get(2).and_then(|v| v.as_ref()).map(|v| v == "1")); maps.temp.insert(imei.clone(), vals.get(3).and_then(|v| v.as_ref()).and_then(|v| v.parse::().ok())); // 柜级状态位：原样透出 hex；空串/缺失 → None（响应 null，不落 "00"） maps.status1.insert(imei.clone(), pick_non_empty_hex(vals.get(4))); maps.status2.insert(imei.clone(), pick_non_empty_hex(vals.get(5))); // 在线（下标 CABINET_HMGET_ONLINE_IDX）：判据**唯一权威纯函数**，与设备列表同源 maps.online.insert( imei.clone(), super::cabinet_tree::device_online_flag( vals.get(CABINET_HMGET_ONLINE_IDX) .and_then(|v| v.as_ref()) .map(String::as_str), ), ); } } } } } } // 通道级：按柜派生「充满数 / 故障数」（DB 里 `compartments.status` 只写 0/1，给不出这两个） let cabinet_ids: Vec = rows.iter().map(|r| r.id).collect(); let entries = match super::cabinet_tree::fetch_channel_keys(&state.mysql, &cabinet_ids).await { Ok(entries) => entries, Err(e) => { tracing::error!("[h5] 通道 key 查询失败，充满/故障计数按 0 计 err={}", e); Vec::new() } }; maps.counts = super::cabinet_tree::derive_counts_by_cabinet(state, &entries).await; maps } /// 查询柜子所属组织是否禁用，返回「项目ID -> 是否禁用」映射 async fn load_org_disabled_map( pool: &sqlx::MySqlPool, rows: &[H5CabinetRow], ) -> HashMap { let mut org_disabled_map: HashMap = HashMap::new(); let project_ids: Vec = rows.iter().filter_map(|r| r.project_id).collect(); if !project_ids.is_empty() { let placeholders: Vec = project_ids.iter().map(|_| "?".to_string()).collect(); // `{}` 处填入占位符列表，等价于原实现的 format! 拼接 let sql = PROJECT_ORG_DISABLED_SQL.replacen("{}", &placeholders.join(","), 1); let mut q = sqlx::query_as::<_, (i64, i8)>(&sql); for pid in &project_ids { q = q.bind(pid); } if let Ok(rows) = q.fetch_all(pool).await { for (pid, disabled) in rows { org_disabled_map.insert(pid, disabled == 1); } } } org_disabled_map } /// 行结构体 + 实时状态 → 响应 JSON 列表（字段名与语义与原实现逐字一致） /// /// `full_count` / `fault_count` 的**取值来源变了**（字段名不变）：不再来自 SQL /// （`compartments.status = 2/3` 在 DB 里永远不成立），改为由通道实时状态派生 /// （[`CabinetRealtimeMaps::counts`]，规则见 `cabinet_tree::derive_channel_counts`）。 /// 派生不到数据（设备离线 / 无该通道键 / Redis 不可用）→ **按 0 计，不猜测**。 fn build_cabinet_list( rows: Vec, realtime: &CabinetRealtimeMaps, org_disabled_map: &HashMap, ) -> Vec { rows.into_iter() .map(|r| { let imei = r.imei.clone(); let rssi = imei.as_ref().and_then(|i| realtime.rssi.get(i).copied()).flatten(); let pow_fail_dc = imei.as_ref().and_then(|i| realtime.dc.get(i).copied()).flatten(); let pow_fail_ac = imei.as_ref().and_then(|i| realtime.ac.get(i).copied()).flatten(); let temp = imei.as_ref().and_then(|i| realtime.temp.get(i).copied()).flatten(); // 柜级状态位（协议 §3.8）：原样透出 2 位 hex；取不到 → null（不落 "00"） let status1 = imei.as_ref().and_then(|i| realtime.status1.get(i).cloned()).flatten(); let status2 = imei.as_ref().and_then(|i| realtime.status2.get(i).cloned()).flatten(); // **实时在线**（Redis `device:{imei}.online`）：`true` 在线 / `false` 明确离线 / // `null` 无数据。字段名与 PC 端一致（`is_online`），小程序两端都消费它。 // ⚠️ 与 `status`（启用/禁用配置态）严格分离：`status === 2` 仍单独渲染「禁用」。 let is_online = imei.as_ref().and_then(|i| realtime.online.get(i).copied()).flatten(); let org_disabled = r.project_id.and_then(|pid| org_disabled_map.get(&pid)).copied().unwrap_or(false); // `ChannelCounts = (idle, charging, full, fault)`：只取派生出的充满/故障 let (_, _, full_count, fault_count) = realtime.counts.get(&r.id).copied().unwrap_or((0, 0, 0, 0)); json!({ "id": r.id, "abstract_id": r.abstract_id, "name": r.name, "imei": r.imei, "iccid": r.iccid, "status": r.status, // 实时在线（Redis，判据与设备列表 `is_online` 同源）；`status` 仍是配置态 "is_online": is_online, "project_id": r.project_id, "address": r.address, "latitude": r.latitude, "longitude": r.longitude, "channel_count": r.channel_count, "idle_count": r.idle_count, "charging_count": r.charging_count, "full_count": full_count, "fault_count": fault_count, "rssi": rssi, "pow_fail_dc": pow_fail_dc, "pow_fail_ac": pow_fail_ac, "temp": temp, // **柜级**状态位（协议 §3.8）：原样 hex 字符串，取不到为 null "status1": status1, "status2": status2, "org_disabled": org_disabled, }) }) .collect() } // --------------------------------------------------------------------------- // 设备扫码（免认证） // --------------------------------------------------------------------------- pub async fn get_cabinet_by_abstract_id( State(state): State, Path(abstract_id): Path, ) -> Result, AppError> { let pool = &state.mysql; let cab: Option<(i64, String, String, Option, i8)> = sqlx::query_as( "SELECT id, abstract_id, imei, name, status FROM cabinets WHERE abstract_id = ?", ) .bind(&abstract_id) .fetch_optional(pool) .await?; let (cab_id, abs_id, _imei, name, status) = cab.ok_or_else(|| AppError::NotFound("设备不存在".into()))?; // 查询仓控板+仓体 let boards: Vec = sqlx::query_as::<_, H5CabinBoardRow>( "SELECT id, board_id, status FROM cabin_boards WHERE cabinet_id = ? ORDER BY board_id", ) .bind(cab_id) .fetch_all(pool) .await?; let mut cabin_boards = Vec::with_capacity(boards.len()); for board in &boards { let comps: Vec = sqlx::query_as::<_, H5CompartmentRow>( "SELECT id, channel_id, status FROM compartments WHERE cabin_board_id = ? ORDER BY channel_id", ) .bind(board.id) .fetch_all(pool) .await?; let compartments: Vec = comps .into_iter() .map(|c| json!({ "id": c.id, "channel_id": c.channel_id, "status": c.status })) .collect(); cabin_boards.push(json!({ "id": board.id, "board_id": board.board_id, "status": board.status, "compartments": compartments, })); } Ok(Json(json!({ "code": 0, "data": { "id": cab_id, "abstract_id": abs_id, "name": name, "status": status, "cabin_boards": cabin_boards, }, "message": "ok" }))) } // --------------------------------------------------------------------------- // 仓体/通道详情 // --------------------------------------------------------------------------- /// 仓体基础信息（id, channel_id, status, cabin_board_id） const COMPARTMENT_BY_ID_SQL: &str = "SELECT id, channel_id, status, cabin_board_id FROM compartments WHERE id = ?"; /// 仓体所属仓控板 → 柜子 const CABIN_BOARD_CABINET_ID_SQL: &str = "SELECT cabinet_id FROM cabin_boards WHERE id = ?"; /// 仓体所属仓控板号 + 柜子 IMEI（拼通道级 Redis key 用） const CABIN_BOARD_REDIS_TARGET_SQL: &str = r#"SELECT cb.board_id, c.imei FROM cabin_boards cb INNER JOIN cabinets c ON c.id = cb.cabinet_id WHERE cb.id = ?"#; /// 仓体最近 10 条充电记录 const COMPARTMENT_CHARGE_RECORDS_SQL: &str = r#"SELECT id, start_time, end_time, energy FROM charge_records WHERE compartment_id = ? ORDER BY start_time DESC LIMIT 10"#; /// GET /api/h5/compartments/:id — 仓体详情（含充电记录，带权限校验） pub async fn get_compartment_detail( user: CurrentUser, State(state): State, Path(id): Path, ) -> Result, AppError> { // 权限校验 auth::check_permission(&user, "device:view")?; let pool = &state.mysql; // 查询仓体基本信息 let comp: Option<(i64, i8, i8, i64)> = sqlx::query_as(COMPARTMENT_BY_ID_SQL) .bind(id) .fetch_optional(pool) .await?; let (comp_id, channel_id, status, cabin_board_id) = comp.ok_or_else(|| AppError::NotFound("仓体不存在".into()))?; // 组织隔离：通过 cabin_board → cabinet → project 链路验证访问权限 verify_compartment_access(&user, cabin_board_id, pool).await?; // 通道级实时数据 key 需要（IMEI, 仓控板号, 通道号）； // 关联缺失时记录并整体降级为「无数据」（字段 null），不影响 MySQL 主体数据 let redis_target: Option<(i8, String)> = sqlx::query_as(CABIN_BOARD_REDIS_TARGET_SQL) .bind(cabin_board_id) .fetch_optional(pool) .await?; let realtime = match redis_target { Some((board_id, imei)) => { load_compartment_realtime(&state, &imei, board_id, channel_id).await } None => { tracing::warn!( comp_id, cabin_board_id, "[h5] 仓体缺少柜子/仓控板关联，实时数据按「无数据」返回" ); CompartmentRealtime::default() } }; // 查询最近充电记录 let records: Vec = sqlx::query_as::<_, ChargeRecordBriefRow>( COMPARTMENT_CHARGE_RECORDS_SQL, ) .bind(comp_id) .fetch_all(pool) .await?; // 展示状态：**有通道实时数据时按派生值**给出 `0空闲 / 1充电中 / 2充满 / 3故障` // （优先级 fault > full > charging > idle，与 PC/小程序三处映射口径一致）； // **拿不到数据时回落到 DB 的占用值**（0/1）—— 离线无法判定，不猜测。 // 字段名与类型不变（前端 `data.status` 直接消费），只是取值来源变了。 let flags = derive_channel_flags(realtime.batt_status.as_deref(), realtime.pow_status.as_deref()); let display_status = if flags.has_data { flags.status_code() } else { status }; Ok(Json(json!({ "code": 0, "data": { "id": comp_id, "channel_id": channel_id, "status": display_status, "cabin_board_id": cabin_board_id, // 以下实时字段全部取自设备上报真实写入的 Redis key； // 取不到时返回 null（**不落 0**），避免把"无数据"伪装成 0 "voltage": realtime.voltage, "current": realtime.current, // energy 没有实时数据源（通道级 Hash 不含电量累计），如实返回 null "energy": Value::Null, "soc": realtime.soc, "temp": realtime.temp, // 电池状态 / 电源状态：两个相互独立的维度（协议 §3.8）， // 小程序 `v-if="data.batt_status != null || data.pow_status != null"` 依赖它们 "batt_status": realtime.batt_status, "pow_status": realtime.pow_status, // 以下 3 个字段当前**没有任何写入方**（协议未上报 BMS 单体明细）， // 保持空数组以维持既有字段类型（前端类型为 number[]/string[]） "cell_voltages": json!([]), "cell_temps": json!([]), "bms_alerts": json!([]), "charge_records": map_charge_records(records), }, "message": "ok" }))) } /// 组织隔离：仓控板 → 柜子 → 项目 → 组织链路校验访问权限 async fn verify_compartment_access( user: &CurrentUser, cabin_board_id: i64, pool: &sqlx::MySqlPool, ) -> Result<(), AppError> { let cabinet_id: Option<(i64,)> = sqlx::query_as(CABIN_BOARD_CABINET_ID_SQL) .bind(cabin_board_id) .fetch_optional(pool) .await?; if let Some((cab_id,)) = cabinet_id { verify_cabinet_access(user, cab_id, pool).await?; } Ok(()) } /// 仓体详情实时状态快照（全部来自**真实写入**的 Redis key） /// /// 所有字段一律 `Option`：取不到就是 `None`（响应 JSON 为 `null`），**绝不落 0** —— /// 0 是"真实读数为 0"，与"无数据"必须区分（旧实现把所有缺失都回落成 0， /// 小程序上表现为 SOC 0.0% / 0.0V / 0.0A 这种"看起来有值但其实是假的 0"）。 #[derive(Default)] struct CompartmentRealtime { /// 电池状态（2 位 hex，协议 §3.8） batt_status: Option, /// 电源状态（2 位 hex，与电池状态相互独立） pow_status: Option, /// SOC，平台单位 ‰ soc: Option, /// 充电电压，单位 mV voltage: Option, /// 充电电流，单位 mA current: Option, /// 电芯最高温度，单位 K×100 temp: Option, } /// 通道级 Hash 字段名（顺序即 HMGET 结果下标，与 `report_worker::write_channel_state` 的写入一致） const COMPARTMENT_REALTIME_FIELDS: [&str; 6] = ["batt_status", "pow_status", "soc", "voltage", "current", "temp"]; /// 从 Redis 读取仓体实时数据 /// /// **数据来源（均为真实写入的 key）：** /// - 通道级 Hash `device:{imei}:board:{板号}:ch:{通道号}`： /// `batt_status` / `pow_status` / `soc`(‰) / `voltage`(mV) / `current`(mA) / `temp`(K×100) /// —— 由 `workers/report_worker.rs::write_channel_state` 在每次 `status_post` 时写入； /// - `bat_in` 登记键 `device:{imei}:board:{板号}:ch:{通道号}:bat` 的 `soc`： /// 仅当通道级 Hash 里没有 `soc`（设备长时间未上报 / Hash 过期）时作为**兜底**， /// 它是"最近一次插电池时的起始 SOC"，语义上弱于实时值。 /// /// **为什么不再读 `compartment:status:{id}`：** 该 key 在全仓**只有读取方、没有任何写入方**， /// 取值恒为空 → 旧实现把它回落成 0，导致 SOC/电压/电流/能耗永远显示 0。 /// /// 板号/通道号为十进制不补零，与上报写入侧保持一致；任何 Redis 异常都只降级为 `None`， /// 不让详情接口整体失败。 async fn load_compartment_realtime( state: &AppState, imei: &str, board_id: i8, channel_id: i8, ) -> CompartmentRealtime { let client = match redis::Client::open(state.redis_url.as_str()) { Ok(c) => c, Err(e) => { tracing::warn!("[h5] Redis 客户端创建失败，仓体实时数据降级 imei={} err={}", imei, e); return CompartmentRealtime::default(); } }; // 使用多路复用连接（MultiplexedConnection），替代已废弃的 aio::Connection let mut conn = match client.get_multiplexed_async_connection().await { Ok(c) => c, Err(e) => { tracing::warn!("[h5] Redis 连接失败，仓体实时数据降级 imei={} err={}", imei, e); return CompartmentRealtime::default(); } }; let ch_key = format!("device:{}:board:{}:ch:{}", imei, board_id, channel_id); // 1) 通道级 Hash：设备上报的真实实时值 let values: Result>, redis::RedisError> = redis::cmd("HMGET") .arg(&ch_key) .arg(&COMPARTMENT_REALTIME_FIELDS) .query_async(&mut conn) .await; let mut rt = match values { Ok(values) => parse_compartment_realtime(&values), Err(e) => { tracing::warn!( "[h5] 通道状态读取失败，实时数据降级 key={} err={}", ch_key, e ); CompartmentRealtime::default() } }; // 2) SOC 兜底：通道 Hash 没值时才回读 `bat_in` 登记键（起始 SOC） if rt.soc.is_none() { let bat_key = format!("{}:bat", ch_key); let registered: Result, redis::RedisError> = redis::cmd("HGET") .arg(&bat_key) .arg("soc") .query_async(&mut conn) .await; match registered { Ok(Some(soc)) => { rt.soc = soc.trim().parse::().ok(); tracing::debug!("[h5] 通道无实时 SOC，回退 bat_in 登记值 key={}", bat_key); } Ok(None) => {} Err(e) => { tracing::warn!("[h5] bat_in 登记读取失败 key={} err={}", bat_key, e); } } } rt } /// HMGET 结果（顺序同 [`COMPARTMENT_REALTIME_FIELDS`]）→ 实时状态快照 /// /// 缺失项或非数字项一律 `None`（**不落 0**）。 fn parse_compartment_realtime(values: &[Option]) -> CompartmentRealtime { /// 取第 i 项的非空字符串（空白串视为"无数据"，避免前端把空 hex 当有效状态渲染） fn pick(values: &[Option], i: usize) -> Option { values .get(i) .and_then(|v| v.as_ref()) .map(|v| v.trim().to_string()) .filter(|v| !v.is_empty()) } /// 取第 i 项并解析为 i64（空值/非数字 → None） fn pick_i64(values: &[Option], i: usize) -> Option { pick(values, i).and_then(|v| v.parse::().ok()) } CompartmentRealtime { batt_status: pick(values, 0), pow_status: pick(values, 1), soc: pick_i64(values, 2), voltage: pick_i64(values, 3), current: pick_i64(values, 4), temp: pick_i64(values, 5), } } /// 充电记录行 → 响应 JSON（`energy_kwh` / `cost` 语义不变） fn map_charge_records(records: Vec) -> Vec { records .into_iter() .map(|r| { json!({ "id": r.id, "start_time": r.start_time.map(|t| t.to_string()), "end_time": r.end_time.map(|t| t.to_string()), "energy_kwh": r.energy.unwrap_or_default().parse::().unwrap_or(0), "cost": 0, }) }) .collect() } // --------------------------------------------------------------------------- // 扫码验证 // --------------------------------------------------------------------------- /// GET /api/h5/scan/:abstract_id — 扫码验证设备访问权限 /// /// 根据二维码中的抽象ID查找设备，验证当前用户是否有权访问。 /// 有权限返回设备ID和基本信息，无权限返回403。 pub async fn scan_cabinet( user: CurrentUser, State(state): State, Path(abstract_id): Path, ) -> Result, AppError> { let pool = &state.mysql; // 查找设备 let cab: Option<(i64, String, String, Option, i8)> = sqlx::query_as( "SELECT id, abstract_id, imei, name, status FROM cabinets WHERE abstract_id = ?", ) .bind(&abstract_id) .fetch_optional(pool) .await?; let (cab_id, abs_id, imei, name, status) = cab.ok_or_else(|| AppError::NotFound("设备不存在".into()))?; // 验证用户是否有权限访问该设备 verify_cabinet_access(&user, cab_id, pool).await?; Ok(Json(json!({ "code": 0, "data": { "id": cab_id, "abstract_id": abs_id, "imei": imei, "name": name, "status": status, }, "message": "ok" }))) } // --------------------------------------------------------------------------- // 充电控制 // --------------------------------------------------------------------------- /// POST /api/h5/charge/start — 开始充电 /// /// 协议 §5.7：**`on` 是建立订单的唯一入口**。平台指令模式（`work_mode="0"`）下由**平台**下发 `on`， /// 因此平台必须在**下发前**建单 —— 设备随后回的 `on` 只是回执（带 `suc`），回执不建单。 /// 建单失败只记日志、**绝不影响指令下发**（充电优先于订单统计）。 /// /// ⚠️ **校验顺序（本 handler 的契约）**： /// **权限 → 归属 → 设备启用 → 设备在线 → 建单 → 下发**。 /// 建单必须排在全部校验之后：否则设备离线/无权访问时接口虽然报错，订单却已经插进 /// `charge_orders`（幽灵单，只能等 10 小时超时结单，UI 上还会多出一次"充电中"）。 pub async fn start_charge( user: CurrentUser, State(state): State, Json(body): Json, ) -> Result, AppError> { auth::check_permission(&user, "charge:start")?; // 一次查出柜子/仓控板/通道 + 充电工作模式 // （`cabinets.work_mode` 是 TINYINT：0=平台指令模式 / 1=自动充电模式 / NULL 按 0 处理） let target: Option<(i64, String, i8, i8, Option)> = sqlx::query_as( r#"SELECT cab.id, cab.imei, cb.board_id, comp.channel_id, cab.work_mode FROM cabinets cab JOIN cabin_boards cb ON cb.cabinet_id = cab.id JOIN compartments comp ON comp.cabin_board_id = cb.id WHERE comp.id = ?"#, ) .bind(body.compartment_id) .fetch_optional(&state.mysql) .await?; // 仓体不存在：与 [`send_compartment_command`] 的报错语义一致（同一 JOIN 条件） let (cabinet_id, imei, board_id, channel_id, mode) = target.ok_or_else(|| AppError::NotFound("仓体对应的设备不存在".into()))?; // 归属 → 设备启用 → 设备在线：全部**提前到建单之前**（顺序与 [`send_compartment_command`] 一致， // 校验函数语义未改；下发路径仍会再校验一次，幂等无副作用） verify_cabinet_access(&user, cabinet_id, &state.mysql).await?; ensure_cabinet_enabled(&state.mysql, cabinet_id).await?; ensure_device_online(&state, &imei).await?; // 只有**平台指令模式**（`work_mode="0"`/NULL）才由平台下发 `on` 并在此建单； // **自动充电模式**（`"1"`）下订单由设备上报的 `on`（不带 `suc`）建立，平台不重复建单 if mode.unwrap_or(0) == 0 { create_order_before_on(&state, &body, cabinet_id, &imei, board_id, channel_id).await; } else { tracing::info!( "[h5] 自动充电模式（work_mode=1），建单由设备上报的 on 负责 compartment_id={}", body.compartment_id ); } send_compartment_command(&state, &user, body.compartment_id, "on").await } /// 平台下发 `on` **之前**建单（失败只记日志，绝不影响指令下发）。 /// /// 电池 id 与起始 SOC 取该通道最近一次 `bat_in` 的登记（`on` 报文本身不带 `info`）。 /// ⚠️ 登记键 `device:{imei}:board:{b}:ch:{c}:bat` 的 TTL 只有 48 小时 /// （[`crate::workers::report_worker`] 的 `CHANNEL_BAT_TTL_SECS`）—— 集中充电柜里电池常在仓内 /// 放置超过 48 小时，登记过期后**必须仍按"未知电池"建单**（与设备侧 `handle_device_on` 的兜底 /// 口径一致）：否则整段会话没有 `charge_orders` / `charge_records` / 电量， /// 用户在"充电记录"里看不到这次充电，属于**平台建单漏单**。 async fn create_order_before_on( state: &AppState, body: &CompartmentActionInput, cabinet_id: i64, imei: &str, board_id: i8, channel_id: i8, ) { let (battery_id, start_soc) = match crate::workers::report_worker::load_channel_battery( &state.redis, imei, board_id, channel_id, ) .await { Some(battery) => (battery.battery_id, Some(battery.soc)), None => { tracing::warn!( "[h5] 该通道无 bat_in 登记，按未知电池建单 compartment_id={}", body.compartment_id ); (String::new(), None) } }; // `ensure_charge_order` 内部自带「按仓体进程内锁 + 条件插入 + 唯一索引」， // 重复下发 / 双击不会多建单 if let Err(e) = crate::workers::report_worker::ensure_charge_order( &state.mysql, &state.redis, imei, cabinet_id, board_id, channel_id, &battery_id, start_soc, ) .await { tracing::error!( "[h5] 下发 on 前建单失败 compartment_id={} err={}", body.compartment_id, e ); } } /// POST /api/h5/charge/stop — 停止充电 pub async fn stop_charge( user: CurrentUser, State(state): State, Json(body): Json, ) -> Result, AppError> { auth::check_permission(&user, "charge:stop")?; send_compartment_command(&state, &user, body.compartment_id, "off").await } /// POST /api/h5/door/open — 开门（**柜级动作**） /// /// 入参是仓体 ID（小程序扫码场景只知道扫到哪个仓）， /// 但**开门是整柜解锁** —— 解析出所属柜子后按**柜级**下发（协议 `id` 省略）。 pub async fn open_door( user: CurrentUser, State(state): State, Json(body): Json, ) -> Result, AppError> { auth::check_permission(&user, "charge:open_door")?; let cabinet_id: Option = sqlx::query_scalar( r#"SELECT cb.cabinet_id FROM compartments comp JOIN cabin_boards cb ON cb.id = comp.cabin_board_id WHERE comp.id = ?"#, ) .bind(body.compartment_id) .fetch_optional(&state.mysql) .await?; let cabinet_id = cabinet_id.ok_or_else(|| AppError::NotFound("仓体对应的设备不存在".into()))?; send_cabinet_command(&state, &user, cabinet_id, None, "open").await } // --------------------------------------------------------------------------- // 辅助函数 // --------------------------------------------------------------------------- // --- 指令下发 SQL / Redis key（由原函数体逐字搬移，契约不变） --- /// 仓体 → 柜子/IMEI/仓控板/通道 一次查询 const COMPARTMENT_TARGET_SQL: &str = r#"SELECT cab.id AS cabinet_id, cab.imei, cb.board_id, comp.channel_id FROM cabinets cab JOIN cabin_boards cb ON cb.cabinet_id = cab.id JOIN compartments comp ON comp.cabin_board_id = cb.id WHERE comp.id = ?"#; /// 柜子ID → IMEI const CABINET_IMEI_SQL: &str = "SELECT imei FROM cabinets WHERE id = ?"; /// 柜子是否被禁用（status = 2） const CABINET_DISABLED_SQL: &str = "SELECT COUNT(*) > 0 FROM cabinets WHERE id = ? AND status = 2"; /// 柜子所属组织是否被禁用 const CABINET_ORG_DISABLED_SQL: &str = r#"SELECT COUNT(*) > 0 FROM cabinets c INNER JOIN projects p ON c.project_id = p.id INNER JOIN organizations o ON p.organization_id = o.id WHERE c.id = ? AND o.disabled = 1"#; /// 设备指令队列 key（device-server 消费端契约，不可更改） const DEVICE_COMMANDS_KEY: &str = "device:commands"; /// 校验柜子及其所属组织未被禁用（甲方禁用组织 → 其下柜子全部失效） async fn ensure_cabinet_enabled(pool: &sqlx::MySqlPool, cabinet_id: i64) -> Result<(), AppError> { // 检查设备是否被禁用 let disabled: bool = sqlx::query_scalar(CABINET_DISABLED_SQL) .bind(cabinet_id) .fetch_one(pool) .await .map_err(AppError::Database)?; if disabled { return Err(AppError::BadRequest("设备已被禁用，无法执行操作".into())); } // 检查柜子所属组织是否被禁用（甲方禁用客户组织 → 其下柜子全部失效） let org_disabled: bool = sqlx::query_scalar(CABINET_ORG_DISABLED_SQL) .bind(cabinet_id) .fetch_one(pool) .await .map_err(AppError::Database)?; if org_disabled { return Err(AppError::BadRequest("设备所属组织已被禁用，无法执行操作".into())); } Ok(()) } /// 设备必须在线：平台对不在线的设备一律不投递 async fn ensure_device_online(state: &AppState, imei: &str) -> Result<(), AppError> { if !state.nodes.is_device_online(imei).await { return Err(AppError::BadRequest("设备不在线".into())); } Ok(()) } /// 序列化指令 → 注入内部路由字段 → LPUSH 进 `device:commands` 队列 async fn push_device_command( state: &AppState, cmd: &DeviceCommand, imei: &str, ) -> Result<(), AppError> { // 注入内部路由字段（目标设备 IMEI；device-server 下发前摘除，设备侧不可见） let mut json_val = serde_json::to_value(cmd).map_err(|e| AppError::Internal(format!("指令序列化失败: {}", e)))?; json_val[ROUTE_DEV_ID_FIELD] = json!(imei); let json_str = json_val.to_string(); let mut conn = state.redis.clone(); redis::cmd("LPUSH") .arg(DEVICE_COMMANDS_KEY) .arg(&json_str) .query_async::<()>(&mut conn) .await .map_err(|e| AppError::Internal(format!("Redis 推入失败: {}", e)))?; Ok(()) } /// 指令下发成功响应（返回码与文案与原实现一致） fn command_dispatched_json() -> Json { Json(json!({ "code": 0, "data": { "success": true }, "message": "指令已下发" })) } /// 根据仓体ID解析所属柜子/仓控板/通道，下发**仓体级**指令（`on` / `off`）。 /// /// 协议 `id` = `仓控板-通道`（两段，仓控板 2 位补零）。 /// 柜级指令（`open` / `pow_on` / `pow_off` / `reset`）请用 [`send_cabinet_command`]。 async fn send_compartment_command( state: &AppState, user: &CurrentUser, compartment_id: i64, action: &str, ) -> Result, AppError> { let pool = &state.mysql; // 一次查询拿到 cabinet_id + IMEI + board_id + channel_id let cab_row = load_compartment_target(pool, compartment_id).await?; // 设备禁用 → 组织禁用 → 组织隔离 → 在线 校验（顺序与原实现一致） ensure_cabinet_enabled(pool, cab_row.cabinet_id).await?; verify_cabinet_access(user, cab_row.cabinet_id, pool).await?; ensure_device_online(state, &cab_row.imei).await?; let imei = &cab_row.imei; // 构造协议 id： // 仓体级指令 (on/off)：`仓控板-通道`（仓控板 2 位补零、通道不补零） // 柜级指令 (open/pow_on/pow_off/reset)：【不带 id】—— 设备身份与目标都由连接确定 let id = format!("{:02}-{}", cab_row.board_id, cab_row.channel_id); let cmd = DeviceCommand { act: action.to_string(), msg_id: 0, id: Some(id.clone()), params: Some(json!({})), }; push_device_command(state, &cmd, imei).await?; tracing::info!( "[h5] 指令已推入队列 id={} action={} compartment_id={}", id, action, compartment_id ); Ok(command_dispatched_json()) } /// 按仓体ID查询目标设备与通道信息 async fn load_compartment_target( pool: &sqlx::MySqlPool, compartment_id: i64, ) -> Result { let row: Option = sqlx::query_as(COMPARTMENT_TARGET_SQL) .bind(compartment_id) .fetch_optional(pool) .await?; row.ok_or_else(|| AppError::NotFound("仓体对应的设备不存在".into())) } // --------------------------------------------------------------------------- // 柜级 / 单仓控板级指令（pow_on / pow_off / reset） // --------------------------------------------------------------------------- /// 柜级 / 单仓控板级指令下发。 /// /// - `board_id = None` → **柜级**：协议**不带 `id`**（省略该字段） /// - `board_id = Some(n)` → **单仓控板**：协议 `id = "{仓控板:02}"`（如 `"01"`） /// /// 适用于 `open` / `pow_on` / `pow_off` / `reset`；`on` / `off` 走 [`send_compartment_command`]。 async fn send_cabinet_command( state: &AppState, user: &CurrentUser, cabinet_id: i64, board_id: Option, action: &str, ) -> Result, AppError> { let pool = &state.mysql; let imei = load_cabinet_imei(pool, cabinet_id).await?; // 设备禁用 → 组织禁用 → 组织隔离 → 在线 校验（顺序与原实现一致） ensure_cabinet_enabled(pool, cabinet_id).await?; verify_cabinet_access(user, cabinet_id, pool).await?; ensure_device_online(state, &imei).await?; // 构造协议 id： // - `board_id = None` → **柜级**：**不带 id**（省略该字段） // - `board_id = Some(n)` → **单仓控板**：`仓控板`（2 位补零，如 "01"） let id = board_id.map(|b| format!("{:02}", b)); let cmd = DeviceCommand { act: action.to_string(), msg_id: 0, id: id.clone(), params: Some(json!({})), }; push_device_command(state, &cmd, &imei).await?; tracing::info!( "[设备指令] 已推入队列 id={:?} action={} cabinet_id={} board_id={:?}", id, action, cabinet_id, board_id ); Ok(command_dispatched_json()) } /// 按柜子ID查询 IMEI async fn load_cabinet_imei(pool: &sqlx::MySqlPool, cabinet_id: i64) -> Result { let imei: Option = sqlx::query_scalar(CABINET_IMEI_SQL) .bind(cabinet_id) .fetch_optional(pool) .await?; imei.ok_or_else(|| AppError::NotFound("设备不存在".into())) } /// POST /api/cabinets/:id/open — **解锁柜门**（柜级） /// /// 柜门是**整柜共用、只有一扇**，所以这是柜级动作（协议 `id` 省略）。 /// WEB 管理端设备详情页用这个；小程序扫码场景用 `POST /api/h5/door/open`（入参为仓体 ID）。 pub async fn cabinet_open( user: CurrentUser, State(state): State, Path(id): Path, ) -> Result, AppError> { auth::check_permission(&user, "charge:open_door")?; send_cabinet_command(&state, &user, id, None, "open").await } /// POST /api/cabinets/:id/pow-on — 接触器**合闸**（柜级） pub async fn cabinet_pow_on( user: CurrentUser, State(state): State, Path(id): Path, ) -> Result, AppError> { auth::check_permission(&user, "device:operate")?; send_cabinet_command(&state, &user, id, None, "pow_on").await } /// POST /api/cabinets/:id/pow-off — 接触器**分闸**（柜级） /// /// ⚠️ 分闸后**仓控板随之下电**：该柜仓体/电池数据不可用，设备会上报 `pow_fail_dc`； /// 恢复供电须再下发 `pow-on`。 pub async fn cabinet_pow_off( user: CurrentUser, State(state): State, Path(id): Path, ) -> Result, AppError> { auth::check_permission(&user, "device:operate")?; send_cabinet_command(&state, &user, id, None, "pow_off").await } /// POST /api/cabinets/:id/reset — **重启整柜**（柜级，协议 `id = IMEI`） pub async fn cabinet_reset( user: CurrentUser, State(state): State, Path(id): Path, ) -> Result, AppError> { auth::check_permission(&user, "device:operate")?; send_cabinet_command(&state, &user, id, None, "reset").await } /// POST /api/cabin-boards/:id/reset — **重启单块仓控板** /// （协议 `id = IMEI-仓控板号`，两段） pub async fn board_reset( user: CurrentUser, State(state): State, Path(board_pk): Path, ) -> Result, AppError> { auth::check_permission(&user, "device:operate")?; let row: Option<(i64, i8)> = sqlx::query_as("SELECT cabinet_id, board_id FROM cabin_boards WHERE id = ?") .bind(board_pk) .fetch_optional(&state.mysql) .await?; let (cabinet_id, board_id) = row.ok_or_else(|| AppError::NotFound("仓控板不存在".into()))?; send_cabinet_command(&state, &user, cabinet_id, Some(board_id), "reset").await } /// POST /api/feedback — 用户问题反馈提交（任何已登录用户可提交） pub async fn submit_feedback( user: CurrentUser, State(state): State, Json(body): Json, ) -> Result, AppError> { let pool = &state.mysql; let content = body.content.trim(); if content.is_empty() { return Err(AppError::BadRequest("反馈内容不能为空".into())); } if content.chars().count() > 2000 { return Err(AppError::BadRequest("反馈内容过长（最多2000字）".into())); } let contact = body.contact.as_ref().map(|c| c.trim().to_string()).filter(|c| !c.is_empty()); if let Some(c) = &contact { if c.chars().count() > 200 { return Err(AppError::BadRequest("联系方式过长".into())); } } // 图片校验：最多 6 张 let images = body.images.clone().unwrap_or_default(); let images: Vec = images .iter() .map(|u| u.trim().to_string()) .filter(|u| !u.is_empty()) .collect(); if images.len() > 6 { return Err(AppError::BadRequest("最多上传6张图片".into())); } let images_json = if images.is_empty() { String::from("[]") } else { serde_json::to_string(&images).unwrap_or_else(|_| "[]".to_string()) }; sqlx::query( "INSERT INTO user_feedback (user_id, content, contact, images) VALUES (?, ?, ?, ?)" ) .bind(user.user_id) .bind(content) .bind(contact) .bind(&images_json) .execute(pool) .await .map_err(AppError::Database)?; tracing::info!( "[h5] 问题反馈已提交 user_id={} content_len={}", user.user_id, content.chars().count() ); Ok(Json(json!({ "code": 0, "data": { "success": true }, "message": "反馈已提交，感谢您的反馈" }))) } /// GET /api/feedback — 查询反馈列表（分页，管理员使用） #[derive(Debug, Deserialize)] pub(crate) struct FeedbackListQuery { page: Option, page_size: Option, /// 处理状态筛选：0=待处理 1=已处理；缺省/不传 = 全部。 /// 必须显式声明，否则 serde 会**静默丢弃**前端传来的 `status`（前端筛选点了没反应）。 status: Option, } #[derive(Debug, sqlx::FromRow)] struct FeedbackRow { id: i64, user_id: i64, content: String, contact: Option, images: Option, status: i8, created_at: chrono::NaiveDateTime, } /// 反馈列表的 WHERE 子句与**文本**绑定值 /// /// - 组织隔离条件（文本）在 SQL 中**先于** `status` ⇒ 调用方必须先绑文本值、 /// 最后单独绑 `status`（整型）； /// - 工厂（`role_level >= 2`）不加组织条件（全量）； /// - 客户侧无组织 → `1=0` 空集。 fn feedback_filter(user: &CurrentUser, has_status: bool) -> (String, Vec) { let mut conditions: Vec = Vec::new(); let mut binds: Vec = Vec::new(); // 归属：反馈提交人必须属于当前用户所在组织（`user_feedback.user_id → users.organization_id`） if user.role_level < auth::SUPER_ADMIN_ROLE_LEVEL { match user.organization_id { Some(org_id) => { conditions.push( "EXISTS (SELECT 1 FROM users u \ WHERE u.id = user_feedback.user_id AND u.organization_id = ?)" .to_string(), ); binds.push(org_id.to_string()); } None => conditions.push("1=0".to_string()), } } if has_status { conditions.push("status = ?".to_string()); } if conditions.is_empty() { (String::new(), binds) } else { (format!(" WHERE {}", conditions.join(" AND ")), binds) } } /// 校验当前用户是否有权处置（查看状态/改状态）某条反馈 /// /// 归属口径与 [`feedback_filter`] 完全一致：工厂豁免；客户侧必须是**本组织成员**提交的反馈。 /// 反馈不存在 → `NotFound`（保持原有 404 语义）；存在但不属于本组织 → `Forbidden` /// （**不返回 404**，避免"改别人的反馈"被静默当成"已处理成功"）。 async fn verify_feedback_ownership( pool: &sqlx::MySqlPool, user: &CurrentUser, feedback_id: i64, ) -> Result<(), AppError> { if user.role_level >= auth::SUPER_ADMIN_ROLE_LEVEL { return Ok(()); } let Some(org_id) = user.organization_id else { return Err(AppError::Forbidden("无权访问该资源".into())); }; let owner_org: Option> = sqlx::query_scalar( "SELECT u.organization_id FROM user_feedback f \ JOIN users u ON u.id = f.user_id WHERE f.id = ?", ) .bind(feedback_id) .fetch_optional(pool) .await?; match owner_org { None => Err(AppError::NotFound("反馈记录不存在".into())), Some(Some(org)) if org == org_id => Ok(()), _ => Err(AppError::Forbidden("无权访问该资源".into())), } } /// GET /api/h5/feedback — 反馈列表（管理端） /// /// 权限：反馈内容里带全部用户的**联系方式**，属于管理端审计类数据， /// 因此不能只校验登录态 —— 复用权限种子里真实存在的 `operation_log:view` /// （`db/migrate.rs::seed_roles`：总管理员全量、企业管理员含该码、操作员**没有**该码）， /// 语义上「查看管理端记录/日志」与「查看用户反馈」最贴近； /// 操作员即使登录也会被 403 拦住。 /// /// **组织隔离（本次修复）**：反馈按**提交人**归属 —— /// `user_feedback.user_id → users.organization_id`（与操作日志同一口径）。 /// 历史缺陷：本接口只校验了 `operation_log:view` 就全量查询 ⇒ 任何**企业管理员** /// 都能读到其它客户组织的反馈（含联系方式）并改其处理状态。 /// 规则：工厂（`role_level >= 2`）全量；客户侧仅本组织成员提交的反馈； /// `organization_id` 为 `NULL` → 空集（**绝不退化成全量**）。 /// 数据范围（`user_scopes`）**不叠加**：反馈与项目/设备没有关联列，项目级范围无法映射 /// （与操作日志完全同一口径，见 AGENTS.md「数据范围」一节的说明）。 /// /// `status` 为可选筛选条件，落到 SQL（不影响未传参时的原有查询语义）。 pub async fn list_feedback( user: CurrentUser, State(state): State, Query(query): Query, ) -> Result, AppError> { auth::check_permission(&user, "operation_log:view")?; let pool = &state.mysql; let page = query.page.unwrap_or(1).max(1); let page_size = query.page_size.unwrap_or(20).clamp(1, 100); let offset = (page - 1) * page_size; let status = query.status; // 状态值口径与 update_feedback_status 保持一致（0待处理 / 1已处理） if let Some(s) = status { if s != 0 && s != 1 { return Err(AppError::BadRequest("状态值必须为0(待处理)/1(已处理)".into())); } } // 条件与绑定值一一对应：**文本条件（组织隔离）在前、`status`（整型）在后**， // 因此绑定顺序同样是"先文本占位、后 status"（见下面的 count/list 绑定） let (filter, org_binds) = feedback_filter(&user, status.is_some()); let mut binds = org_binds; let count_sql = format!("SELECT COUNT(*) FROM user_feedback{}", filter); let mut count_query = sqlx::query_scalar::<_, i64>(&count_sql); for bind in &binds { count_query = count_query.bind(bind); } if let Some(s) = status { count_query = count_query.bind(s); } let total: i64 = count_query.fetch_one(pool).await?; let list_sql = format!( "SELECT id, user_id, content, contact, images, status, created_at FROM user_feedback{} ORDER BY created_at DESC LIMIT ? OFFSET ?", filter ); let mut list_query = sqlx::query_as::<_, FeedbackRow>(&list_sql); for bind in binds.drain(..) { list_query = list_query.bind(bind); } if let Some(s) = status { list_query = list_query.bind(s); } let rows: Vec = list_query .bind(page_size) .bind(offset) .fetch_all(pool) .await?; let list: Vec = rows.into_iter().map(|r| { let images: Vec = r.images .as_deref() .and_then(|s| serde_json::from_str(s).ok()) .unwrap_or_default(); json!({ "id": r.id, "user_id": r.user_id, "content": r.content, "contact": r.contact, "images": images, "status": r.status, "status_text": if r.status == 0 { "待处理" } else { "已处理" }, "created_at": r.created_at.format("%Y-%m-%d %H:%M:%S").to_string(), }) }).collect(); Ok(Json(json!({ "code": 0, "data": { "list": list, "total": total, "page": page, "page_size": page_size }, "message": "ok" }))) } /// PUT /api/feedback/{id} — 更新反馈状态（0待处理 → 1已处理） #[derive(Debug, Deserialize)] pub(crate) struct FeedbackStatusInput { status: i8, } const FEEDBACK_IMG_DIR: &str = "uploads/feedback"; pub async fn upload_feedback_image( user: CurrentUser, mut multipart: Multipart, ) -> Result, AppError> { let mut file_data: Option> = None; let mut ext = "".to_string(); while let Some(field) = multipart.next_field().await .map_err(|e| AppError::Internal(format!("解析上传文件失败: {}", e)))? { let filename = field.file_name().unwrap_or("").to_string(); let data = field.bytes().await .map_err(|e| AppError::Internal(format!("读取文件失败: {}", e)))?; if let Some(pos) = filename.rfind('.') { ext = filename[pos..].to_string(); } file_data = Some(data.to_vec()); } let data = file_data.ok_or_else(|| AppError::BadRequest("上传内容为空".into()))?; if data.is_empty() { return Err(AppError::BadRequest("上传内容为空".into())); } if data.len() > 5 * 1024 * 1024 { return Err(AppError::BadRequest("图片文件不能超过 5MB".into())); } if ext.is_empty() { ext = ".jpg".to_string(); } // 扩展名白名单 + 文件魔数嗅探（拒绝 .svg/.htm 等可脚本化类型，防存储型 XSS） // 返回值是按内容嗅探出的规范扩展名；落盘后缀与真实内容一致 let ext = super::upload_guard::validate_image_upload(&data, &ext)?; let dir = std::path::Path::new(FEEDBACK_IMG_DIR); std::fs::create_dir_all(dir) .map_err(|e| AppError::Internal(format!("创建目录失败: {}", e)))?; let filename = format!("{}{}", Uuid::new_v4().simple(), ext); let filepath = dir.join(&filename); let mut f = std::fs::File::create(&filepath) .map_err(|e| AppError::Internal(format!("创建文件失败: {}", e)))?; f.write_all(&data) .map_err(|e| AppError::Internal(format!("写入文件失败: {}", e)))?; let url = format!("/uploads/feedback/{}", filename); tracing::info!( user_id = user.user_id, path = %url, "反馈图片上传成功" ); Ok(Json(json!({ "code": 0, "data": { "url": url }, "message": "ok" }))) } pub async fn update_feedback_status( user: CurrentUser, State(state): State, Path(id): Path, Json(body): Json, ) -> Result, AppError> { // 与 list_feedback 同一权限码：能改处理状态的人必须能看反馈列表 // （`operation_log:view` 在 `db/migrate.rs` 的权限种子里真实存在） auth::check_permission(&user, "operation_log:view")?; let pool = &state.mysql; if body.status != 0 && body.status != 1 { return Err(AppError::BadRequest("状态值不合法".into())); } // 归属校验：客户侧只能处置本组织成员提交的反馈（工厂豁免）。 // 历史缺陷：原先只校验权限码就直接 UPDATE ⇒ 企业管理员能改别的组织的反馈状态。 verify_feedback_ownership(pool, &user, id).await?; let affected = sqlx::query("UPDATE user_feedback SET status = ? WHERE id = ?") .bind(body.status) .bind(id) .execute(pool) .await .map_err(AppError::Database)? .rows_affected(); if affected == 0 { return Err(AppError::NotFound("反馈记录不存在".into())); } tracing::info!( "[h5] 反馈状态已更新 operator={} feedback_id={} status={}", user.user_id, id, body.status ); Ok(Json(json!({ "code": 0, "data": { "success": true }, "message": "ok" }))) } /// 验证用户是否有权访问指定柜子（组织数据隔离 + 数据范围） /// /// 总管理员（role_level >= 2）可访问所有柜子（数据范围同样豁免）； /// 企业管理员只能访问本组织下项目关联的柜子，**且柜子所属项目必须在其数据范围内**； /// 无组织关联的用户无权访问任何柜子。 async fn verify_cabinet_access( user: &CurrentUser, cabinet_id: i64, pool: &sqlx::MySqlPool, ) -> Result<(), AppError> { // 总管理员无需校验 if user.role_level >= 2 { return Ok(()); } let org_id = user .organization_id .ok_or_else(|| AppError::Forbidden("无组织关联，无权访问设备".into()))?; // 通过 cabinet → project → organization 链路验证归属，并叠加数据范围（项目级） let (scope_cond, scope_binds) = user.effective_scope().project_condition("p.id"); let sql = format!( r#"SELECT cab.id FROM cabinets cab INNER JOIN projects p ON cab.project_id = p.id WHERE cab.id = ? AND p.organization_id = ?{}"#, scope_cond ); let mut query = sqlx::query_as::<_, (i64,)>(&sql).bind(cabinet_id).bind(org_id); for bind in &scope_binds { query = query.bind(bind); } let access: Option<(i64,)> = query.fetch_optional(pool).await?; if access.is_none() { return Err(AppError::Forbidden("无权访问该设备".into())); } Ok(()) } // --------------------------------------------------------------------------- // 单元测试 // --------------------------------------------------------------------------- #[cfg(test)] mod tests { use super::*; /// 小程序设备列表的柜级 hex 位域取值（协议 §3.8）： /// `"00"`（全正常）必须原样保留；缺失 / 空串 / 纯空白必须是 `None`（响应 `null`）。 #[test] fn test_h5_list_pick_non_empty_hex_keeps_00_but_drops_missing() { assert_eq!( pick_non_empty_hex(Some(&Some("00".into()))).as_deref(), Some("00"), "\"00\" 是「全部正常」的有效值，与「无数据」必须区分" ); assert_eq!( pick_non_empty_hex(Some(&Some("10".into()))).as_deref(), Some("10"), "柜门打开位原样透出" ); assert_eq!(pick_non_empty_hex(Some(&Some("01".into()))).as_deref(), Some("01")); assert_eq!(pick_non_empty_hex(Some(&Some(String::new()))), None); assert_eq!(pick_non_empty_hex(Some(&Some(" ".into()))), None); assert_eq!(pick_non_empty_hex(Some(&None)), None); assert_eq!(pick_non_empty_hex(None), None); } /// 通道级 HMGET 六字段（batt_status/pow_status/soc/voltage/current/temp）解析 #[test] fn test_parse_compartment_realtime_reads_all_fields() { let values: Vec> = vec![ Some("82".into()), Some("03".into()), Some("855".into()), Some("53200".into()), Some("1500".into()), Some("29815".into()), ]; let rt = parse_compartment_realtime(&values); assert_eq!(rt.batt_status.as_deref(), Some("82")); assert_eq!(rt.pow_status.as_deref(), Some("03")); assert_eq!(rt.soc, Some(855)); assert_eq!(rt.voltage, Some(53200)); assert_eq!(rt.current, Some(1500)); assert_eq!(rt.temp, Some(29815)); } /// 无数据（key 不存在 → 全是 None）时必须返回 None，而不是 0 /// （这是 ② 的核心回归点：旧实现把"无数据"回落成 0.0% / 0.0V / 0.0A） #[test] fn test_parse_compartment_realtime_no_data_returns_none_not_zero() { let values: Vec> = vec![None, None, None, None, None, None]; let rt = parse_compartment_realtime(&values); assert_eq!(rt.soc, None, "无数据不能落 0"); assert_eq!(rt.voltage, None, "无数据不能落 0"); assert_eq!(rt.current, None, "无数据不能落 0"); assert_eq!(rt.temp, None); assert!(rt.batt_status.is_none()); assert!(rt.pow_status.is_none()); } /// 真实的 0 必须原样保留（0 与"无数据"不能混为一谈） #[test] fn test_parse_compartment_realtime_real_zero_is_kept() { let values: Vec> = vec![ Some("00".into()), Some("00".into()), Some("0".into()), Some("0".into()), Some("0".into()), Some("0".into()), ]; let rt = parse_compartment_realtime(&values); assert_eq!(rt.soc, Some(0)); assert_eq!(rt.voltage, Some(0)); assert_eq!(rt.current, Some(0)); assert_eq!(rt.temp, Some(0)); assert_eq!(rt.batt_status.as_deref(), Some("00")); } /// 非数字垃圾值/结果长度不足时按无数据处理，绝不 panic、绝不落 0 #[test] fn test_parse_compartment_realtime_garbage_is_none() { let values: Vec> = vec![Some("abc".into()), Some(" ".into())]; let rt = parse_compartment_realtime(&values); assert_eq!(rt.soc, None); assert_eq!(rt.voltage, None); assert_eq!(rt.current, None); assert_eq!(rt.temp, None); // batt_status / pow_status 是 hex 字符串，原样透传（不在这里解释位含义） assert_eq!(rt.batt_status.as_deref(), Some("abc")); } /// HMGET 字段名顺序必须与解析下标一致（防止将来改字段顺序导致错位） #[test] fn test_compartment_realtime_fields_order_matches_indexes() { assert_eq!(COMPARTMENT_REALTIME_FIELDS[0], "batt_status"); assert_eq!(COMPARTMENT_REALTIME_FIELDS[1], "pow_status"); assert_eq!(COMPARTMENT_REALTIME_FIELDS[2], "soc"); assert_eq!(COMPARTMENT_REALTIME_FIELDS[3], "voltage"); assert_eq!(COMPARTMENT_REALTIME_FIELDS[4], "current"); assert_eq!(COMPARTMENT_REALTIME_FIELDS[5], "temp"); } // ----------------------------------------------------------------------- // 可见组织范围（组织隔离） // ----------------------------------------------------------------------- /// 工厂/总管理员：可见全部组织（即便自身也挂着 organization_id，也不降级为本组织） #[test] fn test_visible_org_scope_super_admin_sees_all() { assert_eq!(visible_org_scope(2, None), VisibleOrgScope::All); assert_eq!(visible_org_scope(2, Some(7)), VisibleOrgScope::All); } /// 操作员（role_level=0）：只可见自己所属组织 #[test] fn test_visible_org_scope_operator_sees_own_org_only() { assert_eq!(visible_org_scope(0, Some(42)), VisibleOrgScope::Own(42)); } /// 组织管理员（role_level=1）：同样只可见自己所属组织（不允许跨组织） #[test] fn test_visible_org_scope_org_admin_sees_own_org_only() { assert_eq!(visible_org_scope(1, Some(42)), VisibleOrgScope::Own(42)); } /// 客户侧无组织归属：空集（**不能退化成"全部"**，否则越权） #[test] fn test_visible_org_scope_org_user_without_org_is_empty() { assert_eq!(visible_org_scope(0, None), VisibleOrgScope::Empty); assert_eq!(visible_org_scope(1, None), VisibleOrgScope::Empty); } /// 客户侧 SQL 必须带组织过滤条件（防止将来被改成全量查询导致越权） #[test] fn test_visible_orgs_own_sql_filters_by_id() { assert!( VISIBLE_ORGS_BY_ID_SQL.contains("WHERE id = ?"), "客户侧可见组织查询必须按 organization_id 过滤" ); assert_eq!(visible_org_scope(0, Some(1)), VisibleOrgScope::Own(1)); } // ----------------------------------------------------------------------- // 实时在线（`is_online`）守门 —— 防回归：不得再拿 `cabinets.status` 当"在线" // ----------------------------------------------------------------------- /// 小程序列表的在线取数契约： /// ① 在线字段**恰好出现一次**且位于清单末尾（下标常量与清单同步）； /// ② 字段名与设备列表 `is_online` **逐字一致**（跨模块同源守门）。 #[test] fn test_h5_list_online_field_matches_device_list_criterion() { let online_field = crate::routes::cabinet_tree::DEVICE_ONLINE_FIELD; assert_eq!( CABINET_HMGET_ONLINE_IDX, CABINET_HMGET_FIELDS.len() - 1, "在线字段必须追加在字段清单末尾（前面的下标解析依赖顺序）" ); assert_eq!( CABINET_HMGET_FIELDS[CABINET_HMGET_ONLINE_IDX], online_field, "小程序列表在线取数字段必须与设备列表同源" ); assert_eq!( CABINET_HMGET_FIELDS.iter().filter(|f| **f == online_field).count(), 1, "在线字段只允许出现一次" ); // 三态：无数据（None）不是"离线"（false），小程序据此可以区分"未知" assert_eq!(crate::routes::cabinet_tree::device_online_flag(None), None); assert_eq!( crate::routes::cabinet_tree::device_online_flag(Some("1")), Some(true) ); assert_eq!( crate::routes::cabinet_tree::device_online_flag(Some("0")), Some(false) ); } /// 首页「在线设备」的取数 SQL **不得依赖 `cabinets.status`**， /// 且必须保留组织隔离：总管理员无组织条件、客户侧必须带 `p.organization_id = ?`。 #[test] fn test_h5_dashboard_online_sql_has_no_status_and_keeps_org_isolation() { let super_sql = online_cabinet_imeis_sql(true, ""); assert!( !super_sql.to_lowercase().contains("status"), "在线统计不得引用 cabinets.status：{}", super_sql ); assert!(super_sql.starts_with("SELECT cab.imei FROM cabinets cab")); assert!(super_sql.contains("cab.imei IS NOT NULL"), "必须排除 NULL IMEI：{}", super_sql); let org_sql = online_cabinet_imeis_sql(false, " AND p.id IN (?,?)"); assert!( !org_sql.to_lowercase().contains("status"), "在线统计不得引用 cabinets.status：{}", org_sql ); assert!( org_sql.contains("INNER JOIN projects p ON cab.project_id = p.id"), "客户侧必须经 projects 做组织隔离：{}", org_sql ); assert!(org_sql.contains("p.organization_id = ?"), "组织隔离条件丢失：{}", org_sql); assert!(org_sql.contains("AND p.id IN (?,?)"), "数据范围条件丢失：{}", org_sql); } }