~yxh/ecg.git - Gitblit

			@@ -194,6 +194,67 @@
			return GlobalErrorCodeConstants.SUCCESS;
			}

			// ==================== 需求3：停止候诊开关 ====================

			/**
			* 设置「停止候诊」开关。
			* <p>
			* {@code stop=true}：该工位不再新增候诊患者（移出分流队列），
			* 但已有候诊患者仍可正常叫号（{@code nextPatient} 不检查此开关）。
			* <p>
			* {@code stop=false}：恢复正常，重新加入分流队列开始接收患者
			* （前提是工位状态为"医生在座"，与 {@code bedReload} 的判定一致）。
			* <p>
			* 状态写入 {@code clinic_room.stop_ready}，以在 {@code bedReload} 后保持。
			*
			* @return 成功返回 SUCCESS；工位不存在返回 {@link #QUEUE_BED_NOT_EXIST}
			*/
			public ErrorCode setStopReady(Long roomId, String bedNo, boolean stop) {
			BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
			if (null == bedBO) {
			log.error("[setStopReady] 工位不存在. roomId={} bedNo={}", roomId, bedNo);
			return QUEUE_BED_NOT_EXIST;
			}

			// 先落库（失败则不改内存，避免状态不一致）
			//
			// 【部署保护】若数据库尚未执行升级脚本（缺 clinic_room.stop_ready 列），
			// roomMapper.setBedStopReady(...) 会在 Mapper 层直接抛 SQL 异常
			// （@Update 注解方法没有返回值可判断，异常直接冒泡）。
			// 这里显式捕获并转成明确的业务错误码，避免把原始 SQL 错误暴露给前端，
			// 便于现场一眼看出是"部署遗漏"而不是"功能坏了"。
			Integer updateNum;
			try {
			updateNum = roomMapper.setBedStopReady(roomId, bedNo, stop ? 1 : 0);
			} catch (Exception e) {
			log.error("[setStopReady] 写库失败，请确认已执行 _prep/11_需求升级_汇总SQL.sql"
			+ "（clinic_room.stop_ready）. roomId={} bedNo={}", roomId, bedNo, e);
			return QUEUE_STOP_READY_NOT_CONFIGURED;
			}
			if (null == updateNum \|\| 0 == updateNum) {
			// 工位可能尚未在 clinic_room 登记，仅告警但仍允许改内存，
			// 以免因 DB 记录缺失导致医生完全无法使用该功能。
			log.warn("[setStopReady] DB 未更新到行，仅更新内存. roomId={} bedNo={} stop={}", roomId, bedNo, stop);
			}

			bedBO.setStopReady(stop);

			// 同步分流队列：停止 → 移出；恢复 → 加入（仅在医生在座时）
			if (stop) {
			removeBedFromRoutingQueue(bedBO);
			} else if (BedStatusEnum.DOCTOR_ON.getStatus().equals(bedBO.getStatus())) {
			addBedToRoutingQueue(bedBO);
			}
			log.info("[setStopReady] roomId={} bedNo={} stopReady={}", roomId, bedNo, stop);
			return GlobalErrorCodeConstants.SUCCESS;
			}

			/** 查询当前「停止候诊」状态（工位不存在返回 null） */
			public Boolean getStopReady(Long roomId, String bedNo) {
			BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
			return null == bedBO ? null : Boolean.TRUE.equals(bedBO.getStopReady());
			}

			public ErrorCode bedDoctorOn(Long roomId, String bedNo, Long docId, String docName) {
			BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
			if (null == bedBO) {
			@@ -325,7 +386,12 @@

			bedBOList.forEach(item -> {
			mapOpeningBed.put( Utils.formatRoomBed(item.roomId, item.bedNo), item);
			if (BedStatusEnum.DOCTOR_ON.getStatus() == item.getStatus()) {
			// 【需求3】「停止候诊」的工位不加入分流队列 —— 与医生在座(status=DOCTOR_ON)同样判定，
			// 否则每次 bedReload（开诊/重启/诊室重置）后开关会失效、又开始收病人。
			// 注意：stopReady 仅阻止新增候诊患者，已有候诊患者仍可正常叫号
			// （nextPatient 不检查该开关）。
			if (BedStatusEnum.DOCTOR_ON.getStatus() == item.getStatus()
			&& !Boolean.TRUE.equals(item.getStopReady())) {
			addBedToRoutingQueue(item);
			}
			});
			@@ -367,8 +433,13 @@

			BedBO bedBO = getBedQueueBO(roomId, bedNo);

			// 【需求3】「停止候诊」时不再把【已召回】患者放入候诊区。
			// 注意：这不影响已有候诊患者被正常叫号（nextPatient 不检查本开关），
			// 也不影响医生对具体患者的"召回"操作本身（只影响其自动进入候诊的补位）。
			boolean stopReady = Boolean.TRUE.equals(bedBO.getStopReady());

			// 处理过号-回来的人
			while (bedBO.getReadyPatNum() < bedBO.getMaxReadyPatNum()) {
			while (!stopReady && bedBO.getReadyPatNum() < bedBO.getMaxReadyPatNum()) {
			// 查看当前工位是否有过号-回来的患者
			Integer updateNum = queueMapper.queueRecalledPatient(
			bedBO.getRoomId(),
			@@ -410,6 +481,12 @@
			*/
			public void hurryupOneCheckType(Integer checkType) {

			// 【修复既有缺陷】补上开诊门闸。原实现唯独这里漏了 openingFlag 检查
			// （hurryupAllBed 与 hurryupOneBed 都有），导致手动"闭诊"后，
			// 只要有人预约确认 / 加急，患者仍会被推进候诊区。
			if (0 == openingFlag.get())
			return;

			PriorityBlockingQueue<BedBO> routingQueue = mapCheckTypeRoutingQueue.get(checkType);
			if (null == routingQueue)
			return;
			@@ -418,6 +495,18 @@
			BedBO bedBO = routingQueue.peek();
			if (null == bedBO)
			return;

			// 【需求3】跳过处于「停止候诊」的工位。
			// 不能直接 return —— 该队列按 readyPatNum 升序 peek，
			// 直接 return 会让其余工位也收不到患者（饿死）。
			// 这里 poll 出来后若命中停止态，仅将其从队列移除（不再 offer 回去），
			// 然后 continue 处理下一个工位。
			if (Boolean.TRUE.equals(bedBO.getStopReady())) {
			routingQueue.poll();
			log.info("[hurryupOneCheckType] 工位[停止候诊]，移出分流队列. roomId={} bedNo={}",
			bedBO.getRoomId(), bedBO.getBedNo());
			continue;
			}

			int curQueueNum = bedBO.getReadyPatNum();
			if (curQueueNum > bedBO.getMaxReadyPatNum())
			@@ -495,6 +584,11 @@
			}

			private void hurryupOneBedCheckTypeList(BedBO bedBO) {
			// 【需求3】「停止候诊」的工位不再新增候诊患者。
			// 已有候诊患者仍可正常叫号（本方法只负责"补齐候诊"，不参与叫号）。
			if (Boolean.TRUE.equals(bedBO.getStopReady())) {
			return;
			}
			while (bedBO.getReadyPatNum() < bedBO.getMaxReadyPatNum()) {
			// 抢占是否有排队中的患者
			Integer updateNum = queueMapper.preemptWaitingPatientWithBedCheckTypes(
			@@ -575,6 +669,18 @@
			if (Objects.equals(BedOpTypeEnum.OP_INSTALL.getOpType(), bedBO.getOpType()))
			return;

			// 【需求3】「停止候诊」的工位不进分流队列。
			// 这是唯一入口的统一门闸：只要工位被标记为停止候诊，
			// 无论从哪条路径（开诊 addBedToRoutingQueue、医生恢复、bedReload、
			// 或手动恢复开关）试图加入，都会被拒绝，从而保证：
			// · 已有候诊患者仍可正常叫号（nextPatient 不检查该开关）
			// · 但不会再被分配【排队中】的新患者
			if (Boolean.TRUE.equals(bedBO.getStopReady())) {
			log.info("[addBedToRoutingQueue] 工位处于[停止候诊]，跳过加入分流队列. roomId={} bedNo={}",
			bedBO.getRoomId(), bedBO.getBedNo());
			return;
			}

			// 同步DB, 设置工位的分流控制信息
			List<Integer> queueStatusList = new ArrayList<>();
			queueStatusList.add(QueueStatusEnum.READY.getStatus()); //[候诊中]
			@@ -636,6 +742,7 @@
			for (int i = 0; i < affinityItems.size(); i++) {
			QueueDO queueItem = affinityItems.get(i);
			queueItem.setStatus(QueueStatusEnum.AFFINITY_INSTALL.getStatus()); //改变排队状态
			queueItem.setAffinityItem(1);
			queueItem.setRoomId(roomId_operator);
			queueItem.setBedNo(bedNo_operator); // 跟随到装机工位
			queueMapper.updateById(queueItem);