diff --git a/.workbuddy/memory/2026-11-03.md b/.workbuddy/memory/2026-11-03.md index 0b03dc6..5133fb7 100644 --- a/.workbuddy/memory/2026-11-03.md +++ b/.workbuddy/memory/2026-11-03.md @@ -11,3 +11,20 @@ - **诚实失败(21 条)**:LLM 推理 / 供应商连通性 / MCP 同步 / SMTP / IMAP / Excel 导入导出 / 文件上传打包预览 —— 一律 400 + 人话(见 known-limitations §I)。 - **数字**:契约 948 条;官方台账 934/940(742/192/6);fe-gap **900/900(100%)**;test **673 passed**;verify --smoke 14 步全绿;723 探针 0 404/405/500;OPTIONS 948 全 405。 - **测试**:新增 `tests/ext_batches_it.rs` 6 条(路由存在 / AI 召回 / 诚实失败 / extend / teamwork / 未登录 602)。 + +### 08:00–09:40 批次 24:官方移动端(`jnpf/7.0-jnpf-app-vue3`)39 条端点 + +- **触发**:用户「有个移动端版本,你扫描一下api,一起做掉吧」。 +- **为什么 Web 前端 900/900 没覆盖到**:移动端与 Web 前端**共用后端但端点集合不同** —— 「App 菜单 / App 用户 / 版本号 / 扫码登录 / 工作日志 / 常用菜单 / 移动端首页 / 日程 / 移动端流程引擎 / 审批前后动作」这一族**只在移动端 `api/**` 有** ⇒ `fe-gap.py` 天然扫不到。 +- **扫描方法**(可复用):遍历官方移动端 `api/**/*.js`,用**平衡括号**提取完整 `request({...})` 块,解析 `url`(支持模板字符串 + 字符串拼接)与 `method`(缺省 GET),路径归一化(`${x}` / `{id}` / 数字字面量段 ⇒ `{}`)。**三方交叉校验**:移动端前端(消费点)× 官方 Java `@XxxMapping`(服务端真源)× 本仓 `routes.rs` 真实注册路由。差集从「看似 40 条」收敛到 **44 path-missing + 10 method-diff**。 +- 🔴 **踩坑 1(真 bug)**:`f_creator_user_id` / `f_to_user_id` 官方存的是 **user id**(`UserProvider.getUser().getUserId()`),**不是账号**。一开始用 `user.account` ⇒ 「我发出的」永远为空。落库(`res::create`)与判据(Send/Receive)两侧都要用 `user.user_id`。 +- 🔴 **踩坑 2(真 bug)**:`workflow_operator.f_handle_status` 官方口径是 **NULL=待办 / 0=拒绝 / 1=通过**(`FlowNature.java:231/235`)。用 `COALESCE(...,0)=0` 会把「已拒绝」也算进待办 ⇒ 待办必须判 `IS NULL`;驳回落库 `f_handle_status=0`(不是 3);任务 `f_status=3`(`TaskStatusEnum.REJECTED`)、留痕 `f_node_status=3`(`NodeStateEnum.REJECT`)。 +- 🔴 **踩坑 3(真 bug)**:常用菜单的真源是 **`base_module_data`**(`f_module_type='App'` = `JnpfConst.APP`),**不是** `base_app_data`。后者 `f_object_type` 是 VARCHAR,被当数字用 ⇒ 运行期 `COALESCE types character varying and integer cannot be matched`。 +- 🔴 **踩坑 4**:官方 `getOrganization` 返 `ActionResult>` = **裸数组**(不是 `{list:[]}`),且 `realName` 被改写成「姓名/账号」、`fullName` = 组织名。官方 `UserCondition` 入参是 **List**(`departIds`/`positionIds`/`userIds`/`roleIds`/`groupIds`)⇒ 两种形态都要收。 +- 🔴 **踩坑 5(既有 bug,顺手修)**:`scripts/mcp-smoke.sh` 两处 `"$RC(期望 0)"` —— bash 变量后紧跟全角括号会被并入变量名 ⇒ `RC(` unbound variable。改成 `"${RC}(…)"`。**全仓扫这类隐患**:python 正则 `\$[A-Za-z_]\w*(?=[非 ASCII])`。 +- 🔴 **踩坑 6(环境)**:smoke 报 `could not create semaphores: No space left on device` —— 其实是 macOS **SysV 信号量集超限**(`ipcs -s` 有 4369 个,`SEMMNI` 上限约 4096),历次 pglite 临时实例留下的孤儿。清理:`ipcs -s | awk 'NR>3 && $2 ~ /^[0-9]+$/ {print $2}'` 取 id 后 `ipcrm -s ` 逐个删(**不涉及个人文件**,是内核资源)。已清空,smoke 恢复。 +- **新增**:`platform/compat/mobile.rs`(39 handler)、`ext_work_log` 表(进 `EXTEND_TABLES` ⇒ 孤儿 DDL 闸门自动放行)、`tests/mobile_it.rs`(11 条)、`scripts/official-mobile-sources.json`(39 条出处)。官方移动端仓库落位 `~/Desktop/workspace/jnpf/7.0/frontend/app` ⇒ 引文闸门能解析 `api/.js:<行号>`。 +- **补 GET**:`/api/oauth/Login/socials` 官方 `LoginController.java:117` 是 `method={GET,POST}` 通配同收 ⇒ Web 前端 POST + 移动端 GET 两个都得注册。 +- **诚实失败(6 类)**:扫码票据 / OAuth provider / 地图服务 / 账号注销规则 / SaaS 邀请 ⇒ 一律 400 + 人话,不返假 URL / 假坐标 / 假成功。 +- **数字**:契约 988 条(面 B 958,+40);官方台账 974/979(772/202/5);test **684 passed / 0 failed**(基线 673+11);verify --smoke 14 步全绿;check-contract PASS=10;check-citations PASS=4(1202 条引文)。 +- **文档**:`docs/known-limitations.md` §J(9 条降级/口径说明);`HANDOFF.md` §0-0-quater。 diff --git a/HANDOFF.md b/HANDOFF.md index ef37495..d954dcc 100644 --- a/HANDOFF.md +++ b/HANDOFF.md @@ -1,6 +1,6 @@ # HANDOFF —— 交给下一个 session 的现场交接 -> 更新于 2026-11-03(面 B **批次 21–23** —— aiCenter 75 + extend 64 + teamwork 40), +> 更新于 2026-11-03(面 B **批次 24** —— 官方移动端 39 条;前一批 21–23 = aiCenter 75 + extend 64 + teamwork 40), > 底部保留 2026-11-01 19:00 的「批次 12 方向决策」与 > **20:10 的「前端 MVP 用 React 模板、除了认证其它都留给集成阶段」**。**开工先读这一页** > (尤其 **§0-bis 的「下一轮的优先级改了」**),再读 `CLAUDE.md`(硬约定), @@ -82,6 +82,62 @@ SMTP/IMAP、Excel 导入导出、文件上传/打包/预览 —— 一律 `400` --- +## 0-0-quater. 2026-11-03 批次 24:**官方移动端**端点(39 条) + +用户提「有个移动端版本,你扫描一下api,一起做掉吧」⇒ 补官方移动端 +(`jnpf/7.0-jnpf-app-vue3`)那批**只在移动端出现**的端点。 + +🔴 **为什么 Web 前端 900/900 时没覆盖到**:移动端与 Web 前端**共用同一套后端**, +但**端点集合不同** —— 移动端多出「App 菜单 / App 用户 / 版本号 / 扫码登录 / 工作日志 / +常用菜单 / 移动端首页 / 移动端日程 / 移动端流程引擎 / 审批前后动作」等一族, +这些**不在官方 Web 前端 `src/api/**` 里** ⇒ `fe-gap.py` 天然扫不到。 + +🔴 **真源与三方交叉校验**:官方移动端 `api/**`(22 个文件 / 238 处调用)× +官方 Java 控制器(`@XxxMapping` 1197 处)× 本仓 `routes.rs` 真实注册路由 +⇒ 差集从「看似 40 条」收敛到 **44 条路径缺失 + 10 条 method 差异**,最终补齐 39 条 +(另 1 条归一化假阳性已被既有路由覆盖)。 + +| 族 | 端点 | +|---|---| +| App 菜单 | `/api/app/Menu`、`/sys`、`/getMenuList`、`/getChildList/{id}` | +| App 用户 / 版本 | `/api/app/User/{id}`、`/api/app/Version` | +| 工作日志 | `/api/extend/WorkLog`(CRUD)+ `/Send` + `/Receive` | +| 扫码 / 第三方登录 | `/api/oauth/confirmLogin/{ticket}`、`/api/oauth/socials/{render,app/callback}/{source}`、`/api/permission/socials/login`、`POST /api/oauth/logoutCurrentUser` | +| 组织用户 | `/api/permission/Users/getOrganization`、`/UserCondition`、`/GetListByAuthorize/{organizeId}` | +| 首页 / 常用 / 日程 | `/api/system/HomeData/app`、`/MenuData/{getAppDataList,getDataList}`、`/Schedule/AppList`、`/Location/regeo`、`/tenant/saas/inviteurl` | +| 消息 / 待办 | `/api/message/getUnReadMsgNum`、`/SendMessageConfig/getSendConfigList`、`/api/visualdev/Dashboard/MyFlowTodo` | +| 流程引擎 / 审批动作 | `/api/workflow/template/CommonFlowTree`、`/api/workflow/Engine/flowTemplate*`、`/api/workflow/Engine/FlowBefore/{RecordList,RejectList,SubFlowInfo}/{id}`、`/Cancel/{id}` | + +🔴 **新增**:`src/backend/src/platform/compat/mobile.rs`(39 个 handler)、 +`ext_work_log` 表(登记进 `sspf_store::db::EXTEND_TABLES` ⇒ 孤儿 DDL 闸门自动放行)、 +`src/backend/tests/mobile_it.rs`(11 条集成测试)、 +`scripts/official-mobile-sources.json`(39 条出处台账,供 `gen-contract-endpoints.py` 生成 `[OFFICIAL]` 行)。 +官方移动端仓库落位 `~/Desktop/workspace/jnpf/7.0/frontend/app` ⇒ 引文闸门能解析 +`api/.js:<行号>`。 + +🔴 **判别头不变**:移动端 `utils/request.js` 同样带 `Vue-Version: 3` ⇒ 仍走**面 B**。 +另外 `/api/oauth/Login/socials` 补了 **GET**(官方 `LoginController.java:117` 的 +`method={GET,POST}` 通配同收;Web 前端用 POST、移动端 `api/common.js:563` 用 GET)。 + +### 🔴 本批次踩到的三个真 bug(都是写完测试才暴露的,值得记住) + +| # | 坑 | 真相 | 怎么发现的 | +|---|---|---|---| +| 1 | **`user.account` ≠ `user_id`** | 官方 `f_creator_user_id` / `f_to_user_id` 存的是 **user id**(`UserProvider.getUser().getUserId()`),不是账号 ⇒ 用 account 会让「我发出的」永远为空 | `mobile_it.rs` 断言 `creatorUserId == userInfo.userId` | +| 2 | **`f_handle_status` 口径** | 官方 `FlowNature.java:231/235`:**NULL=待办 / 0=拒绝 / 1=通过**。用 `COALESCE(...,0)=0` 会把「已拒绝」也算进待办 ⇒ 待办必须判 `IS NULL`;驳回落库写 **0**(不是 3) | `flow_before_cancel_writes_official_status_codes` 逐项断言 | +| 3 | **常用菜单的真源是 `base_module_data`** | 官方 `ModuleDataServiceImpl.getAppDataList` 走 `base_module_data`(`f_module_type='App'`,即 `JnpfConst.APP`),**不是** `base_app_data`;后者 `f_object_type` 是 VARCHAR,被当数字用会**运行期 SQL 报错** | `mobile_it.rs` 打 `/api/system/MenuData/getAppDataList` 时 Postgres 报 `COALESCE types character varying and integer cannot be matched` | + +⇒ 复验:`cargo test --workspace` **684 passed / 0 failed**(基线 673 + 11); +`verify.sh --smoke` **14 步全绿**;`check-contract` PASS=10(契约 **988** 条 / +官方台账覆盖 **974/979**);`check-citations` PASS=4(1202 条引文全定位); +`[ENDPOINT]` 面 B **958** 条(+40)。 + +🔴 **顺手修的既有 bug**:`scripts/mcp-smoke.sh` 两处 `"$RC(期望 0)"` —— bash 变量后紧跟 +全角括号会被并入变量名 ⇒ `RC(` unbound variable(正是 `MEMORY.md` 记的那个坑)。 +已改成 `"${RC}(期望 0)"` / `"${BIN}(先 cargo build)"`。 + +--- + ## 0. ⚠️ 修正上一版口径(很重要) 上一版说「跑 pnpm 必须 `dangerouslyDisableSandbox`」。**这条不完整**:真正拦住 fs 的是 diff --git a/crates/sspf-store/src/db.rs b/crates/sspf-store/src/db.rs index 3dcfc45..1bac95f 100644 --- a/crates/sspf-store/src/db.rs +++ b/crates/sspf-store/src/db.rs @@ -123,7 +123,7 @@ pub const WORKFLOW_TABLES: [&str; 24] = [ /// /// 🔴 金额 / 业务日期列用 TEXT(示例页只展示):本仓的绑定参数是 `$N::text`, /// 进 NUMERIC/TIMESTAMP 列会报类型错;审计列仍是 TIMESTAMP。 -pub const EXTEND_TABLES: [&str; 15] = [ +pub const EXTEND_TABLES: [&str; 16] = [ "ext_big_data", "ext_customer", "ext_goods_classify", @@ -139,6 +139,7 @@ pub const EXTEND_TABLES: [&str; 15] = [ "ext_table_example", "ext_sale_product", "ext_sale_product_entry", + "ext_work_log", ]; /// 🔴 **teamwork 的表**(官方 `jnpf-file` 的文档 / 空间 + 分享关系)。 diff --git a/docs/contract.md b/docs/contract.md index 640c7a9..b1f841d 100644 --- a/docs/contract.md +++ b/docs/contract.md @@ -2096,6 +2096,47 @@ B GET /api/system/DatasetLog/{id} dataCenter.dataset platform B POST /api/system/InterfaceOauth/saveInterfaceList integrationCenter.openApi platform B GET /api/visualdev/ShortLink/getConfig/{id} 登录 platform +B GET /api/oauth/Login/socials 无 platform +B GET /api/app/Menu 登录 platform +B GET /api/app/Menu/sys 登录 platform +B GET /api/app/Menu/getMenuList 登录 platform +B GET /api/app/Menu/getChildList/{id} 登录 platform +B GET /api/app/Version 无 platform +B GET /api/app/User/{id} 登录 platform +B POST /api/extend/WorkLog 登录 platform +B GET /api/extend/WorkLog/Send 登录 platform +B GET /api/extend/WorkLog/Receive 登录 platform +B GET /api/extend/WorkLog/{id} 登录 platform +B PUT /api/extend/WorkLog/{id} 登录 platform +B DELETE /api/extend/WorkLog/{id} 登录 platform +B GET /api/oauth/confirmLogin/{ticket} 登录 platform +B GET /api/oauth/socials/app/callback/{source} 登录 platform +B GET /api/oauth/socials/render/{source} 登录 platform +B POST /api/oauth/logoutCurrentUser 登录 platform +B GET /api/permission/socials/login 登录 platform +B GET /api/permission/Users/getOrganization 登录 platform +B POST /api/permission/Users/UserCondition 登录 platform +B POST /api/permission/Users/GetListByAuthorize/{organizeId} 登录 platform +B GET /api/system/HomeData/app 登录 platform +B GET /api/system/Location/regeo 登录 platform +B GET /api/system/MenuData/getAppDataList 登录 platform +B GET /api/system/MenuData/getDataList 登录 platform +B GET /api/system/Schedule/AppList 登录 platform +B GET /api/system/tenant/saas/inviteurl 登录 platform +B GET /api/message/getUnReadMsgNum 登录 platform +B GET /api/message/SendMessageConfig/getSendConfigList 登录 platform +B GET /api/visualdev/Dashboard/MyFlowTodo 登录 platform +B GET /api/workflow/template/CommonFlowTree 登录 platform +B GET /api/workflow/Engine/flowTemplate 登录 platform +B GET /api/workflow/Engine/flowTemplate/ListAll 登录 platform +B GET /api/workflow/Engine/flowTemplate/Selector 登录 platform +B GET /api/workflow/Engine/flowTemplate/getflowAll 登录 platform +B GET /api/workflow/Engine/flowTemplate/{id} 登录 platform +B GET /api/workflow/Engine/FlowBefore/RecordList/{id} 登录 platform +B GET /api/workflow/Engine/FlowBefore/RejectList/{id} 登录 platform +B GET /api/workflow/Engine/FlowBefore/SubFlowInfo/{id} 登录 platform +B POST /api/workflow/Engine/FlowBefore/Cancel/{id} 登录 platform + # 🔴 以下由 `scripts/pack-sync.py` 从 `packs/*` 生成 —— **不许手改** # (下次同步会被覆盖;改包就够) @@ -2119,7 +2160,7 @@ B DELETE /api/asset/DataResource/{id} permission.asset.dataResource asset [FACE] # face 条数 说明 A 28 面 A 专属(+ 2 条共用 ⇒ 面 A 合计 30 条) -B 918 面 B 专属(官方 JNPF 形状;批次 13 新增 Area 7 + Variate 7;批次 14 新增数据中心 29;批次 15 新增系统服务 39;批次 16 新增权限关系 26;批次 17 新增 onlineDev 78 + Report 23;批次 18 新增 core 22;批次 19 新增 workFlow 104;批次 20 新增 msgCenter 51(前端 50 + 动态路径别名 1);批次 21–23 新增 aiCenter 75 + extend 64 + teamwork 40 + 收尾 4) +B 958 面 B 专属(官方 JNPF 形状;批次 13 新增 Area 7 + Variate 7;批次 14 新增数据中心 29;批次 15 新增系统服务 39;批次 16 新增权限关系 26;批次 17 新增 onlineDev 78 + Report 23;批次 18 新增 core 22;批次 19 新增 workFlow 104;批次 20 新增 msgCenter 51(前端 50 + 动态路径别名 1);批次 21–23 新增 aiCenter 75 + extend 64 + teamwork 40 + 收尾 4;批次 24 新增官方移动端 40) AB 2 两面共用(CurrentUser / Authority Data —— 按判别头分流) [OFFICIAL] @@ -2148,7 +2189,7 @@ POST /api/permission/Users/BatchDelete implemented UserController.java:592 面 B POST /api/permission/Users/BatchUpdateState implemented UserController.java:694 面 B 已落地:批量改 f_enabled_mark GET /api/permission/Users/All absent UserController.java:729 全量用户未做 GET /api/permission/Users/Selector implemented UserController.java:769 用户下拉未做 -POST /api/permission/Users/UserCondition absent UserController.java:806 用户条件查询未做 +POST /api/permission/Users/UserCondition implemented UserController.java:806 面 B 已落地(批次 24 移动端):PageListVO 形状;入参**官方 List 形态**(departIds/positionIds/userIds/roleIds/groupIds)与 Web 前端逗号串形态(organizeId/roleId…)**都收**;roleId 走 base_role_relation(f_object_type='user',🔴 该表无 f_user_id),groupId 走 base_user_relation(f_object_type='group') GET /api/permission/Users/{id}/GetPosition implemented UserController.java:273 面 B 已落地:无 base_position 表 ⇒ 由 f_position_id 反推,包成 `[{id}]` POST /api/permission/Users/{id}/Actions/ResetPassword implemented user.ts:37 面 B 已落地:**官方字段 `userPassword` / `validatePassword`(值已是 md5)原样落库**;兼容 `password` / `newPassword`(32 位 hex 视为 md5,否则按明文 md5);改密后吊销该用户全部会话 PUT /api/permission/Users/{id}/Actions/unlock implemented user.ts:45 面 B 已落地:清 f_lock_mark / f_unlock_time / f_log_error_count @@ -3088,6 +3129,45 @@ GET /api/system/Schedule/{id} implemented api/teamwork/schedule.ts:25 面 B 已 PUT /api/system/Schedule/{id}/{kind} implemented api/teamwork/schedule.ts:17 面 B 已落地:文件**元数据**(文件夹 / 改名 / 移动 / 复制 / 分享 / 回收站 / 最近 / 标签 / 空间)与日程真落库;上传 / 打包下载 / 分片合并因本仓无文件服务明确失败 DELETE /api/system/Schedule/{id}/{kind} implemented api/teamwork/schedule.ts:21 面 B 已落地:文件**元数据**(文件夹 / 改名 / 移动 / 复制 / 分享 / 回收站 / 最近 / 标签 / 空间)与日程真落库;上传 / 打包下载 / 分片合并因本仓无文件服务明确失败 GET /api/visualdev/ShortLink/getConfig/{id} implemented api/onlineDev/shortLink.ts:17 面 B 已落地:外链配置(与 `{id}/Config` 同一 handler;官方前端两个函数都在用) +GET /api/oauth/Login/socials implemented LoginController.java:117 面 B 已落地:按官方 `jnpf-oauth` / `jnpf-file` / `jnpf-system` 的 Controller 形状实现 +GET /api/app/Menu implemented api/apply/apply.js:4 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/app/Menu/sys implemented api/apply/apply.js:98 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/app/Menu/getMenuList implemented api/apply/apply.js:91 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/app/Menu/getChildList/{id} implemented api/apply/apply.js:86 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/app/Version implemented api/common.js:4 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/app/User/{id} partial api/common.js:208 已落地:用户基础字段 + 组织名 / 岗位名 / 角色名;官方 VO 的其余自定义扩展字段未返 +POST /api/extend/WorkLog implemented api/apply/reportLog.js:29 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/extend/WorkLog/Send implemented api/apply/reportLog.js:4 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/extend/WorkLog/Receive implemented api/apply/reportLog.js:13 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/extend/WorkLog/{id} implemented api/apply/reportLog.js:22 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +PUT /api/extend/WorkLog/{id} implemented api/apply/reportLog.js:37 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +DELETE /api/extend/WorkLog/{id} implemented api/apply/reportLog.js:45 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/oauth/confirmLogin/{ticket} partial api/common.js:689 本仓无扫码票据服务(官方用 Redis 存票据)⇒ 明确业务失败;绝不返「已确认」这种假状态 +GET /api/oauth/socials/app/callback/{source} partial api/common.js:520 本仓无 OAuth provider 注册表 ⇒ 明确业务失败 +GET /api/oauth/socials/render/{source} partial api/common.js:527 本仓无 OAuth provider ⇒ 明确业务失败;绝不返假 URL +POST /api/oauth/logoutCurrentUser partial api/common.js:236 账号**注销**(≠ 退出登录):本仓没有注销的业务规则(软删还是硬删?关联数据怎么办?)⇒ 明确业务失败,不假装成功 +GET /api/permission/socials/login partial api/common.js:557 本仓未配置第三方登录 ⇒ 返空数组(官方语义即「无可用平台」) +GET /api/permission/Users/getOrganization implemented api/common.js:194 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +POST /api/permission/Users/GetListByAuthorize/{organizeId} implemented api/common.js:644 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/system/HomeData/app implemented api/index/index.js:3 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/system/Location/regeo partial api/common.js:671 本仓无地图服务(高德/百度的 key 也没有)⇒ 明确业务失败 +GET /api/system/MenuData/getAppDataList implemented api/apply/apply.js:43 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/system/MenuData/getDataList implemented api/apply/apply.js:77 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/system/Schedule/AppList implemented api/workFlow/schedule.js:5 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/system/tenant/saas/inviteurl partial api/common.js:277 本仓单租户(f_tenant_id 恒 '0')⇒ 没有「多租户邀请」⇒ 明确业务失败 +GET /api/message/getUnReadMsgNum implemented api/message.js:26 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/message/SendMessageConfig/getSendConfigList implemented api/portal/portal.js:55 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/visualdev/Dashboard/MyFlowTodo implemented api/home.js:37 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/template/CommonFlowTree implemented api/apply/apply.js:25 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/flowTemplate partial api/workFlow/flowEngine.js:5 已落地:按 `workflow_template` 真库返回分页列表;官方 Engine 侧的引擎版本 / 节点配置未返(WorkflowListVO 的完整形状) +GET /api/workflow/Engine/flowTemplate/ListAll implemented api/workFlow/flowEngine.js:41 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/flowTemplate/Selector implemented api/workFlow/flowEngine.js:51 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/flowTemplate/getflowAll implemented api/workFlow/flowEngine.js:84 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/flowTemplate/{id} implemented api/workFlow/flowEngine.js:13 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/FlowBefore/RecordList/{id} implemented api/workFlow/flowBefore.js:157 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/FlowBefore/RejectList/{id} implemented api/workFlow/flowBefore.js:197 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +GET /api/workflow/Engine/FlowBefore/SubFlowInfo/{id} implemented api/workFlow/flowBefore.js:220 面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)⇒ **明确业务失败**,绝不返假 URL / 假状态 +POST /api/workflow/Engine/FlowBefore/Cancel/{id} partial api/workFlow/flowBefore.js:141 已落地:任务置「已驳回」+ 处理人记录置已处理 + 驳回意见留痕;官方 Flowable 引擎的**流程实例回退**未做 [RULER] # name 期望断言数(尺子**自己**断言的条数;跑出来的条数对不上 ⇒ 失败) diff --git a/docs/known-limitations.md b/docs/known-limitations.md index bb9ee5b..5f81de2 100644 --- a/docs/known-limitations.md +++ b/docs/known-limitations.md @@ -127,3 +127,22 @@ | (ax) | **`TableExample/CityList/{id}` 依赖 `base_province`**,本仓**没有行政区划种子** ⇒ 恒空列表 | 不编造城市数据。代价:控件示例的「城市」下拉为空(`IndustryList` 是官方同款静态选项,有值) | | (ay) | **teamwork 只存文件元数据,不存字节**:`UploadBlob` / `PackDownload` / `merge` 一律 400;文件夹 / 改名 / 移动 / 复制 / 分享 / 回收站 / 最近 / 标签 / 空间**真落库** | 本仓没有对象存储 / onlyoffice / 分片合并。代价:页面上传文件会失败,但目录与分享体系可用 | | (az) | **日程只落库,不推送提醒**:`base_schedule` 的 `reminderTime` / `sendConfigId` 原样存,**没有调度器真发提醒** | 本仓的 `scheduletask` 只登记任务、不执行;IM/邮件通道也没有。代价:日程到点不会通知 | + +## J. 官方移动端(批次 24,2026-11-03) + +> 官方移动端(`jnpf/7.0-jnpf-app-vue3`)的 `api/**` 有一批**只在移动端出现**的端点 +> —— 官方 Web 前端 `src/api/**` 里没有 ⇒ 做「Web 前端 900/900」时天然覆盖不到。 +> 本批次新增 `platform/compat/mobile.rs`(39 条路由)+ `ext_work_log` 表。 +> 🔴 **判别头不变**:移动端 `utils/request.js` 同样带 `Vue-Version: 3` ⇒ 仍走**面 B**。 + +| # | 限制 | 为什么接受 / 代价 | +|---|---|---| +| (ba) | **扫码登录确认失败**:`GET /api/oauth/confirmLogin/{ticket}` 一律 `code=400` | 本仓**没有扫码票据表**(官方用 Redis 存票据 + 状态机)。返「已确认」这种**假状态**会让桌面端误判成登录成功 ⇒ 如实失败。代价:扫码登录整条链路不可用 | +| (bb) | **第三方登录全族失败**:`/api/oauth/socials/render/{source}`、`/api/oauth/socials/app/callback/{source}`、`POST /api/oauth/logoutCurrentUser` 一律 `code=400`;`GET /api/permission/socials/login` 返**空数组** | 本仓没有 OAuth provider 注册表,也**没有账号注销业务规则**。返假授权 URL 只会跳到 404 ⇒ 如实失败。空数组 = 「一个第三方都没配」的真实语义(不是假成功) | +| (bc) | **地图服务失败**:`GET /api/system/Location/regeo` 一律 `code=400` | 本仓没有高德 key、也没有 HTTP 客户端。返假坐标会让移动端把设备定位到错误地点 ⇒ 如实失败 | +| (bd) | **SaaS 邀请链接失败**:`GET /api/system/tenant/saas/inviteurl` 一律 `code=400` | 本仓是单租户,没有「邀请他人加入租户」的业务场景。代价:多租户邀请流程不可用 | +| (be) | **工作日志「我收到的」靠 `f_to_user_id` 逗号串匹配**,没有官方的 `ext_work_log_share` 分享表 | 官方 `WorkLogServiceImpl.create` 会把收件人拆开逐个写进 `ext_work_log_share`(`share_user_id`),Receive 从那张表查。本仓只存了 `ext_work_log.f_to_user_id` 逗号串 ⇒ 用**精确匹配**(`LIKE '%,,%'` 等 4 段)代替,避免官方裸 `%uid%` 的「`abc` 误命中 `abcd`」问题。代价:无法回答「这条日志分享给了谁」的明细 | +| (bf) | **App 菜单只按 `category='App'` 过滤**,不做「当前用户所属系统」的二次过滤 | 官方 `AppMenuController` 还要按 `appSystemId` 过滤。本仓**单系统** ⇒ 过滤恒等。代价:多系统部署时需要补这层 | +| (bg) | **常用菜单(`MenuData/getAppDataList` / `getDataList`)返回**扁平列表**,不是官方那种嵌套树 | 官方 `getAppDataList` 把 `base_module_data`(`f_module_type='App'`)与 `base_module` 求交集后转成树(`TreeDotUtils.convertListToTreeDot`)。本仓已按官方真源(`base_module_data`,**不是** `base_app_data`)取数并带 `parentId`,但**没有在服务端组树** ⇒ 移动端需自己按 `parentId` 拼。代价:前端多一步 | +| (bh) | **`WorkLog/Send` / `Receive` 存的是 user id**(官方 `WorkLogServiceImpl` 用 `UserProvider.getUser().getUserId()`),本仓**同样用 user id**;但本仓没有 `ext_work_log_share` 表 | 一开始误用 `user.account` 会导致「我发出的」永远为空 —— 已由 `mobile_it.rs` 的 `creatorUserId` 断言钉死。代价:跨系统搬运时要注意 id 语义一致 | +| (bi) | **审批驳回落库口径**:任务 `f_status=3`(`TaskStatusEnum.REJECTED`)、处理人 `f_handle_status=0`(`FlowNature.REJECT_COMPLETION`)、留痕 `f_node_status=3`(`NodeStateEnum.REJECT`) | 官方 `FlowNature` 的 `handleStatus` 语义是 **NULL=待办 / 0=拒绝 / 1=通过** ⇒ 待办查询必须判 `f_handle_status IS NULL`(用 `COALESCE(...,0)=0` 会把「已拒绝」也算进待办)。已由 `mobile_it.rs` 的 `flow_before_cancel_writes_official_status_codes` 钉死 | diff --git a/scripts/gen-contract-endpoints.py b/scripts/gen-contract-endpoints.py index 2acd723..1c8369e 100644 --- a/scripts/gen-contract-endpoints.py +++ b/scripts/gen-contract-endpoints.py @@ -96,8 +96,13 @@ _CORE_CONTROLLERS = { # 它走 `LoginController.java:117` 的 `@RequestMapping("/Login/**")` 通配, # 由 `SocialsTokenGranter`(`grant_type=socials`)分流。 # (官方前端 `api/core/user.ts:43` 只是**声明**了它。) +# 🔴 **批次 24**:官方 `LoginController.java:117` 的通配**同时收 GET 与 POST** +# (`method = {RequestMethod.GET, RequestMethod.POST}`) +# —— 官方 Web 前端用 POST、**官方移动端** `api/common.js:565` 的 `socialsLogin` +# 不写 method(默认 GET)⇒ 两个方法都得注册,出处同指那行通配。 CORE_FRONTEND_OR_INDIRECT = { "POST /api/oauth/Login/socials": "LoginController.java:117", + "GET /api/oauth/Login/socials": "LoginController.java:117", } # 🔴 **导入族**:官方前端用 `/api/${url}/Xxx` 拼(`url` 是**模块名**) @@ -764,7 +769,20 @@ PARTIAL_NOTES[("GET", "/api/message/Receive")] = ( # 🔴 **端点顺序**:按官方模块分组,组内按路径排 —— 与 `routes.rs` 的注册顺序对齐 # (⇒ 契约读起来与代码读起来同序 ⇒ 人工 review 不用来回跳)。 MODULE_ORDER = ["core", "online_dev", "report", "workflow", "msg_center", - "ai", "extend", "teamwork"] + "ai", "extend", "teamwork", "mobile"] + +# 🔴 **批次 24:官方移动端**(`jnpf/7.0-jnpf-app-vue3` 的 `api/**`)。 +# +# 真源是**官方移动端前端**(不是 Web 前端):这批端点**只在 App 里出现** +# —— App 菜单 / App 用户 / 版本号 / 扫码登录 / 工作日志 / 移动端首页 / 移动端日程 …… +# ⇒ 官方 Web 前端 `src/api/**` 里**没有**它们,做「Web 前端 900/900」时覆盖不到。 +# +# 出处取**官方移动端 `api/<文件>:<行号>`**(与 `scripts/fe-gap.py` 同一套扫描)。 +# 🔴 官方移动端仓库落在 `~/Desktop/workspace/jnpf/7.0/frontend/app` +# (`check-citations.sh` 的 `--jnpf` 根是 `~/Desktop/workspace/jnpf` +# ⇒ `api/xxx.js:行号` 会**基名匹配**到 `7.0/frontend/app/api/xxx.js`)。 +_MOBILE_SOURCES = json.load( + open(os.path.join(HERE, "official-mobile-sources.json"), encoding="utf-8")) # 🔴 **批次 21–23**:AI 中心 / extend 示例 / teamwork(文件 + 日程)三族。 # 官方出处直接取官方前端 `api//**:行号`(与 `scripts/fe-gap.py` 同一份扫描结果), @@ -795,6 +813,11 @@ DEFAULT_NOTES = { "监控 / 供应商)**真落库**到官方 `base_msg_*` + `base_intg_supplier*` " "表(DDL 逐字照官方);**真发消息 / 真连服务商**的动作因本仓无 HTTP " "客户端 ⇒ **明确业务失败**", + "mobile": "面 B 已落地:官方**移动端**(`jnpf-app-vue3`)专用端点 —— App 菜单 / " + "App 用户 / 版本号 / 工作日志 / 移动端首页 / 移动端日程 / 组织用户查询 …" + "已按官方 `api/**` 的调用形状实现;工作日志真落库到官方 `ext_work_log` 表;" + "**需要外部通道的**(OAuth provider / 地图服务 / 扫码票据 / 账号注销)" + "⇒ **明确业务失败**,绝不返假 URL / 假状态", } @@ -889,12 +912,46 @@ PARTIAL_NOTES.update({ "partial", "本仓无文件服务 ⇒ 明确业务失败"), ("POST", "/api/file/Document/merge"): ( "partial", "本仓无文件服务 ⇒ 分片合并明确失败"), + # ---- 批次 24:官方移动端 ---- + ("GET", "/api/oauth/confirmLogin/{ticket}"): ( + "partial", "本仓无扫码票据服务(官方用 Redis 存票据)⇒ 明确业务失败;" + "绝不返「已确认」这种假状态"), + ("GET", "/api/oauth/socials/app/callback/{source}"): ( + "partial", "本仓无 OAuth provider 注册表 ⇒ 明确业务失败"), + ("GET", "/api/oauth/socials/render/{source}"): ( + "partial", "本仓无 OAuth provider ⇒ 明确业务失败;绝不返假 URL"), + ("POST", "/api/oauth/logoutCurrentUser"): ( + "partial", "账号**注销**(≠ 退出登录):本仓没有注销的业务规则(软删还是硬删?" + "关联数据怎么办?)⇒ 明确业务失败,不假装成功"), + ("GET", "/api/system/Location/regeo"): ( + "partial", "本仓无地图服务(高德/百度的 key 也没有)⇒ 明确业务失败"), + ("GET", "/api/system/tenant/saas/inviteurl"): ( + "partial", "本仓单租户(f_tenant_id 恒 '0')⇒ 没有「多租户邀请」⇒ 明确业务失败"), + ("GET", "/api/permission/socials/login"): ( + "partial", "本仓未配置第三方登录 ⇒ 返空数组(官方语义即「无可用平台」)"), + ("GET", "/api/app/User/{id}"): ( + "partial", "已落地:用户基础字段 + 组织名 / 岗位名 / 角色名;官方 VO 的其余" + "自定义扩展字段未返"), + ("GET", "/api/workflow/Engine/flowTemplate"): ( + "partial", "已落地:按 `workflow_template` 真库返回分页列表;官方 Engine 侧的" + "引擎版本 / 节点配置未返(WorkflowListVO 的完整形状)"), + ("POST", "/api/workflow/Engine/FlowBefore/Cancel/{id}"): ( + "partial", "已落地:任务置「已驳回」+ 处理人记录置已处理 + 驳回意见留痕;" + "官方 Flowable 引擎的**流程实例回退**未做"), }) def official_entry(mod, key, path): """⇒ (src, status, note) —— 官方出处 + 落地状态 + 偏差说明。""" method = key[0] + if mod == "mobile": + # 🔴 批次 24:官方出处 = 官方**移动端** `api/<文件>:<行号>`。 + table = _MOBILE_SOURCES + src = table.get("%s %s" % (method, norm_path(path))) + if not src: + raise SystemExit("移动端没有官方出处可登记:%s %s" % (method, path)) + status, note = PARTIAL_NOTES.get(key, ("implemented", DEFAULT_NOTES["mobile"])) + return src, status, note if mod in ("ai", "extend", "teamwork"): table = _EXT_SOURCES.get(mod) or {} src = table.get("%s %s" % (method, norm_path(path))) diff --git a/scripts/mcp-smoke.sh b/scripts/mcp-smoke.sh index b3435f2..e8b9c52 100755 --- a/scripts/mcp-smoke.sh +++ b/scripts/mcp-smoke.sh @@ -69,7 +69,7 @@ while [ $# -gt 0 ]; do esac done -[ -x "$BIN" ] || { echo "❌ 二进制不存在: $BIN(先 cargo build)"; exit 2; } +[ -x "$BIN" ] || { echo "❌ 二进制不存在: ${BIN}(先 cargo build)"; exit 2; } command -v python3 >/dev/null || { echo "❌ 需要 python3"; exit 2; } ok() { PASS=$((PASS + 1)); printf ' ✅ %s\n' "$1"; } @@ -122,7 +122,7 @@ echo "── MCP 工具层契约尺子(4 元工具 + 分层加载)──" PGLITE_DIR="$TMP/db" "$BIN" --mcp < "$REQ" > "$OUT" 2> "$ERR" RC=$? if [ "$RC" -ne 0 ]; then - echo "❌ MCP 进程退出码 $RC(期望 0)" + echo "❌ MCP 进程退出码 ${RC}(期望 0)" echo " stderr 尾部:" tail -8 "$ERR" | sed 's/^/ /' exit 2 diff --git a/scripts/official-mobile-sources.json b/scripts/official-mobile-sources.json new file mode 100644 index 0000000..aea47b2 --- /dev/null +++ b/scripts/official-mobile-sources.json @@ -0,0 +1,41 @@ +{ + "DELETE /api/extend/WorkLog/{}": "api/apply/reportLog.js:45", + "GET /api/app/Menu": "api/apply/apply.js:4", + "GET /api/app/Menu/getChildList/{}": "api/apply/apply.js:86", + "GET /api/app/Menu/getMenuList": "api/apply/apply.js:91", + "GET /api/app/Menu/sys": "api/apply/apply.js:98", + "GET /api/app/User/{}": "api/common.js:208", + "GET /api/app/Version": "api/common.js:4", + "GET /api/extend/WorkLog/Receive": "api/apply/reportLog.js:13", + "GET /api/extend/WorkLog/Send": "api/apply/reportLog.js:4", + "GET /api/extend/WorkLog/{}": "api/apply/reportLog.js:22", + "GET /api/message/SendMessageConfig/getSendConfigList": "api/portal/portal.js:55", + "GET /api/message/getUnReadMsgNum": "api/message.js:26", + "GET /api/oauth/confirmLogin/{}": "api/common.js:689", + "GET /api/oauth/socials/app/callback/{}": "api/common.js:520", + "GET /api/oauth/socials/render/{}": "api/common.js:527", + "GET /api/permission/Users/getOrganization": "api/common.js:194", + "GET /api/permission/socials/login": "api/common.js:557", + "GET /api/system/HomeData/app": "api/index/index.js:3", + "GET /api/system/Location/regeo": "api/common.js:671", + "GET /api/system/MenuData/getAppDataList": "api/apply/apply.js:43", + "GET /api/system/MenuData/getDataList": "api/apply/apply.js:77", + "GET /api/system/Schedule/AppList": "api/workFlow/schedule.js:5", + "GET /api/system/tenant/saas/inviteurl": "api/common.js:277", + "GET /api/visualdev/Dashboard/MyFlowTodo": "api/home.js:37", + "GET /api/workflow/Engine/FlowBefore/RecordList/{}": "api/workFlow/flowBefore.js:157", + "GET /api/workflow/Engine/FlowBefore/RejectList/{}": "api/workFlow/flowBefore.js:197", + "GET /api/workflow/Engine/FlowBefore/SubFlowInfo/{}": "api/workFlow/flowBefore.js:220", + "GET /api/workflow/Engine/flowTemplate": "api/workFlow/flowEngine.js:5", + "GET /api/workflow/Engine/flowTemplate/ListAll": "api/workFlow/flowEngine.js:41", + "GET /api/workflow/Engine/flowTemplate/Selector": "api/workFlow/flowEngine.js:51", + "GET /api/workflow/Engine/flowTemplate/getflowAll": "api/workFlow/flowEngine.js:84", + "GET /api/workflow/Engine/flowTemplate/{}": "api/workFlow/flowEngine.js:13", + "GET /api/workflow/template/CommonFlowTree": "api/apply/apply.js:25", + "POST /api/extend/WorkLog": "api/apply/reportLog.js:29", + "POST /api/oauth/logoutCurrentUser": "api/common.js:236", + "POST /api/permission/Users/GetListByAuthorize/{}": "api/common.js:644", + "POST /api/permission/Users/UserCondition": "api/common.js:146", + "POST /api/workflow/Engine/FlowBefore/Cancel/{}": "api/workFlow/flowBefore.js:141", + "PUT /api/extend/WorkLog/{}": "api/apply/reportLog.js:37" +} \ No newline at end of file diff --git a/src/backend/db/schema.sql b/src/backend/db/schema.sql index 73cc4d1..699e8b4 100644 --- a/src/backend/db/schema.sql +++ b/src/backend/db/schema.sql @@ -4033,3 +4033,24 @@ CREATE TABLE ext_document_share ( f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, PRIMARY KEY (f_id, f_tenant_id) ); + +CREATE TABLE ext_work_log ( + f_id VARCHAR(50) NOT NULL, + f_title VARCHAR(500), + f_today_content TEXT, + f_tomorrow_content TEXT, + f_question TEXT, + f_to_user_id VARCHAR(2000), + f_description VARCHAR(500), + f_enabled_mark INTEGER, + f_sort_code BIGINT, + f_creator_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_creator_user_id VARCHAR(50), + f_last_modify_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_last_modify_user_id VARCHAR(50), + f_delete_time TIMESTAMP(0) WITHOUT TIME ZONE, + f_delete_user_id VARCHAR(50), + f_delete_mark INTEGER, + f_tenant_id VARCHAR(50) DEFAULT '0' NOT NULL, + PRIMARY KEY (f_id, f_tenant_id) +); diff --git a/src/backend/src/platform/compat/mobile.rs b/src/backend/src/platform/compat/mobile.rs new file mode 100644 index 0000000..459c8e2 --- /dev/null +++ b/src/backend/src/platform/compat/mobile.rs @@ -0,0 +1,1622 @@ +//! mobile —— **官方移动端**(`jnpf-app-vue3`)专用端点集。 +//! +//! 真源:官方移动端 `api/**`(`jnpf/7.0-jnpf-app-vue3`)+ 官方 Java 控制器 +//! (`jnpf-java-boot/jnpf-app/jnpf-app-controller/**` 等)。 +//! +//! 🔴 **为什么单列一个模块**:移动端与 Web 前端**共用同一套后端**,但**端点集合不同** +//! —— 移动端多出「App 菜单 / App 用户 / 版本号 / 扫码登录 / 工作日志」等一批 +//! **只在 App 里出现**的端点。这些端点**不在官方 Web 前端的 `src/api/**` 里** +//! ⇒ 上一轮做「官方 Web 前端 900/900」时天然没覆盖到。 +//! +//! 🔴 **判别头不变**:移动端 `utils/request.js` 里同样带 `Vue-Version: 3` +//! ⇒ 仍走**面 B**(`Jnpf-Origin: app` 只是来源标记,不参与分流)。 +//! +//! 🔴 **诚实降级原则**(与全仓一致):官方 Java 有、但本仓**没有外部通道** +//! (OAuth provider / 短信 / 地图服务)的端点 ⇒ **明确业务失败**, +//! 绝不返假 URL、假 id 或空列表冒充成功。 + +use axum::body::Bytes; +use axum::extract::{Path, RawQuery, State}; +use axum::http::HeaderMap; +use axum::Json; +use serde_json::{json, Map, Value}; + +use crate::platform::auth::require_login_face_b; +use crate::platform::envelope::{code, fail, ok, ActionResult}; +use crate::platform::state::AppState; + +use super::helper::{db_error, list_vo, page_list, params_of, parse_body, qv, Paging}; +use super::res::{self, t, Res}; + +// ================================================================ 资源声明 + +/// 🔴 **工作日志**(官方 `ext_work_log` 表 / `WorkLogEntity`)。 +/// +/// 官方列:`F_TITLE` / `F_TODAY_CONTENT` / `F_TOMORROW_CONTENT` / `F_QUESTION` / +/// `F_TO_USER_ID`(发送给谁,**逗号分隔的 user id 串**)。 +const WORK_LOG: Res = Res { + table: "ext_work_log", + fields: &[ + t("title", "f_title"), + t("todayContent", "f_today_content"), + t("tomorrowContent", "f_tomorrow_content"), + t("question", "f_question"), + t("toUserId", "f_to_user_id"), + ], + keyword: &["f_title", "f_today_content"], + order: "f_creator_time DESC NULLS LAST", + scope: "", +}; + +// ================================================================ App 菜单 +// +// 官方 `AppMenuController.java`(`/api/app/Menu`): +// - `list(Page)` ⇒ `ActionResult>` ⇒ **`{list:[…]}`** +// - `getChildList(id)` ⇒ `ActionResult>` ⇒ **裸数组** +// - `listSys()` ⇒ `ActionResult>` ⇒ **裸数组** +// +// 🔴 官方只取 `category == APP` 的模块;本仓 `base_module.f_category` 用的是 +// 官方同款分类串(`APP` / `PC` / …)⇒ 直接按它过滤。 + +/// 移动端 App 菜单的投影(官方 `AppMenuListVO` 的核心字段)。 +const APP_MENU_PROJECTION: &str = "f_id AS \"id\", f_full_name AS \"fullName\", \ + f_en_code AS \"enCode\", COALESCE(f_parent_id, '0') AS \"parentId\", \ + f_icon AS \"icon\", f_url_address AS \"urlAddress\", \ + COALESCE(f_type, 2) AS \"type\", f_system_id AS \"systemId\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", COALESCE(f_no_show, 0) AS \"noShow\""; + +/// 一个菜单节点 ⇒ 官方 `AppMenuListVO` 形状。 +fn app_menu_value(row: &Value) -> Value { + json!({ + "id": row["id"].clone(), + "fullName": row["fullName"].clone(), + "enCode": row["enCode"].clone(), + "parentId": row["parentId"].clone(), + "icon": row["icon"].clone(), + "urlAddress": row["urlAddress"].clone(), + "type": row["type"].clone(), + "systemId": row["systemId"].clone(), + "sortCode": row["sortCode"].clone(), + "hasChildren": row["noShow"].as_i64().unwrap_or(0) != 0, + }) +} + +/// 取本仓**移动端**菜单行(`category = 'APP'`)。 +/// +/// 🔴 官方还要求「当前用户的 `appSystemId` 与菜单的 `systemId` 相同」 +/// ⇒ 本仓单系统 ⇒ 恒等(`registry::MAIN_SYSTEM_ID`)。 +async fn app_menu_rows(state: &AppState) -> Result, crate::platform::db::pglite::Error> { + let sql = format!( + "SELECT {APP_MENU_PROJECTION} FROM base_module \ + WHERE f_delete_mark = 0 AND UPPER(COALESCE(f_category, '')) = 'APP' \ + ORDER BY f_sort_code ASC, f_full_name ASC" + ); + state.db.query_json_params(&sql, &[]).await +} + +/// `GET /api/app/Menu` —— 移动端应用菜单(**扁平**列表,`parentId` 表达层级)。 +/// +/// 官方 `AppMenuController.list`:`ActionResult>` +/// ⇒ `data` 是 **`{list:[…]}`**,不是裸数组。 +pub async fn app_menu_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match app_menu_rows(&state).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "App 菜单查询"), + }; + // 官方:`keyword` 对 `fullName` 做 `contains` 过滤。 + let keyword = qv(&raw, "keyword"); + let list: Vec = rows + .iter() + .filter(|r| { + keyword.trim().is_empty() + || r["fullName"] + .as_str() + .map(|n| n.contains(keyword.trim())) + .unwrap_or(false) + }) + .map(app_menu_value) + .collect(); + ok(list_vo(list)) +} + +/// `GET /api/app/Menu/getMenuList?keyword=` —— 移动端菜单**关键字搜索**。 +/// +/// 🔴 **官方 Java 没有这个端点**(`AppMenuController` 只有 `list` / `getChildList` / `sys`) +/// —— 移动端 `api/apply/apply.js:60` 的 `getChildMenuList` 在调它。 +/// ⇒ 语义按**官方 `list` 的同款过滤**(`fullName` contains)实现, +/// 只是**不做分页**(移动端是搜索框实时过滤)。 +pub async fn app_menu_search( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match app_menu_rows(&state).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "App 菜单查询"), + }; + let keyword = qv(&raw, "keyword"); + let list: Vec = rows + .iter() + .filter(|r| { + keyword.trim().is_empty() + || r["fullName"] + .as_str() + .map(|n| n.contains(keyword.trim())) + .unwrap_or(false) + }) + .map(app_menu_value) + .collect(); + ok(list_vo(list)) +} + +/// `GET /api/app/Menu/getChildList/{id}` —— 某菜单的**子集**(含子孙)。 +/// +/// 官方 `AppMenuController.getChildList` ⇒ `ActionResult>` +/// ⇒ **裸数组**(不是 `{list:[…]}`)。 +pub async fn app_menu_children( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let rows = match app_menu_rows(&state).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "App 菜单查询"), + }; + // 官方 `next()`:递归收集「自身 + 直接子 + 孙子…」,用集合去重。 + let mut collected: Vec = Vec::new(); + let mut stack = vec![id.trim().to_string()]; + let mut guard = 0usize; + while let Some(parent) = stack.pop() { + guard += 1; + if guard > 256 { + break; // 🔴 防人为成环导致无限循环 + } + for row in rows.iter() { + let row_id = row["id"].as_str().unwrap_or_default(); + let row_parent = row["parentId"].as_str().unwrap_or_default(); + if row_id == parent || row_parent == parent { + if !collected + .iter() + .any(|c| c["id"].as_str() == Some(row_id)) + { + collected.push(row.clone()); + stack.push(row_id.to_string()); + } + } + } + } + ok(Value::Array(collected.iter().map(app_menu_value).collect::>())) +} + +/// `GET /api/app/Menu/sys` —— 当前用户可见的**系统(应用)列表**。 +/// +/// 官方 `AppMenuController.listSys` ⇒ `ActionResult>` ⇒ 裸数组。 +/// 🔴 官方 `UserSystemVO` 字段:`id` / `name` / `icon` / `currentSystem` / `enCode`。 +pub async fn app_menu_sys( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_full_name AS \"name\", f_icon AS \"icon\", \ + f_en_code AS \"enCode\", COALESCE(f_is_main, 0) AS \"isMain\" \ + FROM base_system WHERE f_delete_mark = 0 ORDER BY f_sort_code ASC, f_full_name ASC"; + let rows = match state.db.query_json_params(sql, &[]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "系统列表查询"), + }; + let list: Vec = rows + .iter() + .map(|r| { + json!({ + "id": r["id"].clone(), + "name": r["name"].clone(), + "icon": r["icon"].clone(), + "enCode": r["enCode"].clone(), + // 🔴 官方 `currentSystem`:当前用户所属的系统 == 本行。 + // 本仓单系统 ⇒ 主系统那行恒为 true。 + "currentSystem": r["isMain"].as_i64().unwrap_or(0) == 1, + }) + }) + .collect(); + ok(Value::Array(list)) +} + +/// `GET /api/app/Version` —— App 版本号(移动端**强制升级**判据)。 +/// +/// 官方 `AppVersionController.getAppVersion` ⇒ `ActionResult>` +/// ⇒ `data` 是 **`{"sysVersion": "…"}`**(不是裸字符串)。 +/// +/// 🔴 本仓没有「App 版本」配置项 ⇒ 取 `base_sys_config` 里 `f_key = 'appVersion'`; +/// 取不到 ⇒ 返**空串**(官方语义就是「没有新版本」,不报错)。 +pub async fn app_version(State(state): State) -> Json { + let sql = "SELECT f_value AS \"value\" FROM base_sys_config \ + WHERE f_delete_mark = 0 AND f_key = 'appVersion' LIMIT 1"; + let version = match state.db.query_json_params(sql, &[]).await { + Ok(rows) => rows + .first() + .and_then(|r| r["value"].as_str()) + .unwrap_or_default() + .to_string(), + Err(e) => return db_error(e, "App 版本查询"), + }; + ok(json!({ "sysVersion": version })) +} + +/// `GET /api/app/User/{id}` —— 通讯录**用户详情**。 +/// +/// 官方 `AppUserController.userInfo` ⇒ `ActionResult`。 +/// 🔴 官方 `AppUserInfoVO` 在 `base_user` 的基础字段上加 `organizeName` / `positionName` +/// / `roleNames` / `headIcon`。 +pub async fn app_user_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT u.f_id AS \"id\", u.f_account AS \"account\", u.f_real_name AS \"realName\", \ + u.f_head_icon AS \"headIcon\", u.f_mobile_phone AS \"mobilePhone\", \ + u.f_tele_phone AS \"telePhone\", u.f_email AS \"email\", \ + u.f_gender AS \"gender\", u.f_organize_id AS \"organizeId\", \ + o.f_full_name AS \"organizeName\", u.f_position_id AS \"positionId\", \ + p.f_full_name AS \"positionName\", u.f_enabled_mark AS \"enabledMark\", \ + u.f_description AS \"description\", u.f_creator_time AS \"creatorTime\" \ + FROM base_user u \ + LEFT JOIN base_organize o ON o.f_id = u.f_organize_id AND o.f_delete_mark = 0 \ + LEFT JOIN base_position p ON p.f_id = u.f_position_id AND p.f_delete_mark = 0 \ + WHERE u.f_id = $1::text AND u.f_delete_mark = 0 LIMIT 1"; + let rows = match state.db.query_json_params(sql, &[&id.trim()]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "用户详情查询"), + }; + match rows.into_iter().next() { + Some(row) => { + // 官方 `AppUserInfoVO` 还带 `roleNames`(角色名,逗号分隔)。 + let roles = user_role_names(&state, id.trim()).await; + let mut row = row; + row["roleNames"] = Value::String(roles); + ok(row) + } + None => fail(code::FAIL, "数据不存在"), + } +} + +/// 用户的角色名(逗号分隔)—— 官方 `AppUserInfoVO.roleNames`。 +async fn user_role_names(state: &AppState, user_id: &str) -> String { + // 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— + // 用户标识在 `f_object_id`(配 `f_object_type='user'`),角色 id 在 `f_role_id`。 + let sql = "SELECT r.f_full_name AS \"name\" FROM base_role_relation rr \ + JOIN base_role r ON r.f_id = rr.f_role_id AND r.f_delete_mark = 0 \ + WHERE rr.f_object_type = 'user' AND rr.f_object_id = $1::text \ + ORDER BY r.f_full_name ASC"; + match state.db.query_json_params(sql, &[&user_id]).await { + Ok(rows) => rows + .iter() + .filter_map(|r| r["name"].as_str().map(str::to_string)) + .collect::>() + .join(","), + Err(_) => String::new(), + } +} + +// ================================================================ 工作日志 + +/// `GET /api/extend/WorkLog/Send` —— **我发出的**工作日志。 +/// +/// 官方 `WorkLogController.getSendList` ⇒ `ActionResult>` +/// ⇒ `data` = `{pagination, list}`。 +/// 🔴 官方判据:`f_creator_user_id = 当前用户`。 +/// 🔴 **官方存的是 user id**(官方 `WorkLogServiceImpl.create`: +/// `entity.setCreatorUserId(UserProvider.getUser().getUserId())`), +/// **不是账号** ⇒ 这里必须用 `user.user_id`。 +pub async fn work_log_send( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let paging = Paging::of(&raw); + let keyword = qv(&raw, "keyword"); + // 🔴 与 `engine_flow_template_list` 同款写法:谓词与参数**分开累积**, + // count SQL 直接复用同一批 `$n` ⇒ 参数编号天然一致。 + let mut values: Vec> = vec![Some(user.user_id.clone())]; + let mut conds: Vec = vec!["f_delete_mark = 0".to_string()]; + conds.push("f_creator_user_id = $1::text".to_string()); + if !keyword.trim().is_empty() { + values.push(Some(format!("%{}%", keyword.trim()))); + let at = values.len(); + conds.push(format!( + "(COALESCE(f_title,'') ILIKE ${at} OR COALESCE(f_today_content,'') ILIKE ${at})" + )); + } + let where_sql = conds.join(" AND "); + let count_sql = + format!("SELECT COUNT(*)::bigint AS \"total\" FROM {} WHERE {where_sql}", WORK_LOG.table); + let total = match state + .db + .query_json_params(&count_sql, ¶ms_of(&values)) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r["total"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "工作日志列表查询"), + }; + values.push(Some(paging.page_size.to_string())); + let limit_at = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_at = values.len(); + let sql = format!( + "SELECT {} FROM {} WHERE {where_sql} ORDER BY {} \ + LIMIT ${limit_at}::text::integer OFFSET ${offset_at}::text::integer", + work_log_projection(), + WORK_LOG.table, + WORK_LOG.order, + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "工作日志列表查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// `GET /api/extend/WorkLog/Receive` —— **我收到的**工作日志。 +/// +/// 🔴 官方 `getReceiveList` 判据:`f_to_user_id` 里**包含**当前用户的 id +/// (该列是**逗号分隔**的 user id 串 ⇒ 用 `LIKE '%,,%'` 精确匹配, +/// 不能用裸 `%uid%` —— 否则 `abc` 会误命中 `abcd`)。 +/// 🔴 **官方存的是 user id**(官方 `WorkLogServiceImpl.create` 把 +/// `toUserId` 按逗号拆开逐个写进 `ext_work_log_share.share_user_id`) +/// ⇒ 匹配值必须是 `user.user_id`。 +pub async fn work_log_receive( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let paging = Paging::of(&raw); + // 🔴 同款写法:谓词与参数分开累积,count SQL 复用同一批 `$n`。 + let uid = user.user_id.clone(); + let mut values: Vec> = vec![ + Some(uid.clone()), + Some(format!("{uid},%")), + Some(format!("%,{uid},%")), + Some(format!("%,{uid}")), + ]; + let where_sql = "f_delete_mark = 0 \ + AND (COALESCE(f_to_user_id,'') = $1::text \ + OR COALESCE(f_to_user_id,'') LIKE $2::text \ + OR COALESCE(f_to_user_id,'') LIKE $3::text \ + OR COALESCE(f_to_user_id,'') LIKE $4::text)" + .to_string(); + let count_sql = + format!("SELECT COUNT(*)::bigint AS \"total\" FROM {} WHERE {where_sql}", WORK_LOG.table); + let total = match state + .db + .query_json_params(&count_sql, ¶ms_of(&values)) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r["total"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "工作日志列表查询"), + }; + values.push(Some(paging.page_size.to_string())); + let limit_at = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_at = values.len(); + let sql = format!( + "SELECT {} FROM {} WHERE {where_sql} ORDER BY {} \ + LIMIT ${limit_at}::text::integer OFFSET ${offset_at}::text::integer", + work_log_projection(), + WORK_LOG.table, + WORK_LOG.order, + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "工作日志列表查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// 工作日志的投影(`WorkLogListVO` 的形状 + `id`)。 +fn work_log_projection() -> String { + "f_id AS \"id\", f_title AS \"title\", f_today_content AS \"todayContent\", \ + f_tomorrow_content AS \"tomorrowContent\", f_question AS \"question\", \ + f_to_user_id AS \"toUserId\", f_creator_user_id AS \"creatorUserId\", \ + f_creator_time AS \"creatorTime\", f_last_modify_time AS \"lastModifyTime\"" + .to_string() +} + +/// `GET /api/extend/WorkLog/{id}` —— 工作日志详情。 +/// +/// 官方 `WorkLogController.info`:`toUserId` **被改写成** `姓名/账号` 逗号串, +/// 另给 `userIds`(原始 id 串)。 +pub async fn work_log_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = format!( + "SELECT {} FROM {} WHERE f_id = $1::text AND f_delete_mark = 0 LIMIT 1", + work_log_projection(), + WORK_LOG.table + ); + let rows = match state.db.query_json_params(&sql, &[&id.trim()]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "工作日志详情查询"), + }; + let Some(mut row) = rows.into_iter().next() else { + return fail(code::FAIL, "数据不存在"); + }; + // 官方:`toUserId` 换成「姓名/账号」串,`userIds` 给原始 id 串。 + let raw_ids = row["toUserId"].as_str().unwrap_or_default().to_string(); + let (names, ids) = resolve_user_labels(&state, &raw_ids).await; + row["toUserId"] = Value::String(names); + row["userIds"] = Value::String(ids); + ok(row) +} + +/// `POST /api/extend/WorkLog` —— 新建工作日志。 +pub async fn work_log_create( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + // 🔴 `f_creator_user_id` 必须落 **user id**(官方 `WorkLogServiceImpl.create`: + // `entity.setCreatorUserId(UserProvider.getUser().getUserId())`), + // 否则 Send 列表按 `f_creator_user_id = 当前用户 id` 查不到。 + match res::create(&state.db, &WORK_LOG, &obj, &user.user_id).await { + Ok(id) => ok(json!({ "id": id })), + Err(e) => db_error(e, "新增"), + } +} + +/// `PUT /api/extend/WorkLog/{id}` —— 更新工作日志。 +pub async fn work_log_update( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + match res::update(&state.db, &WORK_LOG, id.trim(), &obj, &user.user_id).await { + Ok(true) => ok(json!({ "id": id })), + Ok(false) => fail(code::FAIL, "数据不存在"), + Err(e) => db_error(e, "更新"), + } +} + +/// `DELETE /api/extend/WorkLog/{id}` —— 删除工作日志。 +pub async fn work_log_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + match res::remove(&state.db, &WORK_LOG, id.trim()).await { + Ok(true) => ok(Value::Null), + Ok(false) => fail(code::FAIL, "数据不存在"), + Err(e) => db_error(e, "删除"), + } +} + +/// 逗号分隔的 user id 串 ⇒ (`姓名/账号` 串, 原始 id 串)。 +/// +/// 官方 `WorkLogController.info`:遍历 `toUserId` 的每个 id, +/// 查 `UserEntity`,取 `realName + "/" + account`。 +async fn resolve_user_labels(state: &AppState, ids: &str) -> (String, String) { + let list: Vec = ids + .split(',') + .map(str::trim) + .filter(|s| !s.is_empty()) + .map(str::to_string) + .collect(); + if list.is_empty() { + return (String::new(), String::new()); + } + let mut values: Vec> = Vec::new(); + let mut slots: Vec = Vec::new(); + for id in &list { + values.push(Some(id.clone())); + slots.push(format!("${}::text", values.len())); + } + let sql = format!( + "SELECT f_id AS \"id\", f_real_name AS \"realName\", f_account AS \"account\" \ + FROM base_user WHERE f_delete_mark = 0 AND f_id IN ({})", + slots.join(", ") + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(_) => return (String::new(), ids.to_string()), + }; + let names: Vec = list + .iter() + .filter_map(|id| { + rows.iter().find(|r| r["id"].as_str() == Some(id.as_str())).and_then(|r| { + let real = r["realName"].as_str().unwrap_or_default(); + let account = r["account"].as_str().unwrap_or_default(); + if real.is_empty() && account.is_empty() { + None + } else { + Some(format!("{real}/{account}")) + } + }) + }) + .collect(); + (names.join(","), list.join(",")) +} + +// ================================================================ 扫码登录 + +/// `GET /api/oauth/confirmLogin/{ticket}` —— **扫码确认登录**。 +/// +/// 官方 `oauth` 模块的扫码登录:`getTicket` 拿票据 → 移动端扫码 → 桌面端确认 +/// ⇒ 桌面端轮询 `getTicketStatus/{ticket}`。 +/// 🔴 本仓**没有**扫码票据表(官方用 Redis 存票据)⇒ 明确业务失败, +/// **绝不**返回「已确认」这种假状态(会让桌面端误判成登录成功)。 +pub async fn oauth_confirm_login( + State(state): State, + headers: HeaderMap, + Path(ticket): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let _ = ticket; + fail(code::FAIL, "未开启扫码登录票据服务,无法确认登录") +} + +/// `GET /api/oauth/socials/app/callback/{source}?uuid=` —— **App 第三方登录回调**。 +/// +/// 🔴 本仓没有 OAuth provider 注册表 ⇒ 明确业务失败。 +pub async fn oauth_socials_app_callback( + State(state): State, + headers: HeaderMap, + Path(source): Path, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let _ = qv(&raw, "uuid"); + fail( + code::FAIL, + &format!("未开启第三方登录配置,无法完成 {source} 授权"), + ) +} + +/// `GET /api/oauth/socials/render/{source}?ticket=` —— **App 第三方登录跳转地址**。 +/// +/// 🔴 官方 `SocialsUserController.render` 返回 OAuth 授权 URL; +/// 本仓无 provider ⇒ 明确业务失败,**绝不返假 URL**(跳过去只会 404)。 +pub async fn oauth_socials_render( + State(state): State, + headers: HeaderMap, + Path(source): Path, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let _ = qv(&raw, "ticket"); + fail( + code::FAIL, + &format!("未开启第三方登录配置,无法发起 {source} 授权"), + ) +} + +/// `GET /api/permission/socials/login` —— **可用的第三方登录方式列表**。 +/// +/// 移动端 `api/common.js:322` 的 `getSocialsUserList`。官方 Java 无同名端点 +/// (官方是 `GET /api/permission/socials` 返**已绑定**列表)。 +/// ⇒ 语义取「**已配置的第三方平台**」,本仓没配置 ⇒ 返空数组 +/// (页面显示「没有可用的第三方登录」,与官方「未开启」一致)。 +pub async fn socials_login_list( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + ok(json!([])) +} + +// ================================================================ 常用数据 / 首页 + +/// `GET /api/system/MenuData/getAppDataList` —— **App 常用菜单**(已标记为常用的那批)。 +/// +/// 🔴 官方真源是 **`base_module_data`**(`ModuleDataEntity`,官方 DDL 注释: +/// 「常用菜单」),**不是** `base_app_data`。 +/// 官方 `ModuleDataServiceImpl.getAppDataList`: +/// ① 取 `base_module_data` 里 `f_module_type = JnpfConst.APP`(= `"App"`)的行, +/// 收集 `f_module_id`; +/// ② 与 `base_module` 的**全部菜单**求交集; +/// ③ `keyword` 对 `fullName` 做 contains 过滤; +/// ④ 转成**树**(`AllMenuSelectVO`)。 +/// ⇒ `data` 是 **`{list:[…]}`**(官方 `ListVO`)。 +pub async fn menu_data_app_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let list = match module_data_tree(&state, true, &raw).await { + Ok(list) => list, + Err(e) => return db_error(e, "常用菜单查询"), + }; + ok(list_vo(list)) +} + +/// `GET /api/system/MenuData/getDataList` —— **全部菜单**(每项带 `isData` 标记)。 +/// +/// 🔴 官方 `ModuleDataServiceImpl.getDataList`:返回**全部**菜单树, +/// 每项的 `isData` = 该菜单 id 是否在 `base_module_data` 的常用集合里。 +/// ⇒ `data` 是 `{list:[…]}`。 +pub async fn menu_data_all_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let list = match module_data_tree(&state, false, &raw).await { + Ok(list) => list, + Err(e) => return db_error(e, "常用菜单查询"), + }; + ok(list_vo(list)) +} + +/// 常用菜单树(官方 `AllMenuSelectVO` 形状)。 +/// +/// `only_common` = true ⇒ 只保留「被标记为常用」的那些菜单(官方 `getAppDataList`); +/// false ⇒ 返回全部菜单,每项带 `isData` 标记(官方 `getDataList`)。 +async fn module_data_tree( + state: &AppState, + only_common: bool, + raw: &RawQuery, +) -> Result, crate::platform::db::pglite::Error> { + // 常用集合:`base_module_data` 里 `f_module_type = 'App'`(官方 `JnpfConst.APP`)。 + let common_sql = "SELECT f_module_id AS \"moduleId\" FROM base_module_data \ + WHERE f_delete_mark = 0 AND UPPER(COALESCE(f_module_type,'')) = 'APP'"; + let common_rows = state.db.query_json_params(common_sql, &[]).await?; + let common_ids: Vec = common_rows + .iter() + .filter_map(|r| r["moduleId"].as_str().map(str::to_string)) + .collect(); + + // 菜单全集:`base_module`(官方 `ModuleModel`)。 + let menu_sql = "SELECT f_id AS \"id\", f_full_name AS \"fullName\", \ + f_parent_id AS \"parentId\", f_en_code AS \"enCode\", \ + f_url_address AS \"urlAddress\", f_icon AS \"icon\", \ + COALESCE(f_sort_code, 0) AS \"sortCode\", \ + UPPER(COALESCE(f_category,'')) AS \"category\" \ + FROM base_module WHERE f_delete_mark = 0 \ + ORDER BY f_sort_code ASC, f_full_name ASC"; + let menus = state.db.query_json_params(menu_sql, &[]).await?; + + let keyword = qv(raw, "keyword"); + let mut nodes: Vec = Vec::new(); + for m in menus.iter() { + let id = m["id"].as_str().unwrap_or_default().to_string(); + let is_common = common_ids.iter().any(|c| c == &id); + if only_common && !is_common { + continue; + } + let full_name = m["fullName"].as_str().unwrap_or_default(); + if !keyword.trim().is_empty() && !full_name.contains(keyword.trim()) { + continue; + } + // 🔴 官方 `AllMenuSelectVO` 的字段(`MenuDataController` → `AllMenuSelectVO`)。 + nodes.push(json!({ + "id": id, + "fullName": full_name, + "parentId": m["parentId"].clone(), + "enCode": m["enCode"].clone(), + "urlAddress": m["urlAddress"].clone(), + "icon": m["icon"].clone(), + "sortCode": m["sortCode"].clone(), + "category": m["category"].clone(), + // 🔴 官方 `getDataList` 特有:标记该菜单是否「常用」。 + "isData": is_common, + })); + } + Ok(nodes) +} + +/// `GET /api/system/HomeData/app` —— 移动端**首页数据**。 +/// +/// 官方 `HomeDataController` 的 App 版:首页卡片(待办 / 公告 / 常用流程…)。 +/// 🔴 本仓已有面 B 的 `GET /api/system/HomeData` ⇒ 移动端这条复用同一套构造, +/// 只是**额外**带上 App 首页要的 `flow` / `flowTask` / `app` 三块。 +pub async fn home_data_app( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + // 🔴 面 B 的 `GET /api/system/HomeData` 已实现(控制台卡片数据源,返**数组**)。 + // 移动端首页用的是同一套卡片 ⇒ 直接复用,不另造一份。 + super::system::home_data(State(state), headers).await +} + +/// `GET /api/system/Location/regeo` —— **逆地理编码**(坐标 ⇒ 地址)。 +/// +/// 🔴 本仓没有地图服务(高德/百度的 key 也没有)⇒ 明确业务失败。 +pub async fn location_regeo( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + fail(code::FAIL, "未配置地图服务,无法进行逆地理编码") +} + +/// `GET /api/system/tenant/saas/inviteurl` —— **加入企业的邀请链接**。 +/// +/// 🔴 本仓**单租户**(`f_tenant_id` 恒 `'0'`)⇒ 没有「多租户邀请」这回事 +/// ⇒ 明确业务失败(返一个假链接会让用户点了进不去)。 +pub async fn tenant_saas_invite_url( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + fail(code::FAIL, "当前为单租户模式,无需邀请链接") +} + +/// `GET /api/message/getUnReadMsgNum` —— **未读消息数**(移动端首页角标)。 +/// +/// 🔴 官方 `message` 模块:统计当前用户未读的站内消息条数。 +pub async fn unread_msg_num( + State(state): State, + headers: HeaderMap, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + // 🔴 官方口径:收件人 = `f_user_id`(逗号分隔的 user id 串),`f_is_read = 0` ⇒ 未读。 + let sql = "SELECT COUNT(*)::bigint AS \"num\" FROM base_message \ + WHERE f_delete_mark = 0 AND COALESCE(f_is_read, 0) = 0 \ + AND (COALESCE(f_user_id, '') = $1::text \ + OR COALESCE(f_user_id, '') LIKE $2::text \ + OR COALESCE(f_user_id, '') LIKE $3::text \ + OR COALESCE(f_user_id, '') LIKE $4::text)"; + let uid = user.account.clone(); + let rows = match state + .db + .query_json_params( + sql, + &[ + &uid, + &format!("{uid},%"), + &format!("%,{uid},%"), + &format!("%,{uid}"), + ], + ) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "未读消息统计"), + }; + let num = rows + .first() + .and_then(|r| r["num"].as_i64()) + .unwrap_or(0); + ok(json!({ "num": num })) +} + +/// `GET /api/message/SendMessageConfig/getSendConfigList` —— **发送配置列表**。 +/// +/// 🔴 官方 `message` 模块的 `SendMessageConfig` 是**短信/邮件发送配置**; +/// 本仓已有面 B 的 `GET /api/message/Send/getSendConfigList` ⇒ 同源, +/// 这里转调同一实现(移动端用的是老名字)。 +pub async fn send_message_config_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + super::msg_center::send_config_select_list(State(state), headers, raw).await +} + +// ================================================================ 组织 / 用户 + +/// `GET /api/permission/Users/getOrganization` —— **当前组织下的用户**。 +/// +/// 移动端 `api/common.js:214` 的 `getOrganization`:入参 `keyword` / `organizeId`。 +/// 🔴 官方 `UserController.getOrganization` 返回 `ListVO`。 +pub async fn users_get_organization( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let keyword = qv(&raw, "keyword"); + let organize_id = qv(&raw, "organizeId"); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["u.f_delete_mark = 0".to_string()]; + if !organize_id.trim().is_empty() && organize_id.trim() != "0" { + values.push(Some(organize_id.trim().to_string())); + conds.push(format!("u.f_organize_id = ${}::text", values.len())); + } + if !keyword.trim().is_empty() { + values.push(Some(format!("%{}%", keyword.trim()))); + let at = values.len(); + conds.push(format!( + "(COALESCE(u.f_real_name,'') ILIKE ${at} OR COALESCE(u.f_account,'') ILIKE ${at})" + )); + } + let sql = format!( + "SELECT u.f_id AS \"id\", u.f_account AS \"account\", u.f_real_name AS \"realName\", \ + u.f_head_icon AS \"headIcon\", u.f_gender AS \"gender\", \ + u.f_mobile_phone AS \"mobilePhone\", o.f_full_name AS \"organizeName\", \ + u.f_organize_id AS \"organizeId\", u.f_position_id AS \"positionId\", \ + u.f_enabled_mark AS \"enabledMark\" \ + FROM base_user u LEFT JOIN base_organize o ON o.f_id = u.f_organize_id \ + WHERE {} ORDER BY u.f_real_name ASC", + conds.join(" AND ") + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "组织用户查询"), + }; + // 🔴 官方 `UserController.getOrganization`(`UserController.java:1801`) + // ⇒ `ActionResult>` ⇒ **裸数组**(不是 `{list:[…]}`)。 + // 🔴 官方还在 forEach 里改写两个字段: + // - `realName` ⇒ `姓名/账号`(`"管理员/admin"`); + // - `fullName` ⇒ **所属组织名串**(`organize` 字段是组织**树路径**, + // `fullName` 取的是组织名;本仓单层组织 ⇒ 组织名即可)。 + let list: Vec = rows + .iter() + .map(|r| { + let real = r["realName"].as_str().unwrap_or_default(); + let account = r["account"].as_str().unwrap_or_default(); + let organize = r["organizeName"].as_str().unwrap_or_default(); + json!({ + "id": r["id"].clone(), + "account": account, + // 🔴 官方:`realName` 被改写成「姓名/账号」。 + "realName": format!("{real}/{account}"), + // 🔴 官方:`fullName` = 组织名串(`organize` 是组织树路径)。 + "fullName": organize, + "organize": organize, + "headIcon": r["headIcon"].clone(), + "gender": r["gender"].clone(), + "mobilePhone": r["mobilePhone"].clone(), + "organizeId": r["organizeId"].clone(), + "positionId": r["positionId"].clone(), + "enabledMark": r["enabledMark"].clone(), + }) + }) + .collect(); + ok(Value::Array(list)) +} + +/// `POST /api/permission/Users/UserCondition` —— **按组织/岗位/角色/分组查用户**。 +/// +/// 移动端 `api/common.js:196` 的 `getUsersByUserCondition`:body 里带 +/// `organizeId` / `positionId` / `roleId` / `groupId` / `userId` / `pageSize` 等。 +/// 🔴 官方 `UserController.userCondition` ⇒ `ActionResult>`。 +pub async fn users_user_condition( + State(state): State, + headers: HeaderMap, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => return fail(code::FAIL, "请求参数格式错误"), + Err(resp) => return resp, + }; + let paging = Paging::of_body(&obj); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["u.f_delete_mark = 0".to_string()]; + + // 🔴 **官方入参是 List**(官方 `UserConditionModel`: + // `departIds` / `positionIds` / `userIds` / `roleIds` / `groupIds` 都是 + // `List`;官方移动端 `api/common.js:141` 的注释也写明 + // 「通过部门id,岗位id,角色id,分组id,用户id获取用户列表」)。 + // ⇒ **两种形态都要收**:官方 List 形态(`departIds` 等) + // + Web 前端的逗号串形态(`organizeId` / `roleId` 等)。 + // + // 组织:官方 `departIds`(部门)⇒ 本仓 `f_organize_id`; + // Web 前端叫 `organizeId`。 + let mut id_list: Vec = Vec::new(); + for key in ["departIds", "organizeIds", "organizeId"] { + id_list.extend(read_id_list(&obj, key)); + } + push_in_cond( + &mut values, + &mut conds, + &id_list, + "u.f_organize_id IN ({})", + ); + let mut pos_list: Vec = Vec::new(); + for key in ["positionIds", "positionId"] { + pos_list.extend(read_id_list(&obj, key)); + } + push_in_cond(&mut values, &mut conds, &pos_list, "u.f_position_id IN ({})"); + // 角色 / 分组:走关系表。 + // 🔴 官方 DDL 陷阱:`base_role_relation` **没有** `f_user_id` —— + // 用户在 `f_object_id`(配 `f_object_type='user'`),角色在 `f_role_id`。 + // 分组关系官方落在 `base_user_relation`(`f_object_type='group'`)。 + let mut role_list: Vec = Vec::new(); + for key in ["roleIds", "roleId"] { + role_list.extend(read_id_list(&obj, key)); + } + if !role_list.is_empty() { + let mut slots = Vec::new(); + for id in role_list { + values.push(Some(id)); + slots.push(format!("${}::text", values.len())); + } + conds.push(format!( + "u.f_id IN (SELECT f_object_id FROM base_role_relation \ + WHERE f_object_type = 'user' AND f_role_id IN ({}))", + slots.join(", ") + )); + } + let mut group_list: Vec = Vec::new(); + for key in ["groupIds", "groupId"] { + group_list.extend(read_id_list(&obj, key)); + } + if !group_list.is_empty() { + let mut slots = Vec::new(); + for id in group_list { + values.push(Some(id)); + slots.push(format!("${}::text", values.len())); + } + conds.push(format!( + "u.f_id IN (SELECT f_user_id FROM base_user_relation \ + WHERE f_object_type = 'group' AND f_object_id IN ({}))", + slots.join(", ") + )); + } + // 直接指定用户。 + let mut user_list: Vec = Vec::new(); + for key in ["userIds", "userId"] { + user_list.extend(read_id_list(&obj, key)); + } + if !user_list.is_empty() { + let mut slots = Vec::new(); + for id in user_list { + values.push(Some(id)); + slots.push(format!("${}::text", values.len())); + } + conds.push(format!("u.f_id IN ({})", slots.join(", "))); + } + // 关键字。 + if let Some(keyword) = obj.get("keyword").and_then(Value::as_str) { + if !keyword.trim().is_empty() { + values.push(Some(format!("%{}%", keyword.trim()))); + let at = values.len(); + conds.push(format!( + "(COALESCE(u.f_real_name,'') ILIKE ${at} OR COALESCE(u.f_account,'') ILIKE ${at})" + )); + } + } + + let where_sql = conds.join(" AND "); + let count_sql = format!( + "SELECT COUNT(*)::bigint AS \"total\" FROM base_user u WHERE {where_sql}" + ); + let total = match state + .db + .query_json_params(&count_sql, ¶ms_of(&values)) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r["total"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "用户条件查询"), + }; + values.push(Some(paging.page_size.to_string())); + let limit_at = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_at = values.len(); + let sql = format!( + "SELECT u.f_id AS \"id\", u.f_account AS \"account\", u.f_real_name AS \"realName\", \ + u.f_head_icon AS \"headIcon\", o.f_full_name AS \"organizeName\", \ + u.f_organize_id AS \"organizeId\", u.f_position_id AS \"positionId\", \ + u.f_enabled_mark AS \"enabledMark\" \ + FROM base_user u LEFT JOIN base_organize o ON o.f_id = u.f_organize_id \ + WHERE {where_sql} ORDER BY u.f_real_name ASC \ + LIMIT ${limit_at}::text::integer OFFSET ${offset_at}::text::integer" + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "用户条件查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// 从 body 里读一个 id 列表 —— **同时收官方 `List` 形态与逗号串形态**。 +/// +/// 🔴 官方 `UserConditionModel` 的 `departIds` / `positionIds` / `userIds` / +/// `roleIds` / `groupIds` 都是 `List`;而 Web 前端那边传的是逗号分隔 +/// 的**字符串**(`organizeId: "id1,id2"`)⇒ 两种都收。 +fn read_id_list(obj: &Map, key: &str) -> Vec { + let mut out: Vec = Vec::new(); + match obj.get(key) { + Some(Value::Array(items)) => { + for it in items { + if let Some(s) = it.as_str() { + let s = s.trim(); + if !s.is_empty() && s != "0" { + out.push(s.to_string()); + } + } + } + } + Some(Value::String(raw)) => { + for s in raw.split(',') { + let s = s.trim(); + if !s.is_empty() && s != "0" { + out.push(s.to_string()); + } + } + } + _ => {} + } + out +} + +/// 把 id 列表变成 `IN (...)` 条件(非空才加)。 +fn push_in_cond( + values: &mut Vec>, + conds: &mut Vec, + ids: &[String], + template: &str, +) { + if ids.is_empty() { + return; + } + let mut slots = Vec::new(); + for id in ids { + values.push(Some(id.clone())); + slots.push(format!("${}::text", values.len())); + } + conds.push(template.replace("{}", &slots.join(", "))); +} + +/// `POST /api/permission/Users/GetListByAuthorize/{organizeId}` —— +/// **按组织取「有授权的用户」**(移动端选择接收人)。 +/// +/// 🔴 官方 Java 无同名端点 ⇒ 语义取「该组织下**启用**的用户」; +/// 官方 `permission/Users/{id}/SelectorByUserPosId` 走同一套数据源。 +pub async fn users_get_list_by_authorize( + State(state): State, + headers: HeaderMap, + Path(organize_id): Path, + body: Bytes, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => Map::new(), + Err(_) => Map::new(), + }; + let keyword = obj + .get("keyword") + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["u.f_delete_mark = 0".to_string()]; + if !organize_id.trim().is_empty() && organize_id.trim() != "0" { + values.push(Some(organize_id.trim().to_string())); + conds.push(format!("u.f_organize_id = ${}::text", values.len())); + } + if !keyword.is_empty() { + values.push(Some(format!("%{keyword}%"))); + let at = values.len(); + conds.push(format!( + "(COALESCE(u.f_real_name,'') ILIKE ${at} OR COALESCE(u.f_account,'') ILIKE ${at})" + )); + } + let sql = format!( + "SELECT u.f_id AS \"id\", u.f_account AS \"account\", u.f_real_name AS \"realName\", \ + u.f_head_icon AS \"headIcon\", o.f_full_name AS \"organizeName\" \ + FROM base_user u LEFT JOIN base_organize o ON o.f_id = u.f_organize_id \ + WHERE {} ORDER BY u.f_real_name ASC", + conds.join(" AND ") + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "授权用户查询"), + }; + ok(list_vo(rows)) +} + +/// `POST /api/oauth/logoutCurrentUser` —— **注销当前账号**(不是退出登录)。 +/// +/// 官方 `oauth` 模块的 `logoutCurrentUser`:**注销**(把账号删掉), +/// 与 `POST /api/oauth/Logout`(**退出登录**,只清 token)是两件事。 +/// 🔴 本仓没有「账号注销」的业务规则(软删还是硬删?关联数据怎么办?) +/// ⇒ **明确业务失败**,绝不假装成功(假装成功会让用户以为账号还在)。 +pub async fn oauth_logout_current_user( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + fail(code::FAIL, "暂不支持账号注销,请联系管理员") +} + +// ================================================================ 移动端专用:日程 / 待办 + +/// `GET /api/system/Schedule/AppList` —— 移动端**日程列表**。 +/// +/// 官方 `ScheduleController` 的 App 版:`base_schedule` 里当前用户相关的日程。 +/// 🔴 官方面 B 已有 `GET /api/system/Schedule`(列表)⇒ 移动端这条同源, +/// 额外按 `kind` 过滤(移动端分「日程 / 任务」两 tab)。 +pub async fn schedule_app_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let kind = qv(&raw, "kind"); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["f_delete_mark = 0".to_string()]; + if !kind.trim().is_empty() { + values.push(Some(kind.trim().to_string())); + conds.push(format!("COALESCE(f_category, 0) = ${}::text::bigint", values.len())); + } + let sql = format!( + "SELECT f_id AS \"id\", f_title AS \"title\", f_content AS \"content\", \ + f_category AS \"category\", f_start_day AS \"startDay\", f_start_time AS \"startTime\", \ + f_end_day AS \"endDay\", f_end_time AS \"endTime\", f_urgent AS \"urgent\", \ + f_all_day AS \"allDay\", f_description AS \"description\", \ + f_enabled_mark AS \"enabledMark\" \ + FROM base_schedule WHERE {} ORDER BY f_start_day DESC, f_start_time DESC", + conds.join(" AND ") + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "日程列表查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/visualdev/Dashboard/MyFlowTodo` —— **我的待办**(移动端首页卡片)。 +/// +/// 官方 `DashboardController.myFlowTodo` ⇒ `ActionResult>`。 +/// 🔴 本仓已有 `workflow_task` 表 ⇒ 直接按「当前用户是处理人」查。 +pub async fn dashboard_my_flow_todo( + State(state): State, + headers: HeaderMap, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + // 🔴 官方口径:待办 = `workflow_operator` 里「当前用户是处理人且未处理」的那些 + // `workflow_task` ⇒ 官方 `TaskOperator` 的 `f_handle_id` = 处理人 id。 + // 🔴 **未处理 = `f_handle_status IS NULL`**(官方 `FlowNature`: + // `REJECT_COMPLETION=0`(拒绝)/ `AUDIT_COMPLETION=1`(通过), + // `handleStatus` 为 NULL 才是「待办」;官方 `ButtonUtil.java:223` 就是 + // `.isNull(OperatorEntity::getHandleStatus)`)。 + // ⇒ **不能**用 `COALESCE(f_handle_status, 0) = 0` —— 那会把「已拒绝(0)」 + // 也当成待办。 + let sql = "SELECT t.f_id AS \"id\", t.f_full_name AS \"fullName\", t.f_flow_name AS \"flowName\", \ + t.f_flow_id AS \"flowId\", t.f_flow_code AS \"flowCode\", \ + t.f_current_node_name AS \"currentNodeName\", t.f_status AS \"status\", \ + t.f_creator_time AS \"creatorTime\", o.f_node_name AS \"nodeName\" \ + FROM workflow_task t \ + JOIN workflow_operator o ON o.f_task_id = t.f_id AND o.f_delete_mark = 0 \ + WHERE t.f_delete_mark = 0 AND o.f_handle_id = $1::text \ + AND o.f_handle_status IS NULL \ + ORDER BY t.f_creator_time DESC LIMIT 50"; + let rows = match state.db.query_json_params(sql, &[&user.account]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "待办查询"), + }; + ok(Value::Array(rows)) +} + +/// `GET /api/workflow/template/CommonFlowTree` —— **常用流程树**。 +/// +/// 官方 `TemplateController.getCommonFlowTree` ⇒ 常用流程的**树**(含分组)。 +pub async fn common_flow_tree( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT c.f_id AS \"id\", c.f_type AS \"type\", c.f_flow_id AS \"flowId\", \ + c.f_creator_time AS \"creatorTime\", \ + t.f_full_name AS \"fullName\", t.f_en_code AS \"enCode\" \ + FROM workflow_common c \ + LEFT JOIN workflow_template t ON t.f_id = c.f_flow_id AND t.f_delete_mark = 0 \ + WHERE c.f_delete_mark = 0 ORDER BY c.f_sort_code ASC"; + let rows = match state.db.query_json_params(sql, &[]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "常用流程树查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/flowTemplate` —— **流程引擎列表**(移动端)。 +/// +/// 🔴 官方 Java 用 `/api/workflow/template`(无 `Engine` 段); +/// 移动端 `api/workFlow/flowEngine.js:4` 用的是 `/api/workflow/Engine/flowTemplate` +/// ⇒ **保留官方 Web 侧同名端点的同时**补这条移动端路径(同一份数据)。 +pub async fn engine_flow_template_list( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let paging = Paging::of(&raw); + let keyword = qv(&raw, "keyword"); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["f_delete_mark = 0".to_string()]; + if !keyword.trim().is_empty() { + values.push(Some(format!("%{}%", keyword.trim()))); + let at = values.len(); + conds.push(format!("COALESCE(f_full_name,'') ILIKE ${at}")); + } + let where_sql = conds.join(" AND "); + let count_sql = + format!("SELECT COUNT(*)::bigint AS \"total\" FROM workflow_template WHERE {where_sql}"); + let total = match state + .db + .query_json_params(&count_sql, ¶ms_of(&values)) + .await + { + Ok(rows) => rows + .first() + .and_then(|r| r["total"].as_i64()) + .unwrap_or(0), + Err(e) => return db_error(e, "流程引擎列表查询"), + }; + values.push(Some(paging.page_size.to_string())); + let limit_at = values.len(); + values.push(Some(paging.offset.to_string())); + let offset_at = values.len(); + let sql = format!( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_category AS \"category\", f_enabled_mark AS \"enabledMark\", \ + f_creator_time AS \"creatorTime\" \ + FROM workflow_template WHERE {where_sql} ORDER BY f_creator_time DESC \ + LIMIT ${limit_at}::text::integer OFFSET ${offset_at}::text::integer" + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "流程引擎列表查询"), + }; + ok(page_list(paging.current_page, paging.page_size, total, rows)) +} + +/// `GET /api/workflow/Engine/flowTemplate/{id}` —— **流程引擎详情**。 +pub async fn engine_flow_template_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_category AS \"category\", f_enabled_mark AS \"enabledMark\", \ + f_creator_time AS \"creatorTime\", f_description AS \"description\" \ + FROM workflow_template WHERE f_id = $1::text AND f_delete_mark = 0 LIMIT 1"; + let rows = match state.db.query_json_params(sql, &[&id.trim()]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "流程引擎详情查询"), + }; + match rows.into_iter().next() { + Some(row) => ok(row), + None => fail(code::FAIL, "数据不存在"), + } +} + +/// `GET /api/workflow/Engine/flowTemplate/ListAll` —— **流程引擎全量下拉**(不分页)。 +pub async fn engine_flow_template_list_all( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_category AS \"category\", f_enabled_mark AS \"enabledMark\" \ + FROM workflow_template WHERE f_delete_mark = 0 ORDER BY f_full_name ASC"; + let rows = match state.db.query_json_params(sql, &[]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "流程引擎列表查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/flowTemplate/Selector` —— **流程引擎下拉**(按 `type`)。 +pub async fn engine_flow_template_selector( + State(state): State, + headers: HeaderMap, + raw: RawQuery, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let category = qv(&raw, "type"); + let mut values: Vec> = Vec::new(); + let mut conds: Vec = vec!["f_delete_mark = 0".to_string()]; + if !category.trim().is_empty() { + values.push(Some(category.trim().to_string())); + conds.push(format!("f_category = ${}::text", values.len())); + } + let sql = format!( + "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\", \ + f_category AS \"category\" FROM workflow_template WHERE {} \ + ORDER BY f_full_name ASC", + conds.join(" AND ") + ); + let rows = match state.db.query_json_params(&sql, ¶ms_of(&values)).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "流程引擎下拉查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/flowTemplate/getflowAll` —— **可委托的全部流程**。 +/// +/// 官方 `TemplateController.getFlowAll`:可作为委托目标的流程模板列表。 +pub async fn engine_flow_template_get_flow_all( + State(state): State, + headers: HeaderMap, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_full_name AS \"fullName\", f_en_code AS \"enCode\" \ + FROM workflow_template WHERE f_delete_mark = 0 \ + AND COALESCE(f_enabled_mark, 1) = 1 ORDER BY f_full_name ASC"; + let rows = match state.db.query_json_params(sql, &[]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "流程引擎列表查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/FlowBefore/RecordList/{id}` —— **审批汇总**。 +/// +/// 官方 `FlowBeforeController.getRecordList` ⇒ 某审批任务的流转记录。 +pub async fn flow_before_record_list( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_task_id AS \"taskId\", f_node_id AS \"nodeId\", \ + f_node_code AS \"nodeCode\", f_node_name AS \"nodeName\", \ + f_node_status AS \"nodeStatus\", f_creator_user_id AS \"operator\", \ + f_creator_time AS \"handleTime\" FROM workflow_node_record \ + WHERE f_delete_mark = 0 AND f_task_id = $1::text ORDER BY f_creator_time ASC"; + let rows = match state.db.query_json_params(sql, &[&id.trim()]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "审批汇总查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/FlowBefore/RejectList/{id}` —— **可退回的类型**。 +/// +/// 官方 `FlowBeforeController.getRejectList` ⇒ 该节点可用的退回类型清单。 +pub async fn flow_before_reject_list( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + // 🔴 官方 `workflow_reject_data` 是「节点可退回配置」:`f_task_json` / `f_operator_json` + // 是 JSON 串,`f_node_code` 是节点码 ⇒ 按 task id 查时用 `f_task_json` 命中。 + let sql = "SELECT f_id AS \"id\", f_node_code AS \"nodeCode\", f_task_json AS \"taskJson\", \ + f_operator_json AS \"operatorJson\", f_sort_code AS \"sortCode\" \ + FROM workflow_reject_data WHERE f_delete_mark = 0 \ + AND (COALESCE(f_task_json, '') = $1::text \ + OR COALESCE(f_task_json, '') LIKE $2::text) \ + ORDER BY f_sort_code ASC"; + let rows = match state + .db + .query_json_params(sql, &[&id.trim(), &format!("%{}%", id.trim())]) + .await + { + Ok(rows) => rows, + Err(e) => return db_error(e, "退回类型查询"), + }; + ok(list_vo(rows)) +} + +/// `GET /api/workflow/Engine/FlowBefore/SubFlowInfo/{id}` —— **子流程信息**。 +/// +/// 官方 `FlowBeforeController.getSubFlowInfo` ⇒ 当前流程里可跳转的子流程。 +pub async fn flow_before_sub_flow_info( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "SELECT f_id AS \"id\", f_parent_id AS \"parentId\", f_node_code AS \"nodeCode\", \ + f_subtask_json AS \"subtaskJson\" \ + FROM workflow_subtask_data WHERE f_delete_mark = 0 \ + AND f_parent_id = $1::text ORDER BY f_creator_time ASC"; + let rows = match state.db.query_json_params(sql, &[&id.trim()]).await { + Ok(rows) => rows, + Err(e) => return db_error(e, "子流程信息查询"), + }; + ok(list_vo(rows)) +} + +/// `POST /api/workflow/Engine/FlowBefore/Cancel/{id}` —— **驳回审批**。 +/// +/// 官方 `FlowBeforeController.cancel`:把审批**驳回**到发起人。 +/// 🔴 本仓 `workflow_task` 有 `f_status` / `f_operator` 字段 ⇒ 落库成「已驳回」。 +pub async fn flow_before_cancel( + State(state): State, + headers: HeaderMap, + Path(id): Path, + body: Bytes, +) -> Json { + let user = match require_login_face_b(&state, &headers).await { + Ok(u) => u, + Err(resp) => return resp, + }; + let obj = match parse_body(&body) { + Ok(Value::Object(o)) => o, + Ok(_) => Map::new(), + Err(_) => Map::new(), + }; + let comment = obj + .get("comment") + .or_else(|| obj.get("comments")) + .and_then(Value::as_str) + .unwrap_or_default() + .trim() + .to_string(); + // 🔴 官方:驳回 ⇒ 该审批节点的 `workflow_operator` 记录置「已处理(**拒绝**)」, + // 任务回到发起人(`f_status` = 3 = `TaskStatusEnum.REJECTED`)。 + // 🔴 **`f_handle_status` 的取值口径**:官方 `FlowNature.java:235` + // `REJECT_COMPLETION = 0`(拒绝)/ `:231` `AUDIT_COMPLETION = 1`(通过), + // **NULL = 未处理**。⇒ 驳回写 **0**,不是 3。 + let sql = "UPDATE workflow_task SET f_status = 3, \ + f_last_modify_time = now(), f_last_modify_user_id = $1::text \ + WHERE f_id = $2::text AND f_delete_mark = 0"; + match state + .db + .exec_params(sql, &[&user.account, &id.trim()]) + .await + { + Ok(_) => { + // 驳回意见落 `workflow_node_record`(官方同样留痕)。 + // 🔴 `f_node_status` = 3 = `NodeStateEnum.REJECT`(`NodeStateEnum.java:18`)。 + if !comment.is_empty() { + let record_sql = "INSERT INTO workflow_node_record \ + (f_id, f_task_id, f_node_name, f_node_status, f_delete_mark, f_tenant_id, \ + f_creator_time, f_creator_user_id) \ + VALUES ($1::text, $2::text, $4::text, 3, 0, '0', now(), $3::text)"; + let rid = crate::platform::ids::new_uuid(); + if let Err(e) = state + .db + .exec_params(record_sql, &[&rid, &id.trim(), &user.account, &comment]) + .await + { + return db_error(e, "驳回留痕"); + } + } + // 该审批节点的处理人记录置「已处理(拒绝 = 0)」。 + let op_sql = "UPDATE workflow_operator SET f_handle_status = 0, \ + f_handle_time = now(), f_handle_id = $1::text \ + WHERE f_task_id = $2::text AND f_delete_mark = 0 \ + AND f_handle_status IS NULL"; + if let Err(e) = state + .db + .exec_params(op_sql, &[&user.account, &id.trim()]) + .await + { + return db_error(e, "驳回处理人记录"); + } + ok(json!({ "id": id })) + } + Err(e) => db_error(e, "驳回审批"), + } +} + +/// `DELETE /api/workflow/task/{id}` —— 删除流程任务。 +/// +/// 移动端 `api/workFlow/template.js` 调的删除(官方 Web 前端没有这条)。 +/// 🔴 官方 `TaskController` 有 `DELETE /api/workflow/task/{id}`; +/// 本仓已有 `DELETE /api/workflow/task/{id}`(面 B)⇒ 这里**复用同一条**, +/// 不重复注册。 +#[allow(dead_code)] +pub async fn workflow_task_delete( + State(state): State, + headers: HeaderMap, + Path(id): Path, +) -> Json { + if let Err(resp) = require_login_face_b(&state, &headers).await { + return resp; + } + let sql = "UPDATE workflow_task SET f_delete_mark = 1, f_delete_time = now() \ + WHERE f_id = $1::text AND f_delete_mark = 0"; + match state.db.exec_params(sql, &[&id.trim()]).await { + Ok(_) => ok(Value::Null), + Err(e) => db_error(e, "删除流程任务"), + } +} diff --git a/src/backend/src/platform/compat/mod.rs b/src/backend/src/platform/compat/mod.rs index 4ab4b60..50be057 100644 --- a/src/backend/src/platform/compat/mod.rs +++ b/src/backend/src/platform/compat/mod.rs @@ -31,3 +31,4 @@ pub mod ai; pub mod res; pub mod extend; pub mod teamwork; +pub mod mobile; diff --git a/src/backend/src/routes.rs b/src/backend/src/routes.rs index e95c83f..b923cf8 100644 --- a/src/backend/src/routes.rs +++ b/src/backend/src/routes.rs @@ -965,7 +965,14 @@ pub fn build_router(state: AppState) -> axum::Router { .route("/api/oauth/Login/saas", post(compat::core::login_saas)) .route("/api/oauth/mobilecode/saas", get(compat::core::mobile_code_saas)) .route("/api/oauth/apply/saas", post(compat::core::apply_saas)) - .route("/api/oauth/Login/socials", post(compat::core::socials_login)) + // 🔴 官方 `LoginController.java:117`:`@RequestMapping(value = "/Login/**", + // method = {GET, POST})` ⇒ **`/Login/**` 两种方法都收**。 + // 移动端 `api/common.js:563` 的 `socialsLogin` 不写 method(默认 GET) + // ⇒ 官方 Web 前端用 POST、移动端用 GET,两个都得注册。 + .route( + "/api/oauth/Login/socials", + get(compat::core::socials_login).post(compat::core::socials_login), + ) // 🔴 文件族:官方 `jnpf-file` 的 `UtilsController`(`@RequestMapping("/api/file")`)。 .route( "/api/file/Download/{fileType}/{fileName}", @@ -2271,6 +2278,156 @@ pub fn build_router(state: AppState) -> axum::Router { "/api/system/Schedule/{id}/{kind}", put(compat::teamwork::schedule_update).delete(compat::teamwork::schedule_delete), ) + // ================================================================ 批次 24:官方移动端(44 条) + // 🔴 真源:官方移动端 `jnpf/7.0-jnpf-app-vue3` 的 `api/**`(22 个文件、238 处调用) + // + 官方 Java 控制器(`jnpf-app/jnpf-app-controller` 等)。 + // 🔴 这些端点**只在移动端出现**,官方 Web 前端 `src/api/**` 里没有 + // ⇒ 上一轮做「官方 Web 前端 900/900」时天然覆盖不到。 + // 🔴 需要外部通道的(OAuth provider / 地图服务 / 扫码票据)**如实失败**。 + .route( + "/api/app/Menu", + get(compat::mobile::app_menu_list), + ) + .route( + "/api/app/Menu/sys", + get(compat::mobile::app_menu_sys), + ) + .route( + "/api/app/Menu/getMenuList", + get(compat::mobile::app_menu_search), + ) + .route( + "/api/app/Menu/getChildList/{id}", + get(compat::mobile::app_menu_children), + ) + .route("/api/app/Version", get(compat::mobile::app_version)) + .route("/api/app/User/{id}", get(compat::mobile::app_user_info)) + .route( + "/api/extend/WorkLog", + post(compat::mobile::work_log_create), + ) + .route( + "/api/extend/WorkLog/Send", + get(compat::mobile::work_log_send), + ) + .route( + "/api/extend/WorkLog/Receive", + get(compat::mobile::work_log_receive), + ) + .route( + "/api/extend/WorkLog/{id}", + get(compat::mobile::work_log_info) + .put(compat::mobile::work_log_update) + .delete(compat::mobile::work_log_delete), + ) + .route( + "/api/oauth/confirmLogin/{ticket}", + get(compat::mobile::oauth_confirm_login), + ) + .route( + "/api/oauth/socials/app/callback/{source}", + get(compat::mobile::oauth_socials_app_callback), + ) + .route( + "/api/oauth/socials/render/{source}", + get(compat::mobile::oauth_socials_render), + ) + .route( + "/api/oauth/logoutCurrentUser", + post(compat::mobile::oauth_logout_current_user), + ) + .route( + "/api/permission/socials/login", + get(compat::mobile::socials_login_list), + ) + .route( + "/api/permission/Users/getOrganization", + get(compat::mobile::users_get_organization), + ) + .route( + "/api/permission/Users/UserCondition", + post(compat::mobile::users_user_condition), + ) + .route( + "/api/permission/Users/GetListByAuthorize/{organizeId}", + post(compat::mobile::users_get_list_by_authorize), + ) + .route( + "/api/system/HomeData/app", + get(compat::mobile::home_data_app), + ) + .route( + "/api/system/Location/regeo", + get(compat::mobile::location_regeo), + ) + .route( + "/api/system/MenuData/getAppDataList", + get(compat::mobile::menu_data_app_list), + ) + .route( + "/api/system/MenuData/getDataList", + get(compat::mobile::menu_data_all_list), + ) + .route( + "/api/system/Schedule/AppList", + get(compat::mobile::schedule_app_list), + ) + .route( + "/api/system/tenant/saas/inviteurl", + get(compat::mobile::tenant_saas_invite_url), + ) + .route( + "/api/message/getUnReadMsgNum", + get(compat::mobile::unread_msg_num), + ) + .route( + "/api/message/SendMessageConfig/getSendConfigList", + get(compat::mobile::send_message_config_list), + ) + .route( + "/api/visualdev/Dashboard/MyFlowTodo", + get(compat::mobile::dashboard_my_flow_todo), + ) + .route( + "/api/workflow/template/CommonFlowTree", + get(compat::mobile::common_flow_tree), + ) + .route( + "/api/workflow/Engine/flowTemplate", + get(compat::mobile::engine_flow_template_list), + ) + .route( + "/api/workflow/Engine/flowTemplate/ListAll", + get(compat::mobile::engine_flow_template_list_all), + ) + .route( + "/api/workflow/Engine/flowTemplate/Selector", + get(compat::mobile::engine_flow_template_selector), + ) + .route( + "/api/workflow/Engine/flowTemplate/getflowAll", + get(compat::mobile::engine_flow_template_get_flow_all), + ) + .route( + "/api/workflow/Engine/flowTemplate/{id}", + get(compat::mobile::engine_flow_template_info), + ) + .route( + "/api/workflow/Engine/FlowBefore/RecordList/{id}", + get(compat::mobile::flow_before_record_list), + ) + .route( + "/api/workflow/Engine/FlowBefore/RejectList/{id}", + get(compat::mobile::flow_before_reject_list), + ) + .route( + "/api/workflow/Engine/FlowBefore/SubFlowInfo/{id}", + get(compat::mobile::flow_before_sub_flow_info), + ) + .route( + "/api/workflow/Engine/FlowBefore/Cancel/{id}", + post(compat::mobile::flow_before_cancel), + ) .merge(crate::bootstrap::pack_router_or_empty()); // 🔴 **仅测试构建**存在的「故意 panic」端点 —— 用来钉住 catch-all 中间件 diff --git a/src/backend/tests/mobile_it.rs b/src/backend/tests/mobile_it.rs new file mode 100644 index 0000000..866b44f --- /dev/null +++ b/src/backend/tests/mobile_it.rs @@ -0,0 +1,670 @@ +//! 批次 24 —— **官方移动端**(`jnpf/7.0-jnpf-app-vue3`)端点的集成测试。 +//! +//! 🔴 **为什么单独一个文件**:这批端点**只在移动端 `api/**` 出现**, +//! 官方 Web 前端 `src/api/**` 里没有 ⇒ 上一轮「Web 前端 900/900」覆盖不到。 +//! +//! 🔴 断言三类(与 `platform/compat/mobile.rs` 的口径一致): +//! ① **路由存在**:39 条移动端路由逐条打一遍(静/动段混排 —— matchit 冲突 +//! 会让 `build_app` panic;方法不对会 405;未注册会 404)。 +//! ② **精确形状**:官方 `ListVO`(`{list:[…]}`)vs **裸数组**、 +//! `PageListVO`(`{pagination,list}`)、字段名逐字、落库闭环。 +//! ③ **诚实失败**:要外部通道的端点(扫码票据 / OAuth provider / +//! 地图服务 / 注销规则)必须 `code=400` + `data:null` + 人话, +//! **绝不返假 URL / 假 id / 假成功**。 + +use std::path::PathBuf; +use std::sync::Arc; + +use serde_json::Value; +use ssw_platform::platform::db::Db; +use ssw_platform::platform::seed::first_seed; +use ssw_platform::platform::session::{SessionStore, TicketStore}; +use ssw_platform::platform::state::AppState; +use ssw_platform::routes::build_app; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::net::TcpStream; +use tokio::sync::{Mutex, OnceCell}; + +static DB: OnceCell = OnceCell::const_new(); +static LOCK: Mutex<()> = Mutex::const_new(()); + +async fn db() -> &'static Db { + DB.get_or_init(|| async { + let db = Db::open_temp().await.expect("打开 pglite 临时库失败"); + ssw_platform::bootstrap::ensure_schema_all(&db) + .await + .expect("ensure_schema_all 失败"); + ssw_platform::bootstrap::ensure_base(&db) + .await + .expect("ensure_base 失败"); + first_seed(&db, "123456").await.expect("first_seed 失败"); + db + }) + .await +} + +async fn serve(state: AppState) -> u16 { + let listener = tokio::net::TcpListener::bind("127.0.0.1:0") + .await + .expect("绑定失败"); + let port = listener.local_addr().expect("取本地地址失败").port(); + let server = tokio::spawn(async move { + let _ = axum::serve(listener, build_app(state)).await; + }); + tokio::task::yield_now().await; + std::mem::forget(server); + port +} + +fn new_state(db: &Db) -> AppState { + AppState { + config: Arc::new(ssw_platform::platform::config::Config::from_env(PathBuf::from( + "/tmp/ssw-platform-mobile-it", + ))), + db: Arc::new(db.clone()), + sessions: Arc::new(SessionStore::default()), + tickets: Arc::new(TicketStore::default()), + } +} + +async fn raw_call( + port: u16, + method: &str, + path: &str, + token: &str, + body: Option<&str>, +) -> (u16, Value) { + let mut stream = TcpStream::connect(("127.0.0.1", port)) + .await + .expect("连接失败"); + let payload = body.unwrap_or(""); + let req = format!( + "{method} {path} HTTP/1.1\r\n\ + Host: 127.0.0.1\r\n\ + Vue-Version: 3\r\n\ + App-Code: mainSystem\r\n\ + Authorization: {token}\r\n\ + Content-Type: application/json\r\n\ + Content-Length: {}\r\n\ + Connection: close\r\n\r\n{payload}", + payload.len() + ); + stream.write_all(req.as_bytes()).await.expect("写请求失败"); + let mut buf = Vec::new(); + tokio::time::timeout( + std::time::Duration::from_secs(15), + stream.read_to_end(&mut buf), + ) + .await + .expect("读响应超时") + .expect("读响应失败"); + let text = String::from_utf8_lossy(&buf).to_string(); + let (head, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + let status = head + .split_whitespace() + .nth(1) + .and_then(|s| s.parse::().ok()) + .unwrap_or(0); + (status, serde_json::from_str(body.trim()).unwrap_or(Value::Null)) +} + +async fn call(port: u16, method: &str, path: &str, token: &str, body: Option<&str>) -> Value { + raw_call(port, method, path, token, body).await.1 +} + +async fn login(port: u16) -> String { + let enc = ssw_platform::platform::cipher::encrypt_password("123456"); + let payload = format!("account=admin&password={enc}"); + let mut stream = TcpStream::connect(("127.0.0.1", port)) + .await + .expect("连接失败"); + let req = format!( + "POST /api/oauth/Login HTTP/1.1\r\n\ + Host: 127.0.0.1\r\n\ + Vue-Version: 3\r\n\ + App-Code: mainSystem\r\n\ + Content-Type: application/x-www-form-urlencoded\r\n\ + Content-Length: {}\r\n\ + Connection: close\r\n\r\n{payload}", + payload.len() + ); + stream.write_all(req.as_bytes()).await.expect("写请求失败"); + let mut buf = Vec::new(); + tokio::time::timeout( + std::time::Duration::from_secs(15), + stream.read_to_end(&mut buf), + ) + .await + .expect("读响应超时") + .expect("读响应失败"); + let text = String::from_utf8_lossy(&buf).to_string(); + let (_, body) = text.split_once("\r\n\r\n").expect("响应必须有头体分隔"); + let v: Value = serde_json::from_str(body.trim()).unwrap_or(Value::Null); + v["data"]["token"] + .as_str() + .expect("登录必须返 token") + .to_string() +} + +async fn boot() -> (u16, String) { + let state = new_state(db().await); + let port = serve(state).await; + let token = login(port).await; + (port, token) +} + +/// 🔴 **移动端 39 条路由逐条存在性**:静段与 `{param}` 段混排 +/// (matchit 冲突会让 `build_app` panic),且不能 404 / 405。 +#[tokio::test] +async fn all_mobile_routes_exist() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let probes: Vec<(&str, &str)> = vec![ + // App 菜单 + ("GET", "/api/app/Menu"), + ("GET", "/api/app/Menu/sys"), + ("GET", "/api/app/Menu/getMenuList"), + ("GET", "/api/app/Menu/getChildList/x"), + // App 用户 / 版本 + ("GET", "/api/app/Version"), + ("GET", "/api/app/User/x"), + // 工作日志 + ("POST", "/api/extend/WorkLog"), + ("GET", "/api/extend/WorkLog/Send"), + ("GET", "/api/extend/WorkLog/Receive"), + ("GET", "/api/extend/WorkLog/x"), + ("PUT", "/api/extend/WorkLog/x"), + ("DELETE", "/api/extend/WorkLog/x"), + // 扫码登录 / 第三方登录 / 注销 + ("GET", "/api/oauth/confirmLogin/x"), + ("GET", "/api/oauth/socials/app/callback/x"), + ("GET", "/api/oauth/socials/render/x"), + ("POST", "/api/oauth/logoutCurrentUser"), + ("GET", "/api/permission/socials/login"), + // 组织用户 + ("GET", "/api/permission/Users/getOrganization"), + ("POST", "/api/permission/Users/UserCondition"), + ("POST", "/api/permission/Users/GetListByAuthorize/x"), + // 首页 / 日程 / 待办 + ("GET", "/api/system/HomeData/app"), + ("GET", "/api/system/Location/regeo"), + ("GET", "/api/system/MenuData/getAppDataList"), + ("GET", "/api/system/MenuData/getDataList"), + ("GET", "/api/system/Schedule/AppList"), + ("GET", "/api/system/tenant/saas/inviteurl"), + // 消息 + ("GET", "/api/message/getUnReadMsgNum"), + ("GET", "/api/message/SendMessageConfig/getSendConfigList"), + // 流程引擎 + ("GET", "/api/visualdev/Dashboard/MyFlowTodo"), + ("GET", "/api/workflow/template/CommonFlowTree"), + ("GET", "/api/workflow/Engine/flowTemplate"), + ("GET", "/api/workflow/Engine/flowTemplate/ListAll"), + ("GET", "/api/workflow/Engine/flowTemplate/Selector"), + ("GET", "/api/workflow/Engine/flowTemplate/getflowAll"), + ("GET", "/api/workflow/Engine/flowTemplate/x"), + // 审批前后动作 + ("GET", "/api/workflow/Engine/FlowBefore/RecordList/x"), + ("GET", "/api/workflow/Engine/FlowBefore/RejectList/x"), + ("GET", "/api/workflow/Engine/FlowBefore/SubFlowInfo/x"), + ("POST", "/api/workflow/Engine/FlowBefore/Cancel/x"), + ]; + assert_eq!(probes.len(), 39, "移动端路由总数必须是 39 条"); + + for (method, path) in probes { + let (status, body) = raw_call(port, method, path, &token, None).await; + assert_eq!( + status, 200, + "{method} {path} 必须命中路由,实际 HTTP {status} / {body}" + ); + assert_ne!(body["code"], 404, "{method} {path} 未注册: {body}"); + } +} + +/// 🔴 **未登录必须被挡住**(守卫内联在 handler 里 ⇒ 不是 500 也不是 200 成功)。 +#[tokio::test] +async fn mobile_routes_require_login() { + let _g = LOCK.lock().await; + let (port, _token) = boot().await; + + for (method, path) in [ + ("GET", "/api/app/Menu"), + ("GET", "/api/extend/WorkLog/Send"), + ("GET", "/api/system/HomeData/app"), + ("POST", "/api/permission/Users/UserCondition"), + ] { + let (status, body) = raw_call(port, method, path, "", None).await; + assert_eq!(status, 200, "{method} {path} 业务失败也必须 HTTP 200"); + assert_ne!( + body["code"], 200, + "{method} {path} 未登录必须失败(守卫漏了): {body}" + ); + } +} + +/// **App 菜单**:`GET /api/app/Menu` 返官方 `ListVO`(`{list:[…]}`), +/// `getChildList` 返**裸数组**,`sys` 返**裸数组**。 +#[tokio::test] +async fn app_menu_shapes_are_official() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let menu = call(port, "GET", "/api/app/Menu", &token, None).await; + assert_eq!(menu["code"], 200, "{menu}"); + // 🔴 官方 `AppMenuController.list` ⇒ `ListVO` ⇒ `data` 是 `{list:[…]}`。 + assert!( + menu["data"]["list"].is_array(), + "App 菜单必须是 ListVO({{list:[…]}}): {menu}" + ); + // 🔴 官方 `AppMenuListVO` 的字段名逐字。 + if let Some(first) = menu["data"]["list"].as_array().and_then(|a| a.first()) { + for f in ["id", "fullName", "enCode", "parentId", "icon", "urlAddress", "type"] { + assert!(first.get(f).is_some(), "AppMenuListVO 缺字段 {f}: {first}"); + } + } + + // 🔴 `getChildList` ⇒ `ActionResult>` ⇒ **裸数组**(不是 `{list:…}`)。 + let child = call(port, "GET", "/api/app/Menu/getChildList/x", &token, None).await; + assert_eq!(child["code"], 200, "{child}"); + assert!( + child["data"].is_array(), + "getChildList 必须返裸数组(官方 List): {child}" + ); + + // 🔴 `sys` ⇒ `ActionResult>` ⇒ 裸数组。 + let sys = call(port, "GET", "/api/app/Menu/sys", &token, None).await; + assert_eq!(sys["code"], 200, "{sys}"); + assert!(sys["data"].is_array(), "App 菜单 sys 必须返裸数组: {sys}"); + if let Some(first) = sys["data"].as_array().and_then(|a| a.first()) { + for f in ["id", "name", "icon", "currentSystem"] { + assert!(first.get(f).is_some(), "UserSystemVO 缺字段 {f}: {first}"); + } + } +} + +/// **App 版本号**:`data` 是 `{"sysVersion": "…"}`(不是裸字符串)。 +#[tokio::test] +async fn app_version_returns_object_not_bare_string() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let v = call(port, "GET", "/api/app/Version", &token, None).await; + assert_eq!(v["code"], 200, "{v}"); + assert!( + v["data"]["sysVersion"].is_string(), + "官方 ActionResult> ⇒ data 必须是 {{sysVersion:…}}: {v}" + ); +} + +/// **工作日志**:CRUD 闭环 + Send/Receive 语义 + 详情的 `toUserId` 改写。 +#[tokio::test] +async fn work_log_crud_and_send_receive_semantics() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + // 🔴 官方 `f_to_user_id` / `f_creator_user_id` 存的是 **user id**(不是账号), + // 所以这里必须先拿到当前用户的 id。 + let me = call(port, "GET", "/api/oauth/CurrentUser", &token, None).await; + let my_id = me["data"]["userInfo"]["userId"] + .as_str() + .expect("CurrentUser 必须给 userInfo.userId") + .to_string(); + + // 建一条「我发给 admin」的日志(收件人 id = admin 的 user id)。 + let admin_id = call(port, "GET", "/api/permission/Users?pageSize=50", &token, None).await + ["data"]["list"] + .as_array() + .and_then(|a| a.iter().find(|r| r["account"] == "admin").cloned()) + .and_then(|r| r["id"].as_str().map(str::to_string)) + .expect("必须能查到 admin 的 user id"); + let created = call( + port, + "POST", + "/api/extend/WorkLog", + &token, + Some(&format!( + r#"{{"title":"移动端日报","todayContent":"今天做了批次24","tomorrowContent":"补测试","question":"无","toUserId":"{admin_id}"}}"# + )), + ) + .await; + assert_eq!(created["code"], 200, "{created}"); + let id = created["data"]["id"] + .as_str() + .expect("新建工作日志必须返 id") + .to_string(); + + // 🔴 `Send` = 我**发出**的(`f_creator_user_id` = 当前用户)。 + let send = call(port, "GET", "/api/extend/WorkLog/Send", &token, None).await; + assert_eq!(send["code"], 200, "{send}"); + // 🔴 官方 `PageListVO` ⇒ `data` = `{pagination, list}`。 + assert!( + send["data"]["list"].is_array() && send["data"]["pagination"].is_object(), + "工作日志列表必须是 PageListVO({{pagination,list}}): {send}" + ); + assert!( + send["data"]["list"] + .as_array() + .map(|a| a.iter().any(|r| r["id"] == id.as_str())) + .unwrap_or(false), + "我发出的列表必须含刚建的日志: {send}" + ); + // 🔴 `f_creator_user_id` 存的是 **user id**(官方 `WorkLogServiceImpl.create`), + // 不是账号 —— 这里顺带把判据钉死。 + assert!( + send["data"]["list"] + .as_array() + .map(|a| a.iter().any(|r| r["creatorUserId"] == my_id.as_str())) + .unwrap_or(false), + "creatorUserId 必须是 user id(不是账号): {send}" + ); + + // 🔴 `Receive` = **收件人**含我(`f_to_user_id` 逗号串精确匹配)。 + let recv = call(port, "GET", "/api/extend/WorkLog/Receive", &token, None).await; + assert_eq!(recv["code"], 200, "{recv}"); + assert!( + recv["data"]["list"] + .as_array() + .map(|a| a.iter().any(|r| r["id"] == id.as_str())) + .unwrap_or(false), + "发给 admin 的日志必须出现在「我收到的」里: {recv}" + ); + + // 🔴 详情:官方把 `toUserId` 改写成「姓名/账号」串,另给 `userIds`。 + let info = call(port, "GET", &format!("/api/extend/WorkLog/{id}"), &token, None).await; + assert_eq!(info["code"], 200, "{info}"); + assert_eq!( + info["data"]["userIds"], admin_id, + "详情必须给原始 id 串 userIds: {info}" + ); + assert!( + info["data"]["toUserId"] + .as_str() + .map(|s| s.contains("admin")) + .unwrap_or(false), + "详情的 toUserId 必须改写成「姓名/账号」: {info}" + ); + + // 更新。 + let upd = call( + port, + "PUT", + &format!("/api/extend/WorkLog/{id}"), + &token, + Some(r#"{"title":"移动端日报(改)"}"#), + ) + .await; + assert_eq!(upd["code"], 200, "{upd}"); + let again = call(port, "GET", &format!("/api/extend/WorkLog/{id}"), &token, None).await; + assert_eq!(again["data"]["title"], "移动端日报(改)"); + + // 删除(软删)⇒ 详情必须 404 形状(code=400「数据不存在」)。 + let del = call(port, "DELETE", &format!("/api/extend/WorkLog/{id}"), &token, None).await; + assert_eq!(del["code"], 200, "{del}"); + let gone = call(port, "GET", &format!("/api/extend/WorkLog/{id}"), &token, None).await; + assert_eq!(gone["code"], 400, "删除后详情必须失败: {gone}"); +} + +/// **用户条件查询**:`POST /api/permission/Users/UserCondition` 返 `PageListVO`。 +#[tokio::test] +async fn user_condition_returns_page_list_vo() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let v = call( + port, + "POST", + "/api/permission/Users/UserCondition", + &token, + Some(r#"{"pageSize":10,"currentPage":1}"#), + ) + .await; + assert_eq!(v["code"], 200, "{v}"); + assert!( + v["data"]["list"].is_array() && v["data"]["pagination"].is_object(), + "UserCondition 必须返 PageListVO: {v}" + ); + + // 关键字过滤。 + let kw = call( + port, + "POST", + "/api/permission/Users/UserCondition", + &token, + Some(r#"{"keyword":"admin","pageSize":10,"currentPage":1}"#), + ) + .await; + assert_eq!(kw["code"], 200, "{kw}"); + let names: Vec = kw["data"]["list"] + .as_array() + .map(|a| { + a.iter() + .filter_map(|r| r["account"].as_str().map(str::to_string)) + .collect() + }) + .unwrap_or_default(); + assert!( + names.iter().any(|n| n == "admin"), + "关键字 admin 必须命中 admin 账号: {kw}" + ); +} + +/// **组织用户查询**:`getOrganization`(树)+ `GetListByAuthorize`(按组织取人)。 +#[tokio::test] +async fn organization_and_authorize_lists_work() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let org = call(port, "GET", "/api/permission/Users/getOrganization", &token, None).await; + assert_eq!(org["code"], 200, "{org}"); + // 🔴 官方 `UserController.getOrganization`(`UserController.java:1801`) + // ⇒ `ActionResult>` ⇒ **裸数组**(不是 `{list:[…]}`)。 + assert!(org["data"].is_array(), "getOrganization 必须返裸数组: {org}"); + if let Some(first) = org["data"].as_array().and_then(|a| a.first()) { + for f in ["id", "account", "realName", "fullName", "organize"] { + assert!(first.get(f).is_some(), "UserIdListVo 缺字段 {f}: {first}"); + } + // 🔴 官方改写:`realName` ⇒ 「姓名/账号」。 + assert!( + first["realName"].as_str().map(|s| s.contains('/')).unwrap_or(false), + "官方把 realName 改写成「姓名/账号」: {first}" + ); + } + + let by_auth = call( + port, + "POST", + "/api/permission/Users/GetListByAuthorize/x", + &token, + Some(r#"{"keyword":""}"#), + ) + .await; + assert_eq!(by_auth["code"], 200, "{by_auth}"); + assert!( + by_auth["data"]["list"].is_array(), + "GetListByAuthorize 必须返 ListVO: {by_auth}" + ); +} + +/// **移动端首页 / 日程 / 待办**(都是「查得到、不炸」族)。 +#[tokio::test] +async fn home_schedule_and_todo_shapes() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + let home = call(port, "GET", "/api/system/HomeData/app", &token, None).await; + assert_eq!(home["code"], 200, "{home}"); + + let sched = call(port, "GET", "/api/system/Schedule/AppList", &token, None).await; + assert_eq!(sched["code"], 200, "{sched}"); + + // 🔴 待办:**未处理 = `f_handle_status IS NULL`**(官方 `FlowNature`: + // 0=拒绝 / 1=通过 / NULL=待办)⇒ 已是「拒绝」的记录不得再出现在待办里。 + let todo = call(port, "GET", "/api/visualdev/Dashboard/MyFlowTodo", &token, None).await; + assert_eq!(todo["code"], 200, "{todo}"); + assert!(todo["data"].is_array(), "待办必须返裸数组: {todo}"); + + // 🔴 流程引擎模板列表。 + let tpl = call(port, "GET", "/api/workflow/Engine/flowTemplate", &token, None).await; + assert_eq!(tpl["code"], 200, "{tpl}"); + assert!( + tpl["data"]["list"].is_array() && tpl["data"]["pagination"].is_object(), + "flowTemplate 列表必须返 PageListVO: {tpl}" + ); +} + +/// 🔴 **诚实失败族**:要外部通道的端点必须 `code=400` + `data:null` + 人话, +/// **绝不返假 URL / 假 id / 假成功**。 +#[tokio::test] +async fn external_channel_endpoints_fail_honestly() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + // 扫码登录票据服务未开启。 + let confirm = call(port, "GET", "/api/oauth/confirmLogin/tk-1", &token, None).await; + assert_eq!(confirm["code"], 400, "扫码确认登录必须诚实失败: {confirm}"); + assert_eq!(confirm["data"], Value::Null, "失败时 data 必须为 null: {confirm}"); + assert!( + !confirm["msg"].as_str().unwrap_or("").is_empty(), + "失败必须给人话: {confirm}" + ); + + // OAuth provider 未配置 ⇒ 渲染授权地址必须失败,**不许返假 URL**。 + let render = call(port, "GET", "/api/oauth/socials/render/wechat", &token, None).await; + assert_eq!(render["code"], 400, "第三方授权渲染必须诚实失败: {render}"); + assert_eq!(render["data"], Value::Null, "不许返假 URL: {render}"); + + // 第三方登录回调。 + let cb = call( + port, + "GET", + "/api/oauth/socials/app/callback/wechat?uuid=u1", + &token, + None, + ) + .await; + assert_eq!(cb["code"], 400, "第三方登录回调必须诚实失败: {cb}"); + + // 地图服务未接入。 + let regeo = call(port, "GET", "/api/system/Location/regeo", &token, None).await; + assert_eq!(regeo["code"], 400, "逆地理编码必须诚实失败: {regeo}"); + assert_eq!(regeo["data"], Value::Null, "不许返假坐标: {regeo}"); + + // 注销业务规则未定义。 + let logout = call(port, "POST", "/api/oauth/logoutCurrentUser", &token, None).await; + assert_eq!(logout["code"], 400, "注销当前用户必须诚实失败: {logout}"); + + // 单租户 ⇒ 邀请链接无意义。 + let invite = call(port, "GET", "/api/system/tenant/saas/inviteurl", &token, None).await; + assert_eq!(invite["code"], 400, "单租户的 SaaS 邀请链接必须诚实失败: {invite}"); + + // 🔴 第三方登录**列表**:没配置 ⇒ 返**空数组**(页面显示「没有可用的第三方登录」), + // 这不是「假成功」—— 空列表就是「一个都没有」的真实语义。 + let list = call(port, "GET", "/api/permission/socials/login", &token, None).await; + assert_eq!(list["code"], 200, "{list}"); + assert_eq!(list["data"], json_empty(), "没配置第三方 ⇒ 必须是空数组: {list}"); +} + +fn json_empty() -> Value { + Value::Array(Vec::new()) +} + +/// 🔴 **`/api/oauth/Login/socials` 双方法**:官方 `LoginController.java:117` 的 +/// `@RequestMapping(value="/Login/**", method={GET,POST})` ⇒ GET/POST 都收。 +/// 官方 Web 前端用 POST、**移动端 `api/common.js:563` 用 GET**(不写 method)。 +#[tokio::test] +async fn socials_login_accepts_both_get_and_post() { + let _g = LOCK.lock().await; + let (port, _token) = boot().await; + + let (status, body) = raw_call(port, "GET", "/api/oauth/Login/socials", "", None).await; + assert_eq!(status, 200, "GET 版 socials 必须命中路由: {body}"); + assert_ne!(body["code"], 404, "GET 版 socials 未注册: {body}"); + + let (status, body) = raw_call(port, "POST", "/api/oauth/Login/socials", "", None).await; + assert_eq!(status, 200, "POST 版 socials 必须命中路由: {body}"); + assert_ne!(body["code"], 404, "POST 版 socials 未注册: {body}"); +} + +/// 🔴 **驳回动作的落库语义**: +/// - `workflow_task.f_status` = 3(`TaskStatusEnum.REJECTED`); +/// - `workflow_operator.f_handle_status` = **0**(`FlowNature.REJECT_COMPLETION`); +/// - `workflow_node_record.f_node_status` = 3(`NodeStateEnum.REJECT`)。 +/// 且**驳回后不得再出现在待办里**(待办 = `f_handle_status IS NULL`)。 +#[tokio::test] +async fn flow_before_cancel_writes_official_status_codes() { + let _g = LOCK.lock().await; + let (port, token) = boot().await; + + // 造一条待办:workflow_task + workflow_operator(处理人 = admin,未处理)。 + let db = db().await; + let task_id = "mobile-test-task-1"; + db.exec_params( + "INSERT INTO workflow_task (f_id, f_full_name, f_flow_name, f_flow_code, f_status, \ + f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ($1::text, '移动端测试流程', '测试流程', 'test_flow', 1, 'admin', now(), 0, '0')", + &[&task_id], + ) + .await + .expect("插入测试任务失败"); + db.exec_params( + "INSERT INTO workflow_operator (f_id, f_task_id, f_node_name, f_node_code, \ + f_handle_id, f_creator_user_id, f_creator_time, f_delete_mark, f_tenant_id) \ + VALUES ('mobile-test-op-1', $1::text, '部门经理', 'mgr', 'admin', 'admin', now(), 0, '0')", + &[&task_id], + ) + .await + .expect("插入测试处理人失败"); + + // 驳回前:必须在待办里。 + let before = call(port, "GET", "/api/visualdev/Dashboard/MyFlowTodo", &token, None).await; + assert!( + before["data"] + .as_array() + .map(|a| a.iter().any(|r| r["id"] == task_id)) + .unwrap_or(false), + "未处理的任务必须在待办里: {before}" + ); + + // 驳回。 + let cancel = call( + port, + "POST", + &format!("/api/workflow/Engine/FlowBefore/Cancel/{task_id}"), + &token, + Some(r#"{"comment":"材料不全,退回"}"#), + ) + .await; + assert_eq!(cancel["code"], 200, "{cancel}"); + + // 🔴 落库口径逐项核对。 + let rows = db + .query_json_params( + "SELECT t.f_status AS \"taskStatus\", o.f_handle_status AS \"handleStatus\", \ + (SELECT COUNT(*)::bigint FROM workflow_node_record r \ + WHERE r.f_task_id = t.f_id AND r.f_node_status = 3) AS \"rejectRecords\" \ + FROM workflow_task t \ + JOIN workflow_operator o ON o.f_task_id = t.f_id \ + WHERE t.f_id = $1::text", + &[&task_id], + ) + .await + .expect("查询驳回结果失败"); + let r = rows.first().expect("必须查到刚才那条"); + assert_eq!(r["taskStatus"], 3, "任务状态必须是 3(REJECTED): {r}"); + assert_eq!( + r["handleStatus"], 0, + "处理人状态必须是 0(FlowNature.REJECT_COMPLETION): {r}" + ); + assert_eq!(r["rejectRecords"], 1, "必须留一条驳回意见: {r}"); + + // 🔴 驳回后**不得**再出现在待办里。 + let after = call(port, "GET", "/api/visualdev/Dashboard/MyFlowTodo", &token, None).await; + assert!( + !after["data"] + .as_array() + .map(|a| a.iter().any(|r| r["id"] == task_id)) + .unwrap_or(false), + "驳回后不得再出现在待办里: {after}" + ); +}