fmode-file-hub-THXAOGKiPK-fixed.js 28 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769
  1. // fmode-file-hub v0.2.0 — 文件台账(按会话 / 按群隔离)(表: AgentDeliverable)
  2. //
  3. // ## v0.2.0(2026-11-11):群隔离
  4. //
  5. // 伪群聊架构下(App 把群消息拆成 N 条私聊发给各成员容器),容器只在自己的
  6. // DM 房间工作,**它不知道文件属于哪个群**。所以「归群」只能由 App 侧决定:
  7. //
  8. // · 用户上传 → 写入时直接带 `groupId`(App 知道当前是哪个群)
  9. // · 容器产出 → 靠「派发锚点」反查(后续版本),或 App 惰性补归并
  10. //
  11. // 新增字段:`groupId`(所属群;'' = 不属于任何群)、`groupIdSource`、`prevThreadRoot`
  12. // 新增 action:`listByGroup` / `claimToGroup`
  13. //
  14. // 🔴 `threadRoot` 语义不变(单聊 = 单聊会话 id,群 = 群 id)。
  15. // `claimToGroup` 会把记录**搬**进群(threadRoot 一并改写),
  16. // 保证一条文件只出现在一个页签 —— 这就是「不串台」的落地方式。
  17. //
  18. // ## 为什么新建而不是改老函数
  19. //
  20. // 老函数 lfYlgU7SkK(fmodeagent-deliverables) 的 report 用 UPDATABLE 白名单写字段,
  21. // 里面**没有 threadRoot** —— 容器传了也会被静默丢弃,所以成果永远无法归属到会话。
  22. // 用户裁决(2026-11-10):**现有云函数一行不动,新建独立函数走新接口**。
  23. //
  24. // ## 职责边界(用户裁决)
  25. //
  26. // · 消息**不入库**(单聊/群聊都在 Matrix)
  27. // · 只有**文件与成果**入库,目的是让右侧栏能按会话直接加载
  28. // · 只存访问链接与文件元信息,**不存文件内容**(内容由 AlP56LCKFm 签名直传 OBS)
  29. // · 不做老数据适配:没有 threadRoot 的历史成果不出现,按用户裁决"全面切新逻辑"
  30. //
  31. // ## 调用
  32. //
  33. // POST /api/functions {token, id:<Function objectId>, params:{action, ...}}
  34. // action: registerFile | listBySession | listByAgent
  35. //
  36. // ## 表
  37. //
  38. // 复用 AgentDeliverable(已有 user / company / ACL),新增字段:
  39. // threadRoot / uploadedBy / fileName / fileSize / mimeType / storageKey / roomId
  40. // ==================== 基础工具(各云函数本就各自复制一份,沿用惯例) ====================
  41. var CLASS_NAME = 'AgentDeliverable';
  42. var MAX_LIMIT = 200;
  43. var DEFAULT_LIMIT = 50;
  44. /** 会话标识、URL、文件名等的长度上限 */
  45. var LEN = { threadRoot: 200, roomId: 200, agentId: 120, url: 1000, name: 200, key: 500, mime: 120 };
  46. /** 单个文件大小上限(与 App 侧 upload-limits.ts 的 20MB 保持一致) */
  47. var MAX_FILE_BYTES = 20 * 1024 * 1024;
  48. /**
  49. * 「派发锚点」的有效窗口(v0.2.0)。
  50. *
  51. * App 发群消息时为每个目标容器记一条锚点,容器产出的文件在**锚点之后
  52. * 这个窗口内**才认它属于那个群。超过窗口不认 —— 宁可漏,不归错
  53. * (用户裁决 2026-11-11)。
  54. */
  55. var GROUP_ANCHOR_TTL_MS = 30 * 60 * 1000;
  56. /** 锚点记录的识别标记(App 写入时用的 mimeType) */
  57. var ANCHOR_MIME = 'application/x-fmode-anchor';
  58. function _ok(response, data) {
  59. var body = { code: 200 };
  60. if (data) for (var k in data) body[k] = data[k];
  61. response.status(200).json(body);
  62. }
  63. function _fail(response, code, msg) {
  64. response.status(200).json({ code: code, msg: msg });
  65. }
  66. function _str(v, max) {
  67. if (v === undefined || v === null) return '';
  68. var s = String(v).trim();
  69. return max && s.length > max ? s.slice(0, max) : s;
  70. }
  71. function _num(v) {
  72. var n = Number(v);
  73. return isFinite(n) && n >= 0 ? n : null;
  74. }
  75. /**
  76. * 取指针 / 对象的 objectId。
  77. *
  78. * 🔴 2026-11-18:这个函数原来**缺失**,但 `opRegisterFile` 的
  79. * `deliverableId` 认领分支调用了它 —— 线上表现为:
  80. * 带 deliverableId → {"code": 500, "msg": "_idOf is not defined"}
  81. * 去掉 deliverableId → {"code": 200}(走另一条路径)
  82. *
  83. * 后果:容器上报成果后,用 report 返回的 id 来认领那条记录时**必然失败**,
  84. * 文件虽然上了 S3,但成果表里没有对应记录 —— 用户在「成果」页签看不到。
  85. *
  86. * 实现与 `lfYlgU7SkK`(fmodeagent-deliverables)里的同名函数保持一致:
  87. * 字符串直接返回,指针取 `.id`,空值返回 null。
  88. */
  89. function _idOf(v) {
  90. if (!v) return null;
  91. if (typeof v === 'string') return v;
  92. return v.id || null;
  93. }
  94. function _sessionToken() {
  95. // 与 fmodeagent-status 同口径:请求头优先(平台实测只保留请求头)
  96. if (request.headers && request.headers['x-parse-session-token']) {
  97. return request.headers['x-parse-session-token'];
  98. }
  99. if (params && params.token) return params.token;
  100. if (request.body && request.body.token) return request.body.token;
  101. return null;
  102. }
  103. async function _getUser(t) {
  104. if (!t) return null;
  105. if (request.user && request.user.id) return request.user;
  106. try {
  107. var q = new Parse.Query(Parse.Session);
  108. q.equalTo('sessionToken', t);
  109. q.include('user');
  110. var s = await q.first({ useMasterKey: true });
  111. return s ? s.get('user') : null;
  112. } catch (e) {
  113. return null;
  114. }
  115. }
  116. /**
  117. * 反查容器产出的文件属于哪个群(v0.2.0)。
  118. *
  119. * ## 为什么需要
  120. *
  121. * 伪群聊下容器只在自己的 DM 房间工作,回报文件时**不知道群**。
  122. * App 在派活前为每个目标容器记了一条锚点(`uploadedBy:'agent'` +
  123. * `ANCHOR_MIME`),锚点上带着 `groupId` / `agentId` / `roomId`。
  124. * 容器产出到达时,按「同 user + 同 agentId + 同 roomId + 时间在锚点之后」匹配。
  125. *
  126. * ## 宁可漏,不归错(用户裁决)
  127. *
  128. * - 有多条候选锚点 → **不认**(同时被多个群派活的典型场景,认了就会串台)
  129. * - 锚点太旧(超出 TTL)→ 不认
  130. * - 匹配不到 → 返回 '',文件照常登记,只是不归群
  131. *
  132. * @returns {{ groupId: string }} 命中返回群 id,否则空串
  133. */
  134. async function _resolveGroup(user, agentId, roomId) {
  135. if (!agentId) return '';
  136. var q = new Parse.Query(CLASS_NAME);
  137. q.equalTo('user', user);
  138. q.equalTo('agentId', agentId);
  139. q.equalTo('uploadedBy', 'agent');
  140. q.equalTo('mimeType', ANCHOR_MIME);
  141. q.greaterThan('deliveredAt', new Date(Date.now() - GROUP_ANCHOR_TTL_MS));
  142. q.descending('deliveredAt');
  143. q.limit(10);
  144. var rows;
  145. try {
  146. rows = await q.find({ useMasterKey: true });
  147. } catch (e) {
  148. if (!_isMissingColumn(e)) throw e;
  149. await _ensureColumns();
  150. rows = await q.find({ useMasterKey: true });
  151. }
  152. if (rows.length === 0) return '';
  153. /*
  154. * 🔴 唯一性要求:窗口内必须只有**同一个群**的锚点。
  155. *
  156. * 同一容器被群 G 和群 H 先后派活 → 有两条锚点指向不同群 →
  157. * 无法判断这个文件是谁的 → 不认。这是「不串台」的底线,
  158. * 代价是这种并发场景下文件不归群(仍会出现在单聊里)。
  159. */
  160. var groups = new Set();
  161. for (var i = 0; i < rows.length; i++) {
  162. var g = rows[i].get('groupId') || '';
  163. if (g) groups.add(g);
  164. }
  165. if (groups.size !== 1) return '';
  166. return groups.values().next().value || '';
  167. }
  168. /** 云盘链接只接受本平台域名,防止登记任意外链冒充成果 */
  169. function _isCloudUrl(u) {
  170. return /^https:\/\/(s3|file-cloud)\.fmode\.cn\//i.test(u);
  171. }
  172. /**
  173. * 用 threadRoot 反查该会话的房间 id(v0.3.0,2026-11-13)。
  174. *
  175. * 为什么要它:`registerFile` 的主键改成了 roomId,但老调用方(以及容器)
  176. * 手里可能只有 threadRoot。会话目录 `FmodeChatThread` 同时存了
  177. * `threadRoot` 与 `roomId`,是这条换算的权威来源。
  178. *
  179. * 反查不到就返回空串,由调用方决定降级策略(这里退回用 threadRoot 当键)。
  180. */
  181. async function _roomOfThread(user, threadRoot) {
  182. if (!threadRoot) return '';
  183. try {
  184. var q = new Parse.Query('FmodeChatThread');
  185. q.equalTo('user', user);
  186. q.equalTo('threadRoot', threadRoot);
  187. q.descending('lastMessageAt');
  188. var row = await q.first({ useMasterKey: true });
  189. return row ? row.get('roomId') || '' : '';
  190. } catch (e) {
  191. /* 会话目录不可用不该阻断登记:调用方会退回 threadRoot */
  192. return '';
  193. }
  194. }
  195. /**
  196. * 校验 `groupId` 确实是**本用户的群会话**(v0.2.0)。
  197. *
  198. * 🔴 为什么必须校验:`groupId` 是隔离边界。若不校验,客户端可以传任意字符串,
  199. * 把文件"归"到一个不存在的群或别人的群 —— 隔离就成了摆设。
  200. *
  201. * 会话目录在 `FmodeChatThread` 表,`kind === 'group'` 才是群。
  202. * 查不到 / 不是群 / 不是本人 → 一律拒绝。
  203. */
  204. async function _isOwnGroup(user, groupId) {
  205. if (!groupId) return false;
  206. try {
  207. var q = new Parse.Query('FmodeChatThread');
  208. q.equalTo('user', user);
  209. q.equalTo('objectId', groupId);
  210. var row = await q.first({ useMasterKey: true });
  211. if (!row) return false;
  212. var kind = String(row.get('kind') || '').toLowerCase();
  213. return kind === 'group';
  214. } catch (e) {
  215. /* 表不存在或查询失败 → 保守拒绝,宁可登记成"不归群" */
  216. return false;
  217. }
  218. }
  219. /**
  220. * 确保 class 上存在某个列(2026-11-10)。
  221. *
  222. * 🔴 Parse 的自动建列**只在写入时发生**:数据库里还没有 `threadRoot` 列时,
  223. * 直接 `equalTo('threadRoot', x)` 会让 PostgreSQL 报 42703 errorMissingColumn。
  224. * 历史数据本来就没有这个字段,所以第一次查询必然踩到。
  225. *
  226. * 做法:写一个带该字段的探测对象再立刻销毁,把列建出来。
  227. * 只在捕获到缺列错误时执行一次,正常路径零开销。
  228. */
  229. var _ensured = false;
  230. /**
  231. * 一次性建出所有新列。
  232. *
  233. * 历史数据里这些字段一个都不存在,分散建列会让每个字段都触发一次
  234. * 失败查询 + 重试,这里一次建全,后续查询零开销。
  235. */
  236. async function _ensureColumns() {
  237. if (_ensured) return;
  238. var probe = new Parse.Object(CLASS_NAME);
  239. probe.set('threadRoot', '');
  240. probe.set('fileUrl', '');
  241. probe.set('uploadedBy', '');
  242. probe.set('fileName', '');
  243. probe.set('fileSize', 0);
  244. probe.set('mimeType', '');
  245. probe.set('storageKey', '');
  246. probe.set('roomId', '');
  247. /* v0.2.0(2026-11-11):群隔离字段 */
  248. probe.set('groupId', '');
  249. probe.set('groupIdSource', '');
  250. probe.set('scope', '');
  251. await probe.save(null, { useMasterKey: true });
  252. // 探测对象必须销毁,否则会在成果列表里留下一条空记录
  253. await probe.destroy({ useMasterKey: true });
  254. _ensured = true;
  255. }
  256. /**
  257. * 判断是否「列不存在」错误。
  258. *
  259. * 🔴 只认 PostgreSQL 的错误码,不能按字段名匹配 ——
  260. * 查询语句本身就包含字段名,按名匹配会让任何错误都被当成缺列。
  261. */
  262. function _isMissingColumn(e) {
  263. try {
  264. var s = JSON.stringify(e);
  265. return s.indexOf('42703') >= 0 || s.indexOf('errorMissingColumn') >= 0;
  266. } catch (e2) {
  267. return false;
  268. }
  269. }
  270. // ==================== 行 → 返回对象 ====================
  271. function _toFile(r) {
  272. var artifacts = r.get('artifacts') || [];
  273. var first = Array.isArray(artifacts) && artifacts.length ? artifacts[0] : null;
  274. if (typeof first === 'string') first = { url: first, name: '' };
  275. return {
  276. id: r.id,
  277. threadRoot: r.get('threadRoot') || '',
  278. /* v0.2.0:所属群会话 id;'' = 不属于任何群 */
  279. groupId: r.get('groupId') || '',
  280. groupIdSource: r.get('groupIdSource') || '',
  281. agentId: r.get('agentId') || '',
  282. roomId: r.get('roomId') || '',
  283. // 文件信息优先取新字段,回退到 artifacts[0](两者写入时保持一致)
  284. name: r.get('fileName') || (first && first.name) || '',
  285. size: typeof r.get('fileSize') === 'number' ? r.get('fileSize') : -1,
  286. mimeType: r.get('mimeType') || (first && first.mimeType) || '',
  287. url: (first && first.url) || '',
  288. storageKey: r.get('storageKey') || '',
  289. uploadedBy: r.get('uploadedBy') || 'agent',
  290. status: r.get('status') || 'delivered',
  291. deliveredAt: (r.get('deliveredAt') || r.get('createdAt'))
  292. ? new Date(r.get('deliveredAt') || r.get('createdAt')).getTime()
  293. : 0,
  294. };
  295. }
  296. /**
  297. * 过滤掉**派发锚点**记录(v0.2.0)。
  298. *
  299. * 锚点是 App 在派活前写的内部记录(`mimeType = ANCHOR_MIME`),
  300. * 只用来反查文件归属,**不是文件**,不能出现在任何列表里。
  301. */
  302. function _toFiles(rows) {
  303. var out = [];
  304. for (var i = 0; i < rows.length; i++) {
  305. if (rows[i].get('mimeType') === ANCHOR_MIME) continue;
  306. out.push(_toFile(rows[i]));
  307. }
  308. return out;
  309. }
  310. // ==================== actions ====================
  311. /**
  312. * registerFile —— 登记一条文件记录
  313. *
  314. * 用户上传(uploadedBy:'user')与容器产出(uploadedBy:'agent')共用。
  315. * 幂等:同一 (user, roomId, url) 重复登记返回已有记录,不产生重复。
  316. *
  317. * ## 归属键:roomId 优先(v0.3.0,2026-11-13)
  318. *
  319. * 旧版要求 `threadRoot` 必填,而它依赖容器能拿到 App 的会话根 —— 实测拿不到
  320. * (DM 的 `m.relates_to` 根本没进消息),容器只能回落到房间 id。
  321. * App 却按 `$approot_*` 会话根查,**两边键从来对不上**。
  322. *
  323. * 现改为:`roomId` 必填、`threadRoot` 可选。
  324. * 一房间一会话下 roomId 与会话一一对应(App 建房失败会硬报错,不再降级共用房间)。
  325. *
  326. * 老调用方仍可只传 `threadRoot`:服务端用 `FmodeChatThread` 反查它的 roomId。
  327. */
  328. async function opRegisterFile(user, response) {
  329. var p = params || {};
  330. var threadRoot = _str(p.threadRoot, LEN.threadRoot);
  331. var roomId = _str(p.roomId, LEN.roomId);
  332. var url = _str(p.url, LEN.url);
  333. var name = _str(p.name, LEN.name);
  334. /*
  335. * 兼容老调用方:只给了 threadRoot 时,反查该会话的房间。
  336. * 查不到就退回用 threadRoot 当归属键(保证老链路不至于直接失败)。
  337. */
  338. if (!roomId && threadRoot) {
  339. roomId = (await _roomOfThread(user, threadRoot)) || '';
  340. }
  341. if (!roomId) return _fail(response, 400, 'roomId required');
  342. if (!url) return _fail(response, 400, 'url required');
  343. if (!_isCloudUrl(url)) return _fail(response, 400, 'url must be a platform cloud link');
  344. if (!name) return _fail(response, 400, 'name required');
  345. var size = _num(p.size);
  346. if (size !== null && size > MAX_FILE_BYTES) return _fail(response, 400, 'file too large');
  347. var uploadedBy = p.uploadedBy === 'user' ? 'user' : 'agent';
  348. var agentId = _str(p.agentId, LEN.agentId);
  349. /*
  350. * 群归属(v0.2.0,2026-11-11)。
  351. *
  352. * 传了 `groupId` 就必须是本用户的群,否则拒绝 —— 见 `_isOwnGroup`。
  353. * 没传或校验不过 → `groupId` 留空,按原来的「只按会话」处理,
  354. * 不影响存量调用方。
  355. */
  356. var groupId = _str(p.groupId, LEN.threadRoot);
  357. if (groupId) {
  358. var ok = await _isOwnGroup(user, groupId);
  359. if (!ok) return _fail(response, 400, 'groupId must be your own group session');
  360. } else if (uploadedBy === 'agent' && _str(p.mimeType, LEN.mime) !== ANCHOR_MIME) {
  361. /*
  362. * 容器产出没带 groupId → 反查派发锚点(v0.2.0)。
  363. *
  364. * 用户上传(uploadedBy='user')不做反查:App 知道群,直接传就行。
  365. * 锚点记录本身(ANCHOR_MIME)也跳过,否则会自己匹配自己。
  366. */
  367. groupId = await _resolveGroup(user, agentId, _str(p.roomId, LEN.roomId));
  368. }
  369. /*
  370. * 幂等:同一会话内同一 URL 只存一条。
  371. *
  372. * 🔴 不能查 `artifacts.url`(数组内字段)—— 实测该查询永远匹配不到,
  373. * 会导致重复登记。改查顶层 `fileUrl`:registerFile 写入时同步落一份。
  374. * 该列首次查询时也不存在,需要建列后重试(见 _ensureColumn)。
  375. */
  376. /* 🔴 2026-11-14:先按 deliverableId 认领 report 已建的那条记录,不新建。
  377. * registerFile 原来按 (user, roomId, fileUrl) 查重,但 report 建的那条没有
  378. * roomId/fileUrl,查不到 → 又建一条 → 同一 URL 两条记录。
  379. * report 返回的 id 即那条的 objectId,容器以 deliverableId 传进来。 */
  380. var claimId = _str(p.deliverableId, 60);
  381. if (claimId) {
  382. var cq = new Parse.Query(CLASS_NAME);
  383. var claim = await cq.get(claimId, { useMasterKey: true }).catch(function () { return null; });
  384. if (claim && String(_idOf(claim.get('user'))) === String(user.id) && !claim.get('roomId')) {
  385. claim.set('roomId', groupId || roomId);
  386. claim.set('threadRoot', groupId || threadRoot || roomId);
  387. claim.set('fileUrl', url);
  388. claim.set('fileName', name);
  389. claim.set('storageKey', _str(p.key, LEN.key));
  390. claim.set('mimeType', _str(p.mimeType, LEN.mime) || 'application/octet-stream');
  391. if (size !== null) claim.set('fileSize', size);
  392. claim.set('uploadedBy', uploadedBy);
  393. claim.set('agentId', agentId);
  394. claim.set('reportedAt', new Date());
  395. await claim.save(null, { useMasterKey: true });
  396. return _ok(response, { id: claim.id, claimed: true });
  397. }
  398. }
  399. var dupQ = new Parse.Query(CLASS_NAME);
  400. dupQ.equalTo('user', user);
  401. dupQ.equalTo('roomId', roomId);
  402. dupQ.equalTo('fileUrl', url);
  403. var dup;
  404. try {
  405. dup = await dupQ.first({ useMasterKey: true });
  406. } catch (e) {
  407. if (!_isMissingColumn(e)) throw e;
  408. await _ensureColumns();
  409. dup = await dupQ.first({ useMasterKey: true });
  410. }
  411. if (dup) return _ok(response, { id: dup.id, duplicated: true });
  412. var obj = new Parse.Object(CLASS_NAME);
  413. obj.set('user', user);
  414. /*
  415. * 🔴 反查命中的群文件,`threadRoot` **一并改写为群 id**(v0.2.0)。
  416. *
  417. * 这是「不串台」的落地:一条文件只能属于一个页签。
  418. * 若仍保留 DM thread,单聊 `listBySession(dm)` 也会返回它 ——
  419. * 同一个文件在单聊和群里各出现一次。
  420. *
  421. * 原始的 DM thread 存进 `prevThreadRoot`,出问题可据此还原。
  422. */
  423. var resolvedByAnchor = !p.groupId && !!groupId;
  424. /*
  425. * roomId 是主键;threadRoot 落库保留(历史兼容 + 排查用),但不再作为归属依据。
  426. * 群归属命中时两者都改写为群 id,避免同一文件在两个页签各出现一次。
  427. */
  428. obj.set('roomId', resolvedByAnchor ? groupId : roomId);
  429. obj.set('threadRoot', resolvedByAnchor ? groupId : threadRoot || roomId);
  430. if (resolvedByAnchor) obj.set('prevThreadRoot', threadRoot);
  431. obj.set('groupId', groupId);
  432. obj.set(
  433. 'groupIdSource',
  434. groupId ? (resolvedByAnchor ? 'anchor' : _str(p.groupIdSource, 20) || 'app') : '',
  435. );
  436. obj.set('agentId', agentId);
  437. obj.set('uploadedBy', uploadedBy);
  438. obj.set('fileName', name);
  439. obj.set('fileSize', size === null ? -1 : size);
  440. obj.set('mimeType', _str(p.mimeType, LEN.mime));
  441. obj.set('storageKey', _str(p.key, LEN.key));
  442. /* 幂等键:顶层单独存一份 URL,见 opRegisterFile 的去重说明 */
  443. obj.set('fileUrl', url);
  444. obj.set('title', name);
  445. obj.set('summary', p.source ? '容器产出' : '用户上传');
  446. obj.set('status', 'delivered');
  447. obj.set('deliveredAt', new Date());
  448. obj.set('reportedAt', new Date());
  449. obj.set('tags', ['file-hub', uploadedBy]);
  450. /*
  451. * artifacts 保留数组形态:App 现有的 Deliverable 映射(mapDeliverable)
  452. * 按 artifacts[0].url 取链接,写在这里就不用改 App 的解析层。
  453. */
  454. obj.set('artifacts', [
  455. {
  456. name: name,
  457. url: url,
  458. type: _str(p.mimeType, LEN.mime),
  459. source: _str(p.source, LEN.url),
  460. },
  461. ]);
  462. // ACL:只给本人读写(成果属于个人会话,不跨用户可见)
  463. var acl = new Parse.ACL(user);
  464. acl.setPublicReadAccess(false);
  465. acl.setPublicWriteAccess(false);
  466. obj.setACL(acl);
  467. // 公司指针从 agent 带过来,保持与老成果表一致的多租户口径
  468. if (agentId) {
  469. try {
  470. var aq = new Parse.Query('FmodeAgent');
  471. aq.equalTo('agentId', agentId);
  472. var agent = await aq.first({ useMasterKey: true });
  473. if (agent) {
  474. obj.set('agent', agent);
  475. obj.set('agentObjectId', agent.id);
  476. var company = agent.get('company');
  477. if (company) obj.set('company', company);
  478. if (!agentId) obj.set('agentId', agent.get('agentId') || '');
  479. }
  480. } catch (e) {
  481. /* agent 查不到不影响登记:文件仍归属到用户与会话 */
  482. }
  483. }
  484. var saved = await obj.save(null, { useMasterKey: true });
  485. return _ok(response, { id: saved.id });
  486. }
  487. /**
  488. * listBySession —— 按会话拉文件(右侧栏主路径)
  489. *
  490. * 这是用户要求「每次直接从数据库加载文件」的入口:
  491. * 不依赖加载聊天历史,也不依赖 FmodeChatThread.deliverableUrls。
  492. *
  493. * ## 入参(v0.3.0,2026-11-13)
  494. *
  495. * 优先 `roomId`;只给了 `threadRoot` 时先反查房间,再按 roomId 查。
  496. * 两者都没有才报错。
  497. *
  498. * 为什么不能继续只按 threadRoot 查:容器登记的 threadRoot 实际是房间 id
  499. * (`_thread_root()` 的二级回落),而 App 传的是 `$approot_*` 会话根 ——
  500. * 两个值对不上,右栏永远查不到容器成果。
  501. */
  502. async function opListBySession(user, response) {
  503. var p = params || {};
  504. var roomId = _str(p.roomId, LEN.roomId);
  505. var threadRoot = _str(p.threadRoot, LEN.threadRoot);
  506. if (!roomId && threadRoot) {
  507. roomId = (await _roomOfThread(user, threadRoot)) || '';
  508. /* 反查不到:退回按 threadRoot 查(兼容老数据) */
  509. if (!roomId) roomId = threadRoot;
  510. }
  511. if (!roomId) return _fail(response, 400, 'roomId required');
  512. var q = new Parse.Query(CLASS_NAME);
  513. q.equalTo('user', user);
  514. q.equalTo('roomId', roomId);
  515. if (p.before) {
  516. var before = new Date(Number(p.before));
  517. if (!isNaN(before.getTime())) q.lessThan('deliveredAt', before);
  518. }
  519. q.descending('deliveredAt');
  520. q.limit(Math.min(Number(p.limit) || DEFAULT_LIMIT, MAX_LIMIT));
  521. var rows;
  522. try {
  523. rows = await q.find({ useMasterKey: true });
  524. } catch (e) {
  525. // 列还不存在 → 建列后重试一次(历史数据没有 threadRoot,首次查询必然走到这里)
  526. if (!_isMissingColumn(e)) throw e;
  527. await _ensureColumns();
  528. rows = await q.find({ useMasterKey: true });
  529. }
  530. var list = _toFiles(rows);
  531. return _ok(response, {
  532. roomId: roomId,
  533. threadRoot: threadRoot,
  534. files: list,
  535. count: list.length,
  536. });
  537. }
  538. /**
  539. * listByUrl —— 按 URL 反查已登记记录(v0.3.0,2026-11-13)
  540. *
  541. * App 的「成果绑定服务」用它判断某个链接是否已经进了台账:
  542. * · 命中且 roomId 与当前房间一致 → 已绑定,什么都不用做
  543. * · 没命中 → 由 App 补登记
  544. *
  545. * 这是**跨会话**查询(只按 user + url),所以调用方必须自己再校验房间归属,
  546. * 不能拿它当作"这条属于我"的证据。返回里带 roomId 就是为了让调用方能校验。
  547. */
  548. async function opListByUrl(user, response) {
  549. var p = params || {};
  550. var url = _str(p.url, LEN.url);
  551. if (!url) return _fail(response, 400, 'url required');
  552. var q = new Parse.Query(CLASS_NAME);
  553. q.equalTo('user', user);
  554. q.equalTo('fileUrl', url);
  555. q.descending('deliveredAt');
  556. q.limit(Math.min(Number(p.limit) || 10, 50));
  557. var rows;
  558. try {
  559. rows = await q.find({ useMasterKey: true });
  560. } catch (e) {
  561. if (!_isMissingColumn(e)) throw e;
  562. await _ensureColumns();
  563. rows = await q.find({ useMasterKey: true });
  564. }
  565. var list = _toFiles(rows);
  566. return _ok(response, { files: list, count: list.length });
  567. }
  568. /** listByAgent —— 按容器拉(成果页用,不按会话过滤) */async function opListByAgent(user, response) {
  569. var p = params || {};
  570. var q = new Parse.Query(CLASS_NAME);
  571. q.equalTo('user', user);
  572. var agentId = _str(p.agentId, LEN.agentId);
  573. if (agentId) q.equalTo('agentId', agentId);
  574. if (p.before) {
  575. var before = new Date(Number(p.before));
  576. if (!isNaN(before.getTime())) q.lessThan('deliveredAt', before);
  577. }
  578. q.descending('deliveredAt');
  579. q.limit(Math.min(Number(p.limit) || DEFAULT_LIMIT, MAX_LIMIT));
  580. var rows = await q.find({ useMasterKey: true });
  581. var list = _toFiles(rows);
  582. return _ok(response, { files: list, count: list.length });
  583. }
  584. /**
  585. * listByGroup —— 按**群**拉文件(v0.2.0,2026-11-11)
  586. *
  587. * ## 为什么不能只用 threadRoot
  588. *
  589. * 群里的文件有两种来源:
  590. * · **用户上传**:写入时 `threadRoot = groupId`(历史数据也只有 threadRoot)
  591. * · **容器产出**:容器只知道 DM thread,由服务端反查/补归并后
  592. * `threadRoot` 改写为群 id、同时补 `groupId`
  593. *
  594. * 查询用 `groupId == g OR threadRoot == g`,两条来源都能覆盖,
  595. * 也让**没有 groupId 的存量群内上传记录**照样查得到(无需数据迁移)。
  596. */
  597. async function opListByGroup(user, response) {
  598. var p = params || {};
  599. var groupId = _str(p.groupId, LEN.threadRoot);
  600. if (!groupId) return _fail(response, 400, 'groupId required');
  601. var byGroup = new Parse.Query(CLASS_NAME);
  602. byGroup.equalTo('user', user);
  603. byGroup.equalTo('groupId', groupId);
  604. var byThread = new Parse.Query(CLASS_NAME);
  605. byThread.equalTo('user', user);
  606. byThread.equalTo('threadRoot', groupId);
  607. var q = Parse.Query.or(byGroup, byThread);
  608. if (p.before) {
  609. var before = new Date(Number(p.before));
  610. if (!isNaN(before.getTime())) q.lessThan('deliveredAt', before);
  611. }
  612. q.descending('deliveredAt');
  613. q.limit(Math.min(Number(p.limit) || DEFAULT_LIMIT, MAX_LIMIT));
  614. var rows;
  615. try {
  616. rows = await q.find({ useMasterKey: true });
  617. } catch (e) {
  618. if (!_isMissingColumn(e)) throw e;
  619. await _ensureColumns();
  620. rows = await q.find({ useMasterKey: true });
  621. }
  622. var list = _toFiles(rows);
  623. return _ok(response, { groupId: groupId, files: list, count: list.length });
  624. }
  625. /**
  626. * claimToGroup —— 惰性补归并(v0.2.0,2026-11-11)
  627. *
  628. * 有些容器产出登记时没能确定归属群(`groupId=''`)。群页面打开时,
  629. * App 把「有把握属于本群」的记录 id 传进来,这里把它们**搬**到群上:
  630. * 补 `groupId`、把 `threadRoot` 改写为群 id。
  631. *
  632. * 🔴 改写 threadRoot 是「互斥」的落地:一条文件只能出现在一个页签 ——
  633. * 搬进群之后,单聊 `listBySession(单聊sid)` 自然查不到它了。
  634. *
  635. * 安全:只允许操作**本人**的、`uploadedBy='agent'`(容器产出)、
  636. * 且当前 `groupId` 为空的记录。用户上传的文件不允许被搬。
  637. */
  638. async function opClaimToGroup(user, response) {
  639. var p = params || {};
  640. var groupId = _str(p.groupId, LEN.threadRoot);
  641. var ids = Array.isArray(p.ids) ? p.ids.filter((x) => typeof x === 'string' && x) : [];
  642. if (!groupId) return _fail(response, 400, 'groupId required');
  643. if (ids.length === 0) return _fail(response, 400, 'ids required');
  644. if (!(await _isOwnGroup(user, groupId))) {
  645. return _fail(response, 400, 'groupId must be your own group session');
  646. }
  647. var claimed = 0;
  648. var skipped = 0;
  649. for (var i = 0; i < ids.length && i < 100; i++) {
  650. var obj;
  651. try {
  652. var q = new Parse.Query(CLASS_NAME);
  653. q.equalTo('user', user);
  654. obj = await q.get(ids[i], { useMasterKey: true });
  655. } catch (e) {
  656. skipped++;
  657. continue;
  658. }
  659. if (!obj) {
  660. skipped++;
  661. continue;
  662. }
  663. if (obj.get('uploadedBy') !== 'agent' || obj.get('groupId')) {
  664. skipped++;
  665. continue;
  666. }
  667. try {
  668. /* 留一份原 threadRoot,便于出问题时还原 */
  669. if (!obj.get('prevThreadRoot')) obj.set('prevThreadRoot', obj.get('threadRoot') || '');
  670. obj.set('groupId', groupId);
  671. obj.set('groupIdSource', 'claim');
  672. obj.set('threadRoot', groupId);
  673. await obj.save(null, { useMasterKey: true });
  674. claimed++;
  675. } catch (e) {
  676. skipped++;
  677. }
  678. }
  679. return _ok(response, { groupId: groupId, claimed: claimed, skipped: skipped });
  680. }
  681. // ==================== 入口 ====================
  682. function handler(request, response) {
  683. (async function () {
  684. var p = params || {};
  685. var act = p.action || 'listBySession';
  686. var token = _sessionToken();
  687. var user = await _getUser(token);
  688. if (!user) return _fail(response, 401, 'invalid session');
  689. try {
  690. if (act === 'registerFile') return await opRegisterFile(user, response);
  691. if (act === 'listBySession') return await opListBySession(user, response);
  692. if (act === 'listByUrl') return await opListByUrl(user, response);
  693. if (act === 'listByAgent') return await opListByAgent(user, response);
  694. /* v0.2.0(2026-11-11):群隔离 */
  695. if (act === 'listByGroup') return await opListByGroup(user, response);
  696. if (act === 'claimToGroup') return await opClaimToGroup(user, response);
  697. return _fail(response, 400, 'unknown action: ' + act);
  698. } catch (e) {
  699. /*
  700. * Parse 的异常对象字符串化是 `[object Object]`,直接丢出去排查不了。
  701. * 新函数上线初期必须能看到真实原因(字段不存在 / 索引缺失等)。
  702. */
  703. var msg = 'unknown';
  704. try {
  705. msg = (e && (e.message || e.error || e.code)) || String(e);
  706. if (typeof msg === 'object') msg = JSON.stringify(msg);
  707. } catch (e2) {
  708. msg = String(e);
  709. }
  710. return _fail(response, 500, String(msg));
  711. }
  712. })();
  713. }