yxh
yxh
9 天以前 09dc74e264b6262cbe41c9c8476e24705871d4a6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
import { store } from '@/store'
import { defineStore } from 'pinia'
import { CACHE_KEY, useCache } from '@/hooks/web/useCache'
import { RoomApi, RoomVO, RoomSeatResp } from "@/api/ecg/room";
import { DoctorApi } from "@/api/ecg/doctor";
import { getConfigKey } from '@/api/infra/config'
import { useUserStore } from '@/store/modules/user'
 
const { wsCache } = useCache("sessionStorage")
 
/** 参数 key:选择工位模式(与后端 Constants.ECG_ROOM_SELECT_MODE_KEY 一致) */
const ROOM_SELECT_MODE_KEY = 'ecg.room.select.mode'
 
/**
 * 选择工位模式:
 *  0 = 按需要强制选择工位(=原行为)
 *  1 = 登录IP匹配工位(匹配不到按 0 执行)
 *  2 = 登录时手动选择工位,并写入本机IP
 *  3 = 按系统默认处理(该IP未绑定过→按2选一次并记住IP;已绑定→按1自动匹配;匹配不到→按0)
 */
export type RoomSelectMode = 0 | 1 | 2 | 3
 
/** 自动匹配工位的结果,供路由守卫分支用 */
export interface AutoSeatResult {
  /** 是否已成功入座 */
  seated: boolean
  /** 后端识别到的本机IP */
  clientIp: string | null
  /**
   * 未入座原因(seated=true 时无意义):
   * - nomatch:该IP没匹配到工位
   * - occupied:匹配到但全被他人占用
   * - multi:**该IP对应多个可选工位**,无法只凭IP确定,需要人工点选
   * - ip_invalid:本机IP不可用(回环 / IPv6 / 未指定 / 非法),不能作为工位标识
   * - ip_is_server:识别到的是**服务器自身地址**(在服务器上/远程桌面里访问,或代理覆盖了客户端地址)
   * - error:接口异常或入座写库未生效
   */
  reason?: 'nomatch' | 'occupied' | 'multi' | 'ip_invalid' | 'ip_is_server' | 'error'
  /** 被占用时的占用人,便于提示 */
  occupiedBy?: string | null
  /** 【本需求】被占用时命中的候选工位(供"是否接管"确认后直接调用 takeOverBed) */
  roomId?: number | null
  bedNo?: string | null
  roomName?: string | null
}
 
interface RoomInfoVO {
  // 医生诊室选择(= 当前**查看**的工位:看自己就是自己入座的,看别人就是围观对象)
  isSetRoom: boolean
  room: RoomVO
  // 选择工位模式(-1 表示还没取到)
  roomSelectMode: number
  /**
   * 当前登录人**已入座**的工位(系统顶栏显示用;未入座为 null)。
   *
   * 与 `room` 的区别:`room` 是"我正在看哪个工位"(围观时是别人的工位),
   * 而 `currentSeat` 是"我入座在哪个工位"(服务端 clinic_room.doc_id = 我)。
   * 两者相同 → 可操作;不同 → 只读围观。
   */
  currentSeat: RoomSeatResp | null
  /**
   * 【本需求·一人多工位】当前登录人占据的**全部**工位(节假日值班多岗位)。
   *
   * 与 `currentSeat` 的区别:`currentSeat` 只是"默认/首选取"的那一个(顶栏文案用),
   * `mySeats` 才是完整集合;`getCanOperate` 用它判断"当前查看的工位是否属于我"。
   */
  mySeats: RoomSeatResp[]
  /** 当前查看工位的主人的姓名(围观时用于提示"正在围观 X(主人 张三)") */
  viewOwnerName: string | null
  /** 当前查看的工位现在是否**无人操作**(主人已离座;只提示,不自动接管) */
  viewTargetVacant: boolean
}
 
 
export const useRoomStore = defineStore('current-room', {
  state: (): RoomInfoVO => ({
    // 医生诊室选择
    isSetRoom: false,
    room: {
      id: null,
      roomId: null,
      roomName: null,
      bedNo: null,
      ip: null,
      status: null,
      docId: null,
      docName: null,
      checkTypes: null,
      opType: null
    },
    // 选择工位模式:-1 = 尚未从后端取到
    roomSelectMode: -1,
    // 当前入座的工位(顶栏显示;未入座为 null)
    currentSeat: null,
    // 【本需求·一人多工位】我占据的全部工位(未入座为空数组)
    mySeats: [],
    // 正在查看的工位的主人姓名(围观提示用)
    viewOwnerName: null,
    // 正在查看的工位现在是否无人操作(主人已离座 → 只提示,不自动接管)
    viewTargetVacant: false
  }),
  getters: {
    // 医生诊室选择
    getIsSetRoom(): boolean {
      return this.isSetRoom
    },
    getRoom(): RoomVO | null {
      return this.room
    },
    /** 当前入座的工位(可能为 null = 未入座) */
    getCurrentSeat(): RoomSeatResp | null {
      return this.currentSeat
    },
    /** 【本需求·一人多工位】我占据的全部工位 */
    getMySeats(): RoomSeatResp[] {
      return this.mySeats || []
    },
    /** 【本需求·一人多工位】我占据的工位数量(顶栏提示"我的工位 N 个") */
    getMySeatCount(): number {
      return (this.mySeats || []).length
    },
    /**
     * 【主/围观】当前是否**可以操作业务**。
     *
     * 判定(本需求改为"包含"):
     *   当前查看的工位 ∈ 我的工位列表 ⇒ 可操作(服务端另有一道硬校验:该工位 doc_id 必须是我)。
     * 一键多工位后,我不可能同时只在"一个"工位上,所以不能再用"相等"判断。
     * 兼容:`mySeats` 还没取到(旧接口/旧缓存)时回退到 `currentSeat` 相等判断。
     */
    getCanOperate(): boolean {
      const view = this.room
      if (!view || view.roomId == null || !view.bedNo) {
        return false
      }
      const seats = this.mySeats || []
      if (seats.length > 0) {
        return seats.some(
          (s) => String(s.roomId) === String(view.roomId) && String(s.bedNo) === String(view.bedNo)
        )
      }
      const seat = this.currentSeat
      if (!seat || !seat.seated) {
        return false
      }
      return String(seat.roomId) === String(view.roomId) && String(seat.bedNo) === String(view.bedNo)
    },
    /** 当前是否在**围观别人的工位**(有座但看的不是自己那座,或没座只看别人) */
    getIsViewingOther(): boolean {
      return this.isSetRoom && !this.getCanOperate
    },
    /**
     * 顶栏展示文案:`1号门诊 · A1`;未入座返回空串(由组件显示"未入座")。
     * 诊室名为空时退化为只显示工位号,避免出现 `undefined · A1`。
     */
    getSeatText(): string {
      const seat = this.currentSeat
      if (!seat || !seat.seated) return ''
      const name = seat.roomName || `诊室${seat.roomId ?? ''}`
      return seat.bedNo ? `${name} · ${seat.bedNo}` : name
    },
    /** 顶栏"当前查看的工位"文案(围观时用它,而不是我自己入座的工位) */
    getViewText(): string {
      const view = this.room
      if (!view || view.roomId == null || !view.bedNo) return ''
      const name = view.roomName || `诊室${view.roomId}`
      return `${name} · ${view.bedNo}`
    }
  },
  actions: {
    // 医生入座
    async setRoomInfoAction(room: RoomVO) {
      // 更新 store
      this.room!.id = room.id
      this.room!.roomId = room.roomId
      this.room!.roomName = room.roomName
      this.room!.bedNo = room.bedNo
      this.room!.status = room.status
      this.room!.docId = room.docId
      this.room!.docName = room.docName
      this.room!.checkTypes = room.checkTypes
      this.room!.opType = room.opType
      this.isSetRoom = true
      // 【主/围观】这条路径都是"我入座的工位"(入座 / 恢复我的工位 / 自动入座 / 选工位页回填),
      // 因此把 currentSeat 一起设上 —— 否则 getCanOperate 会误判为"无座只读"。
      this.currentSeat = {
        seated: true,
        id: room.id ?? null,
        roomId: room.roomId ?? null,
        roomName: room.roomName ?? null,
        bedNo: room.bedNo ?? null,
        ip: room.ip ?? null,
        status: room.status ?? null,
        docId: room.docId ?? null,
        docName: room.docName ?? null,
        checkTypes: room.checkTypes ?? null,
        opType: room.opType ?? null
      } as RoomSeatResp
      this.viewOwnerName = room.docName ?? null
      this.viewTargetVacant = false
 
      // 【本需求·一人多工位】把该工位并入「我的工位」(已存在则更新,不存在则新增)
      this.upsertMySeat(this.currentSeat)
 
      // 【修复】写入缓存(sessionStorage)。
      //
      // 原实现是 `const bedInfo = wsCache.get(...); if (bedInfo) { ...; wsCache.set(...) }`
      // —— **只在缓存已存在时才更新,而全项目没有任何地方首次写入**,
      // 于是 ROOM 缓存从未被创建,`room` 只活在内存里:
      //   · 刷新页面 / 新开标签页 / 从会话恢复后,`isSetRoom` 又是初始的 false;
      //   · 而各医生页面(Routine/index/DevInstall)只在 `isSetRoom === true` 时
      //     才启动取数定时器 ⇒ **页面一片空白,看起来像"没加载排队病人"**;
      //   · 角色为 doctor 的用户还会被路由守卫弹回 /roomselect 重新选诊室。
      // 这里改为**无条件写入**;恢复见文件末尾的 setupRoomStorePersistence()。
      wsCache.set(CACHE_KEY.ROOM, {
        isSetRoom: true,
        room: this.room,
        currentSeat: this.currentSeat,
        mySeats: this.mySeats
      })
    },
    /** 【本需求·一人多工位】把一条工位并入 mySeats(按 roomId+bedNo 去重) */
    upsertMySeat(seat: RoomSeatResp | null) {
      if (!seat || seat.roomId == null || !seat.bedNo) return
      const list = (this.mySeats || []).filter(
        (s) => !(String(s.roomId) === String(seat.roomId) && String(s.bedNo) === String(seat.bedNo))
      )
      list.push(seat)
      this.mySeats = list
    },
    /** 【本需求·一人多工位】用后端返回的完整列表替换 mySeats,并同步 currentSeat */
    applyMySeats(seats: RoomSeatResp[]) {
      this.mySeats = Array.isArray(seats) ? seats : []
      if (this.mySeats.length === 0) {
        this.currentSeat = null
        return
      }
      // currentSeat:优先取"当前查看的工位"对应的那条,否则第一条
      const view = this.room
      const matched = this.mySeats.find(
        (s) =>
          null != view &&
          String(s.roomId) === String(view.roomId) &&
          String(s.bedNo) === String(view.bedNo)
      )
      this.currentSeat = matched ?? this.mySeats[0]
    },
    /**
     * 【主/围观】把"我正在看的工位"切到别人(或切回自己)——**不改我的入座工位**。
     *
     * 围观就是靠这个动作实现的:`room`(看谁)与 `currentSeat`(我坐哪)分离,
     * 两者不同时 {@link getCanOperate} 为 false → 界面只读,服务端另有一道硬校验。
     *
     * @param bed       要查看的工位(来自工位列表)
     * @param ownerName 该工位当前主人的姓名(无主时传 null)
     */
    async setViewTargetAction(bed: RoomVO, ownerName?: string | null) {
      this.room!.id = bed.id ?? null
      this.room!.roomId = bed.roomId ?? null
      this.room!.roomName = bed.roomName ?? null
      this.room!.bedNo = bed.bedNo ?? null
      this.room!.ip = bed.ip ?? null
      this.room!.status = bed.status ?? null
      this.room!.docId = bed.docId ?? null
      this.room!.docName = bed.docName ?? null
      this.room!.checkTypes = bed.checkTypes ?? null
      this.room!.opType = bed.opType ?? null
      this.isSetRoom = true
      this.viewOwnerName = ownerName ?? bed.docName ?? null
      this.viewTargetVacant = bed.docId == null
      wsCache.set(CACHE_KEY.ROOM, {
        isSetRoom: true,
        room: this.room,
        currentSeat: this.currentSeat,
        mySeats: this.mySeats
      })
    },
    /**
     * 【主/围观】刷新"我正在看的工位"的最新状态(用于发现主人已离座)。
     *
     * 只更新 docId/docName 与 vacant 标记,不改变"我在看哪个工位"。
     * 按确认口径:主人离座后**只提示、不自动接管**。
     */
    refreshViewTargetState(bed: RoomVO) {
      if (!this.room || String(this.room.roomId) !== String(bed.roomId) || this.room.bedNo !== bed.bedNo) {
        return
      }
      this.room.docId = bed.docId ?? null
      this.room.docName = bed.docName ?? null
      this.viewOwnerName = bed.docName ?? null
      this.viewTargetVacant = bed.docId == null
    },
    // 医生离座
    async clearRoomInfoAction() {
      // 清 store
      this.room.id = null
      this.room.roomId = null
      this.room.roomName = null
      this.room.bedNo = null
      this.room.status = null
      this.room.docId = null
      this.room.docName = null
 
      this.isSetRoom = false
      // 顶栏标签同步清空(离座后显示"未入座")
      this.currentSeat = null
      // 【本需求·一人多工位】离座后 mySeats 一并清空
      this.mySeats = []
      this.viewOwnerName = null
      this.viewTargetVacant = false
 
      // 清缓存(与上面的写入对应,避免下次启动把已离座的诊室恢复出来)
      wsCache.delete(CACHE_KEY.ROOM)
    },
    /**
     * 【修复】应用启动时从 sessionStorage 恢复「医生已选诊室」。
     *
     * 为什么需要:`isSetRoom` 是内存态,刷新即丢;而各医生页面都靠它决定是否取数。
     * 恢复时同时校验诊室信息完整(roomId + bedNo),避免脏缓存指向不存在的工位。
     */
    restoreRoomInfo() {
      if (this.isSetRoom && this.room?.roomId != null) {
        return // 内存里已有,无需恢复
      }
      const cached = wsCache.get(CACHE_KEY.ROOM)
      if (cached?.isSetRoom && cached?.room?.roomId != null && cached?.room?.bedNo != null) {
        this.room = { ...this.room, ...cached.room }
        this.isSetRoom = true
        // 【主/围观】连"我入座的工位"一起恢复:否则刷新后 getCanOperate 会误判为只读
        // 【本需求·一人多工位】优先恢复完整列表;旧缓存没有 mySeats 时用 currentSeat 兜底
        if (Array.isArray(cached?.mySeats) && cached.mySeats.length > 0) {
          this.mySeats = cached.mySeats
        } else if (cached?.currentSeat) {
          this.mySeats = [cached.currentSeat]
        }
        if (cached?.currentSeat) {
          this.currentSeat = cached.currentSeat
          this.viewOwnerName = cached.currentSeat.docName ?? null
          // ⚠️【本次修复】**不把"围观对象"带到下一次打开**:
          // 缓存里的 room 若与我入座的工位不是同一个,说明上次在围观别人。
          // 若照原样恢复,刷新后工作台会一直显示**别人工位的队列**(看着像"患者列表空了"),
          // 而医生以为在看自己的工位 —— 现场反馈的"列表整个是空的"很可能就是这个。
          // 围观是"当前会话里的临时选择",刷新/重开一律回到我自己的工位。
          const seat = cached.currentSeat
          const cachedIsMine =
            String(cached.room.roomId) === String(seat.roomId) && cached.room.bedNo === seat.bedNo
          if (!cachedIsMine) {
            this.room = {
              ...this.room,
              id: seat.id ?? null,
              roomId: seat.roomId ?? null,
              roomName: seat.roomName ?? null,
              bedNo: seat.bedNo ?? null,
              ip: seat.ip ?? null,
              status: seat.status ?? null,
              docId: seat.docId ?? null,
              docName: seat.docName ?? null,
              checkTypes: seat.checkTypes ?? null,
              opType: seat.opType ?? null
            }
            this.viewOwnerName = seat.docName ?? null
            this.viewTargetVacant = false
            console.info('[room] 上次在围观其他工位,本次打开回到我自己的工位', this.room)
          }
        }
      }
    },
 
    /* ==================== 选择工位模式(0/1/2/3) ==================== */
 
    /** 读取「选择工位模式」参数:会话内只取一次;取不到或非法一律按 0(原行为),避免影响存量部署 */
    async loadRoomSelectMode(force = false): Promise<number> {
      if (!force && this.roomSelectMode >= 0) {
        return this.roomSelectMode
      }
      let mode = 0
      try {
        const v = await getConfigKey(ROOM_SELECT_MODE_KEY)
        const n = Number(v)
        if ([0, 1, 2, 3].includes(n)) {
          mode = n
        }
      } catch (e) {
        mode = 0
      }
      this.roomSelectMode = mode
      return mode
    },
 
    /**
     * 模式 1/3:按本机IP自动匹配并自动入座。
     *
     * 【本次修复】改为**调用后端一个接口**(`POST /clinic/room/auto-seat`)完成
     * 「匹配 → 判定 → 落座」,不再由前端拼 `getIpBed → bindIpToBed → bedDoctorOn` 三步:
     * 原来任一步失败都只能回落"手选工位",现场表现就是"登录后没有自动入座"且看不出原因。
     * 现在后端直接返回 `reason`(ip_invalid / nomatch / multi / occupied / error)与识别到的 IP。
     *
     * 匹配策略(后端实现,与原前端逻辑一致):
     * · 已经是我的工位      → 幂等恢复(刷新/重进/上次没正常离座都走这条);
     * · 空闲候选**恰好 1 个** → 入座(服务端同时保证"一个用户只占一个工位");
     * · 空闲候选**多个**     → 不擅自入座(reason='multi'),交人工点选;
     * · 全被他人占用        → reason='occupied' + 占用人姓名(**不挤掉**已在操作的人)。
     */
    async tryAutoSeatByIp(): Promise<AutoSeatResult> {
      try {
        const resp: any = (await RoomApi.autoSeat()) || {}
        const clientIp: string | null = resp.clientIp ?? null
        if (resp.seated) {
          await this.setRoomInfoAction({
            id: resp.id ?? null,
            roomId: resp.roomId ?? null,
            roomName: resp.roomName ?? null,
            bedNo: resp.bedNo ?? null,
            ip: resp.ip ?? null,
            status: resp.status ?? null,
            docId: resp.docId ?? null,
            docName: resp.docName ?? null,
            checkTypes: resp.checkTypes ?? null,
            opType: resp.opType ?? null
          } as RoomVO)
          // 顶栏"当前工位"标签用
          this.currentSeat = resp as RoomSeatResp
          // 【本需求·一人多工位】把该工位并入我的工位列表
          this.upsertMySeat(this.currentSeat)
          console.info('[room] 按IP自动入座成功', resp)
          return { seated: true, clientIp }
        }
        console.info('[room] 按IP自动入座未成功', resp)
        return {
          seated: false,
          clientIp,
          reason: (resp.reason || 'nomatch') as AutoSeatResult['reason'],
          occupiedBy: resp.ownerName ?? resp.docName ?? null,
          // 【本需求】被占用时后端会带回候选工位信息,供"是否接管"确认后直接调用
          roomId: resp.roomId ?? null,
          bedNo: resp.bedNo ?? null,
          roomName: resp.roomName ?? null
        }
      } catch (e) {
        console.error('[tryAutoSeatByIp] 自动入座接口异常', e)
        return { seated: false, clientIp: null, reason: 'error' }
      }
    },
 
    /**
     * 查询并记录"当前登录人已入座的工位"(系统顶栏显示用)。
     *
     * 场景:刷新页面 / 新开标签页 / 直接进系统,内存里的 `currentSeat` 可能是空的,
     * 但后端知道我是哪个工位的主人 —— 查一次就能让顶栏与各页面口径一致。
     *
     * 【主/围观】注意:**只有在我还没选"要看的工位"、或我看的就是自己工位时**,
     * 才把查看目标也对齐到我的工位;否则会把正在围观的对象覆盖掉(围观就没法用了)。
     */
    async fetchMySeat(): Promise<RoomSeatResp | null> {
      try {
        // 【本需求·一人多工位】优先取"我的全部工位";后端未升级(404)时回退单值接口
        let seats: RoomSeatResp[] = []
        let fallbackSingle: any = null
        try {
          const list: any = await RoomApi.getMySeats()
          seats = Array.isArray(list) ? (list as RoomSeatResp[]) : []
        } catch (e) {
          console.warn('[fetchMySeat] /my-seats 不可用,回退 /my-seat', e)
          const resp: any = (await RoomApi.getMySeat()) || {}
          if (resp.seated) {
            fallbackSingle = resp
            seats = [resp as RoomSeatResp]
          }
        }
 
        if (seats.length === 0 && !fallbackSingle) {
          this.mySeats = []
          this.currentSeat = null
          return null
        }
 
        this.applyMySeats(seats)
 
        const noViewTarget = !this.isSetRoom || this.room.roomId == null || !this.room.bedNo
        const viewingMine = !noViewTarget && this.getCanOperate
        if (!noViewTarget && !viewingMine) {
          // 正在围观别人 → 只更新"我的工位列表",不动查看目标
          console.info('[room] 已刷新我的工位列表(当前正在围观他人,不切换查看目标)', seats)
          return this.currentSeat
        }
 
        // 未选查看目标 / 看的就是自己的某个工位 → 对齐到该工位(优先当前查看的那个)
        const target = this.currentSeat ?? seats[0]
        if (target) {
          await this.setRoomInfoAction({
            id: target.id ?? null,
            roomId: target.roomId ?? null,
            roomName: target.roomName ?? null,
            bedNo: target.bedNo ?? null,
            ip: target.ip ?? null,
            status: target.status ?? null,
            docId: target.docId ?? null,
            docName: target.docName ?? null,
            checkTypes: target.checkTypes ?? null,
            opType: target.opType ?? null
          } as RoomVO)
        }
        console.info('[room] 查询到我的工位列表', seats)
        return this.currentSeat
      } catch (e) {
        console.error('[fetchMySeat] 查询当前工位失败', e)
        return null
      }
    },
 
    /**
     * 【本需求·接班自助接管】把指定工位从"别人占用"改到我名下,并切换到该工位。
     *
     * @returns 是否接管成功
     */
    async takeOverBed(roomId: number | null, bedNo: string | null): Promise<boolean> {
      if (roomId == null || !bedNo) return false
      try {
        await RoomApi.takeOverBed({ roomId, bedNo })
        // 刷新"我的工位"(此时后端已把该工位 doc_id 设为我)
        await this.fetchMySeat()
        // 切换到该工位(若是刚接管、且不在列表里,则手动补一条并切过去)
        let seat = (this.mySeats || []).find(
          (s) => String(s.roomId) === String(roomId) && String(s.bedNo) === String(bedNo)
        )
        if (!seat) {
          const userStore = useUserStore()
          const curUser: any = userStore.getUser || {}
          seat = {
            seated: true,
            roomId,
            bedNo,
            roomName: this.room?.roomName ?? null,
            docId: curUser.id ?? null,
            docName: curUser.nickname ?? null
          } as RoomSeatResp
          this.mySeats = [...(this.mySeats || []), seat]
        }
        await this.setRoomInfoAction({
          id: seat.id ?? null,
          roomId: seat.roomId ?? null,
          roomName: seat.roomName ?? null,
          bedNo: seat.bedNo ?? null,
          ip: seat.ip ?? null,
          status: seat.status ?? null,
          docId: seat.docId ?? null,
          docName: seat.docName ?? null,
          checkTypes: seat.checkTypes ?? null,
          opType: seat.opType ?? null
        } as RoomVO)
        console.info('[room] 接管工位成功', roomId, bedNo)
        return true
      } catch (e) {
        console.error('[takeOverBed] 接管工位失败', e)
        return false
      }
    },
 
    /**
     * 入座(bed-doctor-on)+ 写入会话。抽出来给「手动选择」和「按IP自动匹配」共用。
     * @returns 是否入座成功
     */
    async seatRoom(bed: Partial<RoomVO>): Promise<boolean> {
      const userStore = useUserStore()
      const curUser: any = userStore.getUser || {}
      const tempRoomVO: RoomVO = {
        id: bed.id ?? null,
        roomId: bed.roomId ?? null,
        roomName: bed.roomName ?? null,
        bedNo: bed.bedNo ?? null,
        ip: bed.ip ?? null,
        status: bed.status ?? null,
        docId: curUser.id ?? null,
        docName: curUser.nickname ?? null,
        checkTypes: bed.checkTypes ?? null,
        opType: bed.opType ?? null
      }
      const data = await DoctorApi.bedDoctorOn(tempRoomVO)
      if (data !== 0) {
        console.warn('[seatRoom] bedDoctorOn 返回非 0:', data)
        return false
      }
      await this.setRoomInfoAction(tempRoomVO)
      // 【本需求·一人多工位】入座后刷新"我的全部工位"(可能已有多个)
      await this.fetchMySeat()
      return true
    },
 
    /**
     * 模式 2/3:把本机IP写到指定工位。
     * @returns { code, conflict, msg } —— code=409 表示该IP已绑在别的工位(conflict=true),需确认后带 force 重调
     */
    async bindCurrentIp(bedId: number, force = false): Promise<any> {
      const resp: any = await RoomApi.bindIpToBed(bedId, force)
      return resp || {}
    }
  }
})
 
export const useRoomStoreWithOut = () => {
  return useRoomStore(store)
}
 
/**
 * 在应用启动阶段调用一次(见 src/main.ts),把「已选诊室」从 sessionStorage 恢复到 store。
 *
 * 必须早于路由守卫与各医生页面的 onMounted,否则页面会因为 isSetRoom=false 而完全不取数。
 */
export const setupRoomStorePersistence = () => {
  useRoomStoreWithOut().restoreRoomInfo()
}