From 68ff33beff11310e830b0615b5a81f83fad0f683 Mon Sep 17 00:00:00 2001
From: yxh <172933527@qq.com>
Date: 星期日, 08 十一月 2026 23:33:14 +0800
Subject: [PATCH] ai优化
---
jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java | 1021 ++++++++++++++++++++++++++++++++++++++++++++------------
1 files changed, 794 insertions(+), 227 deletions(-)
diff --git a/jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java b/jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java
index 10399ac..575ddc0 100644
--- a/jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java
+++ b/jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java
@@ -7,13 +7,13 @@
import cn.lihu.jh.module.ecg.controller.admin.room.vo.MonitorInfoVO;
import cn.lihu.jh.module.ecg.dal.dataobject.checktype.CheckTypeDO;
import cn.lihu.jh.module.ecg.dal.dataobject.queue.QueueDO;
-import cn.lihu.jh.module.ecg.dal.dataobject.queue.QueueStatisticDO;
import cn.lihu.jh.module.ecg.dal.dataobject.room.RoomDO;
import cn.lihu.jh.module.ecg.dal.mysql.call.CallMapper;
import cn.lihu.jh.module.ecg.dal.mysql.checktype.CheckTypeMapper;
import cn.lihu.jh.module.ecg.dal.mysql.devrent.DevRentMapper;
import cn.lihu.jh.module.ecg.dal.mysql.queue.QueueMapper;
import cn.lihu.jh.module.ecg.dal.mysql.room.RoomMapper;
+import cn.lihu.jh.module.ecg.enums.BedOpTypeEnum;
import cn.lihu.jh.module.ecg.enums.BedStatusEnum;
import cn.lihu.jh.module.ecg.enums.QueueStatusEnum;
import cn.lihu.jh.module.infra.api.config.ConfigApi;
@@ -65,16 +65,17 @@
AtomicInteger openingFlag = new AtomicInteger(0);
- AtomicInteger curSeqNum = new AtomicInteger(0);
- ConcurrentHashMap<String, BedQueueBO > mapBedVsQueue = new ConcurrentHashMap<>();
+ // 銆愬彿缁熶竴锛堟湰闇�姹傦級銆戝師 curSeqNum锛堝垎娴佹椂缁欐偅鑰呯紪"鍐呴儴搴忓彿"鐨勫唴瀛樿鏁板櫒锛夊凡鍒犻櫎銆�
+ // 鎺掗槦鍙锋敼涓虹鍒版椂涓�娆℃�у啓鍏� queue.seq_num锛屼箣鍚庝换浣曠幆鑺傞兘涓嶅啀璧嬪彿锛�
+ // 鍒嗘祦銆佸彨鍙峰悗琛ラ綈鍊欒瘖銆佽繃鍙枫�佸彫鍥炪�佸姞鎬ャ�佽鏈洪兘鍙敼鐘舵��/璇婂/宸ヤ綅銆�
- // 瑁呮満宸ヤ綅..涓嶈繘鍏ヤ紭鍏堥槦鍒�
- Map<Integer, PriorityBlockingQueue<BedQueueBO>> mapCheckTypePriorityQueue = new HashMap();
+ // 缁存姢 寮�鏀剧殑宸ヤ綅
+ ConcurrentHashMap<String, BedBO> mapOpeningBed = new ConcurrentHashMap<>();
- // 鍩轰簬绫诲瀷鐨�, 瑁呮満鍑嗗鐨勪紭鍏堥槦鍒�
- // Map<Integer, PriorityBlockingQueue<BedQueueBO>> mapReadyPriorityQueue = new HashMap();
-
+ // 瑁呮満宸ヤ綅..涓嶈繘鍏ュ垎娴侀槦鍒�
+ ConcurrentHashMap<Integer, PriorityBlockingQueue<BedBO>> mapCheckTypeRoutingQueue = new ConcurrentHashMap<>();
+
Map<Integer, CheckTypeDO> mapCheckTypeVsReadyMax = null;
/**
@@ -84,8 +85,8 @@
* @return
*/
public ErrorCode bedOpen(Long roomId, String roomName, String bedNo) {
- BedQueueBO bedQueueBO2 = mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
- if (null != bedQueueBO2) {
+ BedBO bedBO2 = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
+ if (null != bedBO2) {
log.error("bedOpen mapBedVsQueue has existed. " + roomId + " " + bedNo);
return QUEUE_BED_EXIST;
}
@@ -99,41 +100,39 @@
return ROOM_INVALID_STATUS;
}
- List<Integer> queueStatusList = new ArrayList<>();
- queueStatusList.add(QueueStatusEnum.READY.getStatus());
- List<QueueDO> queueDOList = queueMapper.getBedQueueByStatus(roomId, bedNo, queueStatusList);
-
RoomDO roomDO = roomMapper.getRoom(roomId, bedNo);
// 鏂板..宸ヤ綅闃熷垪
- BedQueueBO bedQueueBO = new BedQueueBO();
- bedQueueBO.setRoomId(roomId);
- bedQueueBO.setRoomName(roomName);
- bedQueueBO.setBedNo(bedNo);
- bedQueueBO.setMaxQueueNum(getBedReadyMax(roomId, bedNo));
- bedQueueBO.setQueueNum(new AtomicInteger(queueDOList.size()));
- bedQueueBO.setStatus(BedStatusEnum.OPENING.getStatus());
- bedQueueBO.setCheckTypes( roomDO.getCheckTypes() );
- bedQueueBO.setOpType( roomDO.getOpType() );
- mapBedVsQueue.put( Utils.formatRoomBed(roomId, bedNo), bedQueueBO);
+ BedBO bedBO = new BedBO();
+ bedBO.setRoomId(roomId);
+ bedBO.setRoomName(roomName);
+ bedBO.setBedNo(bedNo);
+ bedBO.setStatus(BedStatusEnum.OPENING.getStatus());
+ bedBO.setCheckTypes( roomDO.getCheckTypes() );
+ bedBO.setOpType( roomDO.getOpType() );
+ mapOpeningBed.put( Utils.formatRoomBed(roomId, bedNo), bedBO);
return GlobalErrorCodeConstants.SUCCESS;
}
public ErrorCode bedClose(Long roomId, String bedNo) {
- BedQueueBO bedQueueBO = mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
- if (null == bedQueueBO) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
+ if (null == bedBO) {
log.error("bedClose mapBedVsQueue DONOT existed. " + roomId + " " + bedNo);
return QUEUE_BED_NOT_EXIST;
}
- // 闄や簡鍒ゆ柇 鍑嗗鍊欒瘖涓� 鐨勪汉鏁帮紝杩橀渶瑕� 鍒ゆ柇 杩囧彿鐨勪汉鏁�
- //if (bedQueueBO.getQueueNum().get() >0)
- // return QUEUE_HAVE_PATIENT;
+ // 妫�鏌ユ槸鍚﹁繕鏈夋偅鑰呴渶瑕佸鐞�
List<Integer> queueStatusList = new ArrayList<>();
queueStatusList.add(QueueStatusEnum.READY.getStatus());
+ queueStatusList.add(QueueStatusEnum.ONSTAGE.getStatus());
+ queueStatusList.add(QueueStatusEnum.INSTALLING.getStatus());
queueStatusList.add(QueueStatusEnum.PASSED.getStatus());
+ queueStatusList.add(QueueStatusEnum.PASSED_INSTALL.getStatus());
queueStatusList.add(QueueStatusEnum.RECALLED.getStatus());
+ queueStatusList.add(QueueStatusEnum.RECALLED_INSTALL.getStatus());
+ queueStatusList.add(QueueStatusEnum.AFFINITY.getStatus());
+ queueStatusList.add(QueueStatusEnum.AFFINITY_INSTALL.getStatus());
List<QueueDO> queueDOList = queueMapper.getBedQueueByStatus(roomId, bedNo, queueStatusList);
if (queueDOList.size() > 0)
return QUEUE_HAVE_PATIENT;
@@ -142,7 +141,7 @@
List statusList = new ArrayList<BedStatusEnum>();
statusList.add(BedStatusEnum.OPENING);
statusList.add(BedStatusEnum.DOCTOR_ON);
- statusList.add(BedStatusEnum.PAUSE);
+ statusList.add(BedStatusEnum.DOCTOR_PAUSE);
Integer updateNum = roomMapper.setBedOpeningClosed(roomId, bedNo,
BedStatusEnum.CLOSED, statusList);
if ( null==updateNum || 0 == updateNum ) {
@@ -150,14 +149,14 @@
return ROOM_INVALID_STATUS;
}
- mapBedVsQueue.remove( Utils.formatRoomBed(roomId, bedNo) );
- removePriorityQueue(bedQueueBO);
+ mapOpeningBed.remove( Utils.formatRoomBed(roomId, bedNo) );
+ removeBedFromRoutingQueue(bedBO);
return GlobalErrorCodeConstants.SUCCESS;
}
public ErrorCode bedDoctorPause(Long roomId, String bedNo, Long docId, String docName) {
- BedQueueBO bedQueueBO = mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
- if (null == bedQueueBO) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
+ if (null == bedBO) {
log.error("bedDoctorPause mapBedVsQueue DONOT existed. " + roomId + " " + bedNo);
return QUEUE_BED_NOT_EXIST;
}
@@ -165,27 +164,27 @@
// DB update
List statusList = new ArrayList<BedStatusEnum>();
statusList.add(BedStatusEnum.DOCTOR_ON);
- Integer updateNum = roomMapper.setBedDoctorStatus(roomId, bedNo, docId, BedStatusEnum.PAUSE, statusList);
+ Integer updateNum = roomMapper.setBedDoctorStatus(roomId, bedNo, docId, BedStatusEnum.DOCTOR_PAUSE, statusList);
if ( null==updateNum || 0 == updateNum ) {
log.error("bedDoctorPause DB invalid status. " + roomId + " " + bedNo);
return ROOM_INVALID_STATUS;
}
- bedQueueBO.setStatus(BedStatusEnum.PAUSE.getStatus());
- removePriorityQueue(bedQueueBO);
+ bedBO.setStatus(BedStatusEnum.DOCTOR_PAUSE.getStatus());
+ removeBedFromRoutingQueue(bedBO);
return GlobalErrorCodeConstants.SUCCESS;
}
public ErrorCode bedDoctorResume(Long roomId, String bedNo, Long docId, String docName) {
- BedQueueBO bedQueueBO = mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
- if (null == bedQueueBO || !bedQueueBO.getStatus().equals(BedStatusEnum.PAUSE.getStatus())) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
+ if (null == bedBO || !bedBO.getStatus().equals(BedStatusEnum.DOCTOR_PAUSE.getStatus())) {
log.error("bedDoctorResume mapBedVsQueue DONOT existed OR NOT Paused. " + roomId + " " + bedNo);
return QUEUE_BED_NOT_EXIST;
}
// DB update
List statusList = new ArrayList<BedStatusEnum>();
- statusList.add(BedStatusEnum.PAUSE);
+ statusList.add(BedStatusEnum.DOCTOR_PAUSE);
Integer updateNum = roomMapper.setBedDoctorStatus(roomId, bedNo, docId,
BedStatusEnum.DOCTOR_ON, statusList);
if ( null==updateNum || 0 == updateNum ) {
@@ -193,35 +192,222 @@
return ROOM_INVALID_STATUS;
}
- bedQueueBO.setStatus(BedStatusEnum.DOCTOR_ON.getStatus());
- addPriorityQueue(bedQueueBO);
+ bedBO.setStatus(BedStatusEnum.DOCTOR_ON.getStatus());
+ addBedToRoutingQueue(bedBO);
return GlobalErrorCodeConstants.SUCCESS;
}
- public ErrorCode bedDoctorOn(Long roomId, String bedNo, Long docId, String docName) {
- BedQueueBO bedQueueBO = mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
- if (null == bedQueueBO) {
+ // ==================== 闇�姹�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_闇�姹傚崌绾姹囨�籗QL.sql"
+ + "锛坈linic_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());
+ }
+
+ /**
+ * 鍏ュ骇锛堟妸宸ヤ綅涓讳汉璁句负鎴戯級銆�
+ *
+ * @param bedId 宸ヤ綅涓婚敭锛堝墠绔姹傞噷甯︼紱**浼樺厛鎸夊畠瀹氫綅**锛岃涓嬶級鈥斺�斿彲涓虹┖锛屼负绌烘椂鎸� roomId+bedNo 瀹氫綅
+ */
+ public ErrorCode bedDoctorOn(Long roomId, String bedNo, Long docId, String docName, Integer bedId) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
+ if (null == bedBO) {
log.error("bedDoctorOn mapBedVsQueue DONOT existed. " + roomId + " " + bedNo);
return QUEUE_BED_NOT_EXIST;
}
- // DB update
- List statusList = new ArrayList<BedStatusEnum>();
- statusList.add(BedStatusEnum.OPENING);
- Integer updateNum = roomMapper.setBedDoctorOn(roomId, bedNo, docId, docName, BedStatusEnum.DOCTOR_ON, statusList);
+ // 鍙互"鎴愪负涓讳汉"鐨勭姸鎬侊細宸插紑閫� / 鏈夊尰鐢� / 鏆傚仠锛�**鎺掗櫎"宸插叧闂�"**锛夈��
+ // 銆愭湰娆℃斁瀹姐�戝師鏉�"鏃犱富浜�"鏃跺彧璁�"宸插紑閫�"锛氫竴鏃︽暟鎹嚭鐜�"doc_id 涓虹┖浣嗙姸鎬佷粛鏄湁鍖荤敓/鏆傚仠"
+ // 杩欑涓嶄竴鑷达紝鍖荤敓绔欏湪宸ヤ綅鍓嶅嵈濮嬬粓鍧愪笉涓婏紝鍙姤"鐘舵�佸紓甯�"锛岀幇鍦烘棤浠庡鐞嗐��
+ List<BedStatusEnum> claimableStatusList = new ArrayList<>();
+ claimableStatusList.add(BedStatusEnum.OPENING);
+ claimableStatusList.add(BedStatusEnum.DOCTOR_ON);
+ claimableStatusList.add(BedStatusEnum.DOCTOR_PAUSE);
+
+ // 銆愭湰娆′慨澶嶃�戜紭鍏堟寜**涓婚敭**鏇存柊锛氱幇鍦哄嚭鐜拌繃"宸ヤ綅鍦ㄥ簱閲屾槑鏄庣┖闂层�佸叆搴у嵈鏇存柊 0 琛�"锛�
+ // 宸叉帓闄�"琚崰鐢�"锛涘墿涓嬬殑鍙兘鏄� bed_no 涓庤姹傚�兼湁鑲夌溂闅捐鲸鐨勫樊寮�
+ // 锛堢粨灏剧┖鏍� / 澶у皬鍐� / 鍏ㄨ锛孞SON 涓庡鍒剁矘璐撮兘鐪嬩笉鍑烘潵锛夈�傚墠绔湰鏉ュ氨甯� id锛岀敤瀹冩渶绋炽��
+ Integer updateNum = null;
+ if (null != bedId) {
+ updateNum = roomMapper.setBedDoctorOnById(bedId, docId, docName,
+ BedStatusEnum.DOCTOR_ON, claimableStatusList);
+ if (null != updateNum && updateNum > 0) {
+ // 鏍￠獙涓�涓� id 鎸囧悜鐨勮纭疄灏辨槸璇锋眰鐨勫伐浣嶏紙涓嶄竴鑷磋鏄庡墠绔紦瀛樹笌搴撲笉鍚屾锛岃鏃ュ織渚夸簬鎺掓煡锛�
+ RoomDO seatRow = roomMapper.getRoom(roomId, bedNo);
+ RoomDO idRow = roomMapper.selectById(bedId);
+ if (null != idRow && null != seatRow && !idRow.getId().equals(seatRow.getId())) {
+ log.warn("[bedDoctorOn] 鎸� id 鍏ュ骇鎴愬姛锛屼絾 id 鎸囧悜鐨勫伐浣嶄笌璇锋眰鐨� roomId/bedNo 涓嶆槸鍚屼竴琛岋紒"
+ + " id={} 鈫� {}/{}, 璇锋眰 鈫� {}/{}",
+ bedId, idRow.getRoomId(), idRow.getBedNo(), roomId, bedNo);
+ }
+ }
+ }
+ if (null == updateNum || 0 == updateNum) {
+ // 鍥為��锛氭寜 roomId + bedNo 瀹氫綅锛堝吋瀹逛笉甯� id 鐨勮皟鐢ㄦ柟锛屽鑷姩鍏ュ骇鐨勮�佽矾寰勶級
+ updateNum = roomMapper.setBedDoctorOn(roomId, bedNo, docId, docName,
+ BedStatusEnum.DOCTOR_ON, claimableStatusList);
+ }
+
if ( null==updateNum || 0 == updateNum ) {
- log.error("bedDoctorOn DB invalid status. " + roomId + " " + bedNo);
+ // 浠嶅け璐� 鈫� 鎶婂簱閲�**鐪熷疄鐘舵��**鎽婂紑锛屽苟鍖哄垎鍘熷洜锛堝師鏉ヤ竴寰�"鐘舵�佸紓甯�"锛岀幇鍦虹湅涓嶅嚭鎵�浠ョ劧锛�
+ RoomDO rowById = (null == bedId) ? null : roomMapper.selectById(bedId);
+ RoomDO rowByRoomBed = roomMapper.getRoom(roomId, bedNo);
+ log.warn("[bedDoctorOn] 鍏ュ骇鏇存柊 0 琛�. 璇锋眰 roomId={} bedNo=[{}] bedId={} docId={}锛�"
+ + "鎸塱d鏌ュ埌={} 鎸塺oomId+bedNo鏌ュ埌={}",
+ roomId, bedNo, bedId, docId,
+ null == rowById ? "鏃�" : describeBedRow(rowById),
+ null == rowByRoomBed ? "鏃�" : describeBedRow(rowByRoomBed));
+
+ RoomDO occupant = (null != rowById) ? rowById : rowByRoomBed;
+ if (null != occupant && null != occupant.getDocId() && !occupant.getDocId().equals(docId)) {
+ log.warn("[bedDoctorOn] 宸ヤ綅宸茶浠栦汉鍗犵敤锛屾嫆缁濆叆搴э紙涓嶆尋鎺夛級. 鍗犵敤浜�={}({})",
+ occupant.getDocName(), occupant.getDocId());
+ return ROOM_OCCUPIED_BY_OTHER;
+ }
return ROOM_INVALID_STATUS;
}
- bedQueueBO.setStatus(BedStatusEnum.DOCTOR_ON.getStatus());
- addPriorityQueue(bedQueueBO);
+ // 銆愭湰闇�姹偮蜂竴浜哄宸ヤ綅銆戝叆搴ф垚鍔熷悗**涓嶅啀閲婃斁**璇ュ尰鐢熺殑鍏跺畠宸ヤ綅锛�
+ // 鑺傚亣鏃ュ�肩彮鏃朵竴浣嶅尰鐢熷彲鑳藉悓鏃跺崰銆屾鏌ュ伐浣� + 棰嗙敤宸ヤ綅 + 瑁呮満宸ヤ綅銆嶏紝
+ // 鐢卞墠绔�屾垜鐨勫伐浣嶃�嶄笅鎷夊湪鍚勫伐浣嶉棿鍒囨崲锛堝啓鎿嶄綔浠嶇敱 @RequireBedOwner 鎸夊伐浣� doc_id 鏍￠獙锛夈��
+ // 鍘熷疄鐜帮細roomMapper.releaseOtherBedsOfDoc(docId, roomId, bedNo, BedStatusEnum.OPENING);
+ // 宸ヤ綅閲婃斁鏀逛负涓夌鏄庣‘閫斿緞锛氣憼 鍖荤敓鐐广�岀搴с�嶏紱鈶� 闂瘖缁熶竴娓呯┖锛涒憿 绠＄悊鍛樸�屾竻绌哄伐浣嶃��/鎺ョ彮鍖荤敓銆屾帴绠°�嶃��
+
+ bedBO.setStatus(BedStatusEnum.DOCTOR_ON.getStatus());
+ addBedToRoutingQueue(bedBO);
return GlobalErrorCodeConstants.SUCCESS;
}
+ /**
+ * 鎵嬪伐鎶婃煇浣嶃�屾帓闃熶腑銆嶆偅鑰呮媺鍏ユ寚瀹氬伐浣嶏紙宸ヤ綔鍙�"鏈瘖瀹ゆ帓闃熶腑锛堟湭鍒嗛厤锛�"鍒嗗尯鐨勩�屾媺鍏ャ�嶆寜閽級銆�
+ *
+ * <p>涓庤嚜鍔ㄥ垎娴侊紙{@code hurryupOneCheckType}锛夎蛋**鍚屼竴濂�**鍔ㄤ綔锛�
+ * 鏉′欢鏇存柊銆屾帓闃熶腑(10) 鈫� 鍑嗗涓�(20)銆嶅苟鎶� room/bed 鍐欐垚鏈伐浣嶏紝鐒跺悗澶勭悊浜插拰椤广��
+ * 鍙蜂笉鍙橈紙鍙峰湪绛惧埌鏃跺凡瀹氾級銆�
+ *
+ * <p>涓夐噸鏍￠獙锛氬伐浣嶅瓨鍦� 鈫� 璇ヨ浠嶆槸銆屾帓闃熶腑銆嶁啋 妫�鏌ラ」鐩湪鏈伐浣嶅紑灞曡寖鍥村唴銆�
+ * 鏉′欢鏇存柊鑷甫骞跺彂淇濇姢锛氫袱涓伐浣嶅悓鏃剁偣銆屾媺鍏ャ�嶏紝鍙湁涓�涓兘鎴愬姛銆�
+ */
+ public ErrorCode pullWaitingPatient(Long roomId, String bedNo, Integer queueId) {
+ RoomDO bed = (null == roomId || null == bedNo) ? null : roomMapper.getRoom(roomId, bedNo);
+ if (null == bed) {
+ log.warn("[pullWaitingPatient] 宸ヤ綅涓嶅瓨鍦�. roomId={} bedNo={}", roomId, bedNo);
+ return QUEUE_BED_NOT_EXIST;
+ }
+
+ QueueDO item = (null == queueId) ? null : queueMapper.selectById(queueId);
+ if (null == item) {
+ log.warn("[pullWaitingPatient] 鎺掗槦琛屼笉瀛樺湪. queueId={}", queueId);
+ return QUEUE_NOT_EXISTS;
+ }
+ if (!QueueStatusEnum.WAITING.getStatus().equals(item.getStatus())) {
+ log.warn("[pullWaitingPatient] 璇ユ偅鑰呭凡涓嶅湪鎺掗槦涓�. queueId={} patId={} status={}",
+ queueId, item.getPatId(), item.getStatus());
+ return QUEUE_NOT_WAITING;
+ }
+ Integer[] bedCheckTypes = bed.getCheckTypes();
+ if (null == bedCheckTypes || 0 == bedCheckTypes.length
+ || null == item.getBookCheckType()
+ || !java.util.Arrays.asList(bedCheckTypes).contains(item.getBookCheckType())) {
+ log.warn("[pullWaitingPatient] 妫�鏌ラ」鐩笉鍦ㄦ湰宸ヤ綅鑼冨洿. queueId={} checkType={} 鏈伐浣�={}",
+ queueId, null == item ? null : item.getBookCheckType(), java.util.Arrays.toString(bedCheckTypes));
+ return QUEUE_CHECK_TYPE_NOT_MATCH;
+ }
+
+ Integer updateNum = queueMapper.preemptWaitingPatientById(queueId, roomId, bed.getRoomName(), bedNo,
+ QueueStatusEnum.WAITING.getStatus(), QueueStatusEnum.READY.getStatus());
+ if (null == updateNum || 0 == updateNum) {
+ log.warn("[pullWaitingPatient] 鎷夊叆鏈敓鏁堬紙宸茶鍏朵粬宸ヤ綅鎷夎蛋锛�. queueId={}", queueId);
+ return QUEUE_NOT_WAITING;
+ }
+
+ // 鍐呭瓨瀵硅薄涓庡簱鍐呬繚鎸佷竴鑷达紙浜插拰椤硅璺熼殢涓婚」鐨勮瘖瀹�/宸ヤ綅锛�
+ item.setStatus(QueueStatusEnum.READY.getStatus());
+ item.setRoomId(roomId);
+ item.setRoomName(bed.getRoomName());
+ item.setBedNo(bedNo);
+
+ try {
+ CheckTypeDO checkTypeDO = getCheckTypeItem(item.getBookCheckType());
+ if (null != checkTypeDO && null != checkTypeDO.getAffinityCheckTypes()
+ && checkTypeDO.getAffinityCheckTypes().length > 0) {
+ procAffinityWhenPreempt(item, checkTypeDO.getAffinityCheckTypes());
+ }
+ } catch (Exception e) {
+ // 浜插拰椤瑰鐞嗗け璐ヤ笉褰卞搷涓婚」宸叉垚鍔熸媺鍏�
+ log.error("[pullWaitingPatient] 浜插拰椤瑰鐞嗗け璐ワ紙涓婚」宸叉媺鍏ワ級. queueId={}", queueId, e);
+ }
+
+ log.info("[pullWaitingPatient] 宸叉墜宸ユ媺鍏�. roomId={} bedNo={} queueId={} patId={} seqNum={}",
+ roomId, bedNo, queueId, item.getPatId(), item.getSeqNum());
+ return GlobalErrorCodeConstants.SUCCESS;
+ }
+
+ /** 鎷间竴琛屽伐浣嶅叧閿瓧娈碉紝渚涙棩蹇�/鎺掓煡蹇�熷姣旓紙灏ゅ叾鐪� bed_no 鏄惁涓庤姹備竴鑷达級 */
+ private String describeBedRow(RoomDO row) {
+ return String.format("id=%s,room_id=%s,bed_no=[%s](len=%d),status=%s,doc_id=%s,doc_name=%s",
+ row.getId(), row.getRoomId(), row.getBedNo(),
+ null == row.getBedNo() ? -1 : row.getBedNo().length(),
+ row.getStatus(), row.getDocId(), row.getDocName());
+ }
+
public ErrorCode bedDoctorOff(Long roomId, String bedNo, Long docId, String docName) {
- BedQueueBO bedQueueBO = mapBedVsQueue.get( Utils.formatRoomBed( roomId, bedNo ) );
- if (null == bedQueueBO) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed( roomId, bedNo ) );
+ if (null == bedBO) {
log.error("bedDoctorOff mapBedVsQueue DONOT existed. " + roomId + " " + bedNo);
return QUEUE_BED_NOT_EXIST;
}
@@ -229,94 +415,202 @@
// DB update
List statusList = new ArrayList<BedStatusEnum>();
statusList.add(BedStatusEnum.DOCTOR_ON);
- statusList.add(BedStatusEnum.PAUSE);
+ statusList.add(BedStatusEnum.DOCTOR_PAUSE);
Integer updateNum = roomMapper.setBedDoctorOff(roomId, bedNo, docId, BedStatusEnum.OPENING, statusList);
if ( null==updateNum || 0 == updateNum ) {
log.error("bedDoctorOff DB invalid status. " + roomId + " " + bedNo);
return ROOM_INVALID_STATUS;
}
- removePriorityQueue(bedQueueBO);
+ removeBedFromRoutingQueue(bedBO);
- bedQueueBO.setStatus(BedStatusEnum.OPENING.getStatus());
+ bedBO.setStatus(BedStatusEnum.OPENING.getStatus());
return GlobalErrorCodeConstants.SUCCESS;
+ }
+
+ /**
+ * 銆愭湰娆￠渶姹傘�戠鐞嗗憳寮哄埗娓呯┖宸ヤ綅锛堜笉瑕佹眰鏄湰浜猴級銆�
+ * <p>
+ * 涓� {@link #bedDoctorOff} 鐨勫尯鍒細涓嶆竻 {@code doc_id=?} 鏉′欢锛�
+ * 鍥犳鍙妸銆屽埆浜哄崰鐢ㄤ腑銆嶇殑宸ヤ綅娓呮帀 鈥斺�� 鐢ㄤ簬鍖荤敓涓嬬彮蹇樼搴с�佹崲浜轰娇鐢ㄥ悓涓�宸ヤ綅鐨勫満鏅��
+ * 浠嶇劧鍙竻銆屽尰鐢熷湪宀� / 鏆傚仠銆嶄笖 doc_id 闈炵┖鐨勫伐浣嶏紝绌洪棽宸ヤ綅涓嶄細琚鍔ㄣ��
+ */
+ public ErrorCode bedDoctorOffByAdmin(Long roomId, String bedNo) {
+ BedBO bedBO = mapOpeningBed.get( Utils.formatRoomBed( roomId, bedNo ) );
+ if (null == bedBO) {
+ log.error("bedDoctorOffByAdmin mapBedVsQueue DONOT existed. " + roomId + " " + bedNo);
+ return QUEUE_BED_NOT_EXIST;
+ }
+
+ List statusList = new ArrayList<BedStatusEnum>();
+ statusList.add(BedStatusEnum.DOCTOR_ON);
+ statusList.add(BedStatusEnum.DOCTOR_PAUSE);
+ Integer updateNum = roomMapper.setBedDoctorOffAdmin(roomId, bedNo, BedStatusEnum.OPENING, statusList);
+ if ( null==updateNum || 0 == updateNum ) {
+ log.error("bedDoctorOffByAdmin DB invalid status. " + roomId + " " + bedNo);
+ return ROOM_INVALID_STATUS;
+ }
+
+ removeBedFromRoutingQueue(bedBO);
+
+ bedBO.setStatus(BedStatusEnum.OPENING.getStatus());
+ log.info("[绠＄悊鍛樻竻绌哄伐浣峕 roomId={} bedNo={} 宸茬疆涓虹┖闂�", roomId, bedNo);
+ return GlobalErrorCodeConstants.SUCCESS;
+ }
+
+ /**
+ * 銆愭湰娆￠渶姹傘�戦棴璇婃竻绌猴細鎶婃墍鏈夈�屽尰鐢熷湪宀� / 鏆傚仠銆嶇殑宸ヤ綅缃负绌洪棽锛坉oc_id / doc_name 娓呯┖锛夈��
+ * <p>
+ * 涓� {@link #closeBiz()} 閰嶅悎锛氬厛娓呭簱锛岄殢鍚� {@code startBedReload()} 浼氭寜搴撻噸鏂拌杞藉唴瀛橈紝
+ * 淇濊瘉鍐呭瓨锛坢apOpeningBed / 鍒嗘祦闃熷垪锛変笌搴撲竴鑷淬��
+ *
+ * @return 娓呯┖鐨勫伐浣嶆暟
+ */
+ public int closeBizClearBeds() {
+ List statusList = new ArrayList<BedStatusEnum>();
+ statusList.add(BedStatusEnum.DOCTOR_ON);
+ statusList.add(BedStatusEnum.DOCTOR_PAUSE);
+ Integer updateNum = roomMapper.clearAllBedDoctors(BedStatusEnum.OPENING, statusList);
+
+ // 鍐呭瓨鍚屾锛氭妸宸ヤ綅鐘舵�佹敼鍥炵┖闂诧紝骞朵粠鍒嗘祦闃熷垪鎽橀櫎锛堥伩鍏嶉棴璇婂悗浠嶆湁宸ヤ綅琚淳鎮ｈ�咃級
+ // 娉ㄦ剰锛歴tatus 鏄� Integer 鍖呰绫诲瀷锛屽繀椤荤敤 equals 姣旇緝锛�== 鍙湪 -128~127 缂撳瓨鍖洪棿鍐呭伓鐒舵垚绔嬶級
+ for (BedBO bedBO : mapOpeningBed.values()) {
+ if (Objects.equals(BedStatusEnum.DOCTOR_ON.getStatus(), bedBO.getStatus())
+ || Objects.equals(BedStatusEnum.DOCTOR_PAUSE.getStatus(), bedBO.getStatus())) {
+ removeBedFromRoutingQueue(bedBO);
+ bedBO.setStatus(BedStatusEnum.OPENING.getStatus());
+ }
+ }
+ log.info("[闂瘖] 宸叉竻绌哄綋鐝伐浣� {} 涓紙doc_id / doc_name 缃┖锛岀姸鎬佹敼涓虹┖闂诧級",
+ updateNum == null ? 0 : updateNum);
+ return updateNum == null ? 0 : updateNum;
}
/* 2024.11.11
// 甯歌 鎴栬�� 棰嗙敤 鏃� 鍖荤敓 鍙栦笅涓�浣嶆偅鑰�
public ErrorCode nextPatient(Long roomId, String bedNo) {
- // 浠� DB 鎶婅宸ヤ綅.搴忓彿鏈�灏忕殑 [灏辫瘖鍑嗗涓璢 鐨勪汉 璁剧疆涓� [灏辫瘖涓璢 (鎴栭鐢ㄤ腑)
+ // 浠� DB 鎶婅宸ヤ綅.搴忓彿鏈�灏忕殑 [鍊欒瘖涓腑] 鐨勪汉 璁剧疆涓� [灏辫瘖涓璢 (鎴栭鐢ㄤ腑)
Integer updateNum = queueMapper.updateBedQueueStatus(roomId, bedNo,
QueueStatusEnum.READY.getStatus(), QueueStatusEnum.ONSTAGE.getStatus());
- // 璇ュ伐浣� 娌℃湁 [灏辫瘖鍑嗗涓璢 浜哄憳
+ // 璇ュ伐浣� 娌℃湁 [鍊欒瘖涓腑] 浜哄憳
if (null == updateNum || 0 == updateNum) {
return QUEUE_NOT_READY_PATIENT;
}
- // 浼樺厛闃熷垪涓� 璇ュ伐浣� 灏辫瘖鍑嗗涓汉鐨勬暟閲� 鍑忎竴
+ // 鍒嗘祦闃熷垪涓� 璇ュ伐浣� 鍊欒瘖涓腑浜虹殑鏁伴噺 鍑忎竴
BedQueueBO bo = mapBedVsQueue.get( Utils.formatRoomBed( roomId, bedNo ) );
bo.queueNum.getAndDecrement(); // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 hurry-up 涓敼鍙樹簡鍊�
- refreshPriorityQueue(bo);
+ refreshRoutingQueue(bo);
return GlobalErrorCodeConstants.SUCCESS;
}
*/
// 甯歌 鎴栬�� 棰嗙敤 鏃� 鍖荤敓 鍙栦笅涓�浣嶆偅鑰�
public ErrorCode nextPatient(Long roomId, String bedNo) {
- QueueDO firstReadyQueueItem = queueMapper.getFirstItemByBedAndStatus(roomId, bedNo, QueueStatusEnum.READY.getStatus());
- // 璇ュ伐浣� 娌℃湁 [灏辫瘖鍑嗗涓璢 浜哄憳
- if (null == firstReadyQueueItem) {
+ // 鈸� 銆愬苟鍙戝姞鍥郝锋湰闇�姹傘�戞湰宸ヤ綅**宸叉湁銆屽氨璇婁腑(30)銆嶆偅鑰呮椂涓嶅啀鍙笅涓�浣�**銆�
+ //
+ // 鍘熷厛杩欎釜鍒ゆ柇鍙湪 `QueueServiceImpl#finishNextPatient` 閲屽仛杩囷紝鑰屽畠浣嶄簬
+ // singleThreadExecutor 涓茶鍖�**涔嬪**锛氫袱涓苟鍙戣姹傦紙鍙屽嚮 / 澶氱锛夐兘鍙兘璇诲埌 0锛�
+ // 闅忓悗鍚勮嚜鎻愪氦涓�娆� nextPatient锛屼覆琛屾墽琛屾椂浼氬悇鎺ㄨ繘涓�鏉� READY 鈬�
+ // 鍚屼竴宸ヤ綅鍑虹幇 2 涓�屽氨璇婁腑銆嶏紝鎮ｈ�呰"鍗�"鍦ㄥ氨璇婁腑銆佸伐浣嶄篃涓嶅啀琛ヤ汉銆�
+ // 杩欓噷鍦ㄤ覆琛屽尯鍐呭啀鍒や竴娆★紙鏈柟娉曞彧鐢辫涓茶绾跨▼姹犺皟鐢級銆�
+ List<Integer> onstageStatusList = new ArrayList<>();
+ onstageStatusList.add(QueueStatusEnum.ONSTAGE.getStatus());
+ Integer onstageNum = queueMapper.bedQueueStatisticByStatus(roomId, bedNo, onstageStatusList);
+ if (null != onstageNum && onstageNum > 0) {
+ log.warn("[nextPatient] 鏈伐浣嶅凡鏈� {} 涓�屽氨璇婁腑銆嶆偅鑰咃紝璺宠繃鏈鍙彿锛堥槻骞跺彂鍙屽氨璇婁腑锛�. 宸ヤ綅={}/{}",
+ onstageNum, roomId, bedNo);
+ return GlobalErrorCodeConstants.SUCCESS;
+ }
+
+ // 鈶� 鍊欒瘖涓�(20) 浼樺厛
+ QueueDO firstQueueItem = queueMapper.getBedFirstQueueItemByStatus(
+ roomId, bedNo, QueueStatusEnum.READY.getStatus());
+ boolean fromRecalled = false;
+
+ // 鈶� 鍊欒瘖鍖烘病浜烘椂锛屽洖閫�鍙栥�屽凡鍙洖(15)銆嶉噷鍙锋渶灏忕殑涓�浣�
+ //
+ // 銆愮己闄蜂慨澶嶃�戣繃鍙锋偅鑰�"鍙洖"鍚庝細鍏堢疆涓� RECALLED(15)锛屽啀闈� hurryupOneBed 鐨勮ˉ浜哄惊鐜�
+ // 鎻愬崌鎴� READY(20)銆備絾琛ヤ汉寰幆鏈変笁閬撻棬闂革紙openingFlag=0 / stopReady=true / 鍊欒瘖鍖哄凡婊★級锛�
+ // 浠讳竴鏉℃垚绔嬫偅鑰呭氨**涓�鐩村仠鍦� 15**锛涜�屽彨鍙锋鍓嶅彧璁� READY 鈬� 鍑虹幇姝荤粨锛�
+ // 鐜板満琛ㄧ幇涓�"鎺掗槦鍙� A2/A3 鐘舵�佹槸宸插彫鍥烇紝鐐瑰彨鍙峰姞杞戒笉鍑烘偅鑰呬俊鎭紝鏃犳硶妫�鏌�"锛�2026-10-29 鍙嶉锛夈��
+ // 杩欓噷鎸変笌 nextInstallPatient锛堝凡鍚� RECALLED_INSTALL锛変竴鑷寸殑鎬濊矾鐩存帴鍙埌锛�
+ // 涓嶅啀渚濊禆琛ヤ汉鏄惁鎴愬姛銆�
+ if (null == firstQueueItem) {
+ firstQueueItem = queueMapper.getBedFirstQueueItemByStatus(
+ roomId, bedNo, QueueStatusEnum.RECALLED.getStatus());
+ fromRecalled = null != firstQueueItem;
+ if (fromRecalled) {
+ log.info("[nextPatient] 鍊欒瘖鍖烘棤浜猴紝鏀瑰彨銆屽凡鍙洖銆嶆偅鑰�. 宸ヤ綅={}/{} patId={} seqNum={}",
+ roomId, bedNo, firstQueueItem.getPatId(), firstQueueItem.getSeqNum());
+ }
+ }
+
+ // 璇ュ伐浣嶆棦娌℃湁 [鍊欒瘖涓璢 涔熸病鏈� [宸插彫鍥瀅 浜哄憳
+ if (null == firstQueueItem) {
return QUEUE_NOT_READY_PATIENT;
}
- // QueueStatusEnum.READY => QueueStatusEnum.ONSTAGE
- firstReadyQueueItem.setStatus(QueueStatusEnum.ONSTAGE.getStatus());
- queueMapper.updateById( firstReadyQueueItem );
+ // 鈶� READY / RECALLED => ONSTAGE锛氱敤銆屼富閿� + 褰撳墠鐘舵�併�嶆潯浠舵洿鏂帮紙骞跺彂鍔犲浐锛夛紝
+ // 0 琛岃鏄庤琛屽凡琚彟涓�璇锋眰鎺ㄨ繘锛屾湰娆℃斁寮冿紙涓嬫鍐嶅彇锛夈��
+ int curStatus = fromRecalled
+ ? QueueStatusEnum.RECALLED.getStatus() : QueueStatusEnum.READY.getStatus();
+ Integer updated = queueMapper.updateStatusByIdIfCurrent(
+ firstQueueItem.getId(), curStatus, QueueStatusEnum.ONSTAGE.getStatus());
+ if (null == updated || 0 == updated) {
+ log.warn("[nextPatient] 鍊欒瘖琛屽凡琚苟鍙戞帹杩涳紝鏀惧純鏈鍙彿. 宸ヤ綅={}/{} queueId={} 鏈熸湜鐘舵��={}",
+ roomId, bedNo, firstQueueItem.getId(), curStatus);
+ return QUEUE_NOT_READY_PATIENT;
+ }
+ firstQueueItem.setStatus(QueueStatusEnum.ONSTAGE.getStatus());
- // 浼樺厛闃熷垪涓� 璇ュ伐浣� 灏辫瘖鍑嗗涓汉鐨勬暟閲� 鍑忎竴
- BedQueueBO bo = mapBedVsQueue.get( Utils.formatRoomBed( roomId, bedNo ) );
- bo.queueNum.getAndDecrement(); // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 hurry-up 涓敼鍙樹簡鍊�
-
- refreshPriorityQueue(bo);
+ // 鍒嗘祦闃熷垪涓� 璇ュ伐浣� 銆愬�欒瘖涓�戞偅鑰呮暟閲� 鍑忎竴
+ // 娉ㄦ剰锛氬彫鍥炵殑杩欎綅鏈潵灏变笉鍦ㄥ�欒瘖璁℃暟閲岋紝涓嶈兘鍑忥紱鍙﹀ bo 鍙兘涓� null锛堝伐浣嶄笉鍦ㄥ紑璇婂垪琛級锛�
+ // 鍘熷疄鐜扮洿鎺� bo.readyPatNum-- 浼� NPE銆�
+ BedBO bo = mapOpeningBed.get(Utils.formatRoomBed(roomId, bedNo));
+ if (null != bo) {
+ if (!fromRecalled) {
+ bo.readyPatNum--; // 鍙兘宸茬粡鍦� hurry-up 涓敼鍙樹簡鍊�
+ }
+ refreshBedPriorityLevelInRoutingQueue(bo);
+ } else {
+ log.warn("[nextPatient] 宸ヤ綅涓嶅湪寮�璇婂垪琛紝璺宠繃鍐呭瓨璁℃暟涓庡垎娴佸埛鏂�. 宸ヤ綅={}/{}", roomId, bedNo);
+ }
return GlobalErrorCodeConstants.SUCCESS;
}
// 瑁呮満鏃� 鍖荤敓 鍙栦笅涓�浣嶆偅鑰�
public ErrorCode nextInstallPatient(Long roomId, String bedNo) {
// 浠� DB 鎶� 搴忓彿鏈�灏忕殑 [宸查鐢╙ [宸插彫鍥�-瀹夎] 鐨勪汉 璁剧疆涓� [瀹夎涓璢
- QueueDO firstItem = queueMapper.getFirstItemByRoomAndStatus(roomId, List.of(QueueStatusEnum.RECEIVED.getStatus(), QueueStatusEnum.RECALLED_INSTALL.getStatus()));
+ QueueDO firstItem = queueMapper.getRoomFirstQueueItemByStatus(roomId, List.of(QueueStatusEnum.RECEIVED.getStatus(), QueueStatusEnum.RECALLED_INSTALL.getStatus()));
// 璇ュ伐浣� 娌℃湁 [宸查鐢╙ | [宸插彫鍥�-瀹夎] 浜哄憳
if (null == firstItem) {
return QUEUE_NOT_READY_PATIENT;
}
firstItem.setStatus( QueueStatusEnum.INSTALLING.getStatus() );
- firstItem.setBedNo( bedNo );
+ firstItem.setBedNo( bedNo ); // 杞埌 瀹夎宸ヤ綅
queueMapper.updateById( firstItem );
- // 妫�鏌ラ」鐩�.浜插拰鎬� 澶勭悊閫昏緫
+ // 妫�鏌ラ」鐩�.浜插拰鎬� 澶勭悊閫昏緫: 鍙樹负銆愬畨瑁呬腑銆戝悗 鎷� 鍏朵粬妫�鏌ラ」鏉ヤ翰鍜�
CheckTypeDO checkTypeDO = getCheckTypeItem( firstItem.getBookCheckType() );
if (checkTypeDO.getAffinityCheckTypes().length > 0) {
procAffinityWhenSomeOneEntryInstalling(firstItem.getPatId(), roomId, bedNo, checkTypeDO.getAffinityCheckTypes() );
}
- // 瑁呮満宸ヤ綅 鏃犱紭鍏堥槦鍒�
- // 浼樺厛闃熷垪涓� 璇ュ伐浣� [宸查鐢╙浜虹殑鏁伴噺 鍑忎竴
- //BedQueueBO bo = mapBedVsQueue.get( Utils.formatRoomBed( roomId, bedNo ) );
- //bo.queueNum.getAndDecrement(); // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 hurry-up 涓敼鍙樹簡鍊�
- //refreshPriorityQueue(bo);
+ // 瑁呮満宸ヤ綅 涓嶅弬涓庡垎娴�
return GlobalErrorCodeConstants.SUCCESS;
}
/**
- * 1. 姣忓ぉ寮�璇婂墠 浠嶥B鍚屾宸ヤ綅鐨勬偅鑰呴槦鍒楁暟鎹埌 宸ヤ綅浼樺厛闃熷垪
+ * 1. 姣忓ぉ寮�璇婂墠 浠嶥B鍚屾宸ヤ綅鐨勬偅鑰呴槦鍒楁暟鎹埌 宸ヤ綅鍒嗘祦闃熷垪
* 2. 鏈嶅姟杩愮淮閲嶅惎鏃�
*/
public ErrorCode bedReload() {
- mapCheckTypePriorityQueue.clear();
- mapBedVsQueue.clear();
+ mapCheckTypeRoutingQueue.clear();
+ mapOpeningBed.clear();
// 娓呴櫎闈炲綋澶╃殑鎺掗槦浜哄憳
queueMapper.clearQueue();
@@ -327,32 +621,24 @@
List<BedStatusEnum> bedStatusEnumList = new ArrayList<BedStatusEnum>();
bedStatusEnumList.add(BedStatusEnum.OPENING);
bedStatusEnumList.add(BedStatusEnum.DOCTOR_ON);
- bedStatusEnumList.add(BedStatusEnum.PAUSE);
+ bedStatusEnumList.add(BedStatusEnum.DOCTOR_PAUSE);
List<RoomDO> roomDOList = roomMapper.simpleRoomList(bedStatusEnumList);
- List<BedQueueBO> bedQueueBOList = roomDOList.stream().map(item -> BeanUtils.toBean(item, BedQueueBO.class)).toList();
+ List<BedBO> bedBOList = roomDOList.stream().map(item -> BeanUtils.toBean(item, BedBO.class)).toList();
- // 浠嶥B 鑾峰彇 闃熷垪涓� 灏辫瘖鍑嗗涓汉鍛樼粺璁� 鍒楄〃
- List<Integer> queueStatusList = new ArrayList<>();
- queueStatusList.add(QueueStatusEnum.READY.getStatus());
- List<QueueStatisticDO> queueStatisticDOList = queueMapper.queueStatistic(queueStatusList);
-
- bedQueueBOList.forEach(item -> {
- item.maxQueueNum = getBedReadyMax(item.roomId, item.bedNo);
- Optional<QueueStatisticDO> queueStatisticDOOptional = queueStatisticDOList.stream().filter(it->it.getRoomId()==item.roomId && it.getBedNo().equals(item.getBedNo())).findFirst();
- int queueNum = queueStatisticDOOptional.isPresent() ? queueStatisticDOOptional.get().getTotalInStatus() : 0;
- if ( item.maxQueueNum < queueNum )
- throw new RuntimeException("init: exceed max queue number!");
-
- item.queueNum.set( queueNum );
- mapBedVsQueue.put( Utils.formatRoomBed(item.roomId, item.bedNo), item);
- if (BedStatusEnum.DOCTOR_ON.getStatus() == item.getStatus()) {
- addPriorityQueue(item);
+ bedBOList.forEach(item -> {
+ mapOpeningBed.put( Utils.formatRoomBed(item.roomId, item.bedNo), item);
+ // 銆愰渶姹�3銆戙�屽仠姝㈠�欒瘖銆嶇殑宸ヤ綅涓嶅姞鍏ュ垎娴侀槦鍒� 鈥斺�� 涓庡尰鐢熷湪搴�(status=DOCTOR_ON)鍚屾牱鍒ゅ畾锛�
+ // 鍚﹀垯姣忔 bedReload锛堝紑璇�/閲嶅惎/璇婂閲嶇疆锛夊悗寮�鍏充細澶辨晥銆佸張寮�濮嬫敹鐥呬汉銆�
+ // 娉ㄦ剰锛歴topReady 浠呴樆姝�**鏂板**鍊欒瘖鎮ｈ�咃紝宸叉湁鍊欒瘖鎮ｈ�呬粛鍙甯稿彨鍙�
+ // 锛坣extPatient 涓嶆鏌ヨ寮�鍏筹級銆�
+ if (BedStatusEnum.DOCTOR_ON.getStatus() == item.getStatus()
+ && !Boolean.TRUE.equals(item.getStopReady())) {
+ addBedToRoutingQueue(item);
}
});
- Integer num = queueMapper.getMaxSeqNum();
- curSeqNum = new AtomicInteger(null == num ? 0 : num);
-
+ // 銆愬彿缁熶竴锛堟湰闇�姹傦級銆戜笉鍐嶅垵濮嬪寲鍐呭瓨璁℃暟鍣� curSeqNum锛�
+ // 鎺掗槦鍙锋潵鑷鍒版椂鐨� queue.seq_num锛屽垎娴佷笉鍐嶅垎閰嶅彿銆�
return GlobalErrorCodeConstants.SUCCESS;
}
@@ -361,7 +647,7 @@
// 韪㈠嚭鍦ㄥ骇鐨勫尰鐢�
List<BedStatusEnum> bedStatusEnumList = new ArrayList<BedStatusEnum>();
bedStatusEnumList.add(BedStatusEnum.DOCTOR_ON);
- bedStatusEnumList.add(BedStatusEnum.PAUSE);
+ bedStatusEnumList.add(BedStatusEnum.DOCTOR_PAUSE);
List<RoomDO> roomDOList = roomMapper.simpleRoomList(bedStatusEnumList);
List<Long> userIdList = roomDOList.stream().map(roomDO -> roomDO.getDocId()).toList();
oAuth2TokenApi.tick(userIdList);
@@ -375,92 +661,151 @@
if (0 == openingFlag.get())
return;
- mapBedVsQueue.values().forEach(bedQueueBO -> hurryupOneBed(bedQueueBO.roomId, bedQueueBO.bedNo));
+ mapOpeningBed.values().forEach(bedQueueBO -> hurryupOneBed(bedQueueBO.roomId, bedQueueBO.bedNo));
}
/**
* 鎶婂尰鐢熷�欒瘖鐨勯槦鍒楀婊�
*/
public void hurryupOneBed(Long roomId, String bedNo) {
- if (0 == openingFlag.get())
+ if (0 == openingFlag.get()) {
+ // 銆愮幇鍦烘帓鏌ャ�戞湭寮�璇婃椂**鏁翠釜鑷姩琛ヤ汉閮芥槸鍏抽棴鐨�**锛堟帓闃熶腑鐨勭梾浜轰笉浼氳鎼繘鍊欒瘖鍖猴級銆�
+ // 鍘熷疄鐜版槸闈欓粯 return锛岀幇鍦哄彧鑳界湅鍒�"浜洪兘鍦紝灏辨槸涓嶈繘鏉�"锛屾晠杩欓噷鏄庣‘璁颁竴鏉°��
+ log.warn("[琛ヤ汉] 绯荤粺鏈浜庛�愬紑璇娿�戠姸鎬侊紙openingFlag=0锛夛紝璺宠繃鑷姩琛ヤ汉. 宸ヤ綅={}/{}锛堝彲鍦ㄧ洃鎺ч〉鐐广�屽紑璇娿�嶏級",
+ roomId, bedNo);
return;
+ }
- BedQueueBO bedQueueBO = getBedQueueBO(roomId, bedNo);
+ BedBO bedBO = getBedQueueBO(roomId, bedNo);
+ if (null == bedBO) {
+ log.warn("[琛ヤ汉] 宸ヤ綅涓嶅湪銆屽凡寮�璇婂伐浣嶃�嶅垪琛ㄤ腑锛岃烦杩�. 宸ヤ綅={}/{}", roomId, bedNo);
+ return;
+ }
+
+ // 銆愭湰娆″姞鍥恒�戠敤搴撻噷鐨勭湡瀹炲�欒瘖浜烘暟鏍℃鍐呭瓨璁℃暟锛�
+ // readyPatNum 鏄唴瀛樺�硷紝鑻ユ煇鏉¤矾寰勶紙鎾ら攢/鏀惧純/杩囧彿绛夛級娌″悓姝ワ紝瀹冧細铏氶珮锛�
+ // 浜庢槸 "鍊欒瘖鍖哄凡婊�" 鐨勫垽鏂竴鐩存垚绔嬨�佹案杩滀笉琛ヤ汉锛堣�岀晫闈笂鍊欒瘖鍖哄叾瀹炴槸绌虹殑锛夈��
+ int realReadyNum = countReadyInDb(roomId, bedNo);
+ if (realReadyNum != bedBO.getReadyPatNum()) {
+ log.warn("[琛ヤ汉] 鍐呭瓨鍊欒瘖浜烘暟({}) 涓庡簱鍐�({}) 涓嶄竴鑷达紝宸叉寜搴撳唴鏍℃. 宸ヤ綅={}/{}",
+ bedBO.getReadyPatNum(), realReadyNum, roomId, bedNo);
+ bedBO.setReadyPatNum(realReadyNum);
+ }
+
+ // 銆愰渶姹�3銆戙�屽仠姝㈠�欒瘖銆嶆椂涓嶅啀鎶娿�愬凡鍙洖銆戞偅鑰呮斁鍏ュ�欒瘖鍖恒��
+ // 娉ㄦ剰锛氳繖**涓嶅奖鍝�**宸叉湁鍊欒瘖鎮ｈ�呰姝ｅ父鍙彿锛坣extPatient 涓嶆鏌ユ湰寮�鍏筹級锛�
+ // 涔熶笉褰卞搷鍖荤敓瀵瑰叿浣撴偅鑰呯殑"鍙洖"鎿嶄綔鏈韩锛堝彧褰卞搷鍏惰嚜鍔ㄨ繘鍏ュ�欒瘖鐨勮ˉ浣嶏級銆�
+ boolean stopReady = Boolean.TRUE.equals(bedBO.getStopReady());
// 澶勭悊 杩囧彿-鍥炴潵 鐨勪汉
- while (bedQueueBO.queueNum.get() < bedQueueBO.maxQueueNum) {
- // 鏌ョ湅 褰撳墠宸ヤ綅 鏄惁鏈夎繃鍙�-鍥炴潵鐨勬偅鑰�
- Integer updateNum = queueMapper.queueRecalledPatient(
- bedQueueBO.getRoomId(),
- bedQueueBO.getRoomName(),
- bedQueueBO.getBedNo(),
- curSeqNum.get() + 1, // 杩囧彿鍥炴潵锛屾帓鍒板綋鍓嶇殑涓嬩竴浣�
- QueueStatusEnum.RECALLED.getStatus(), // 涓嶉渶瑕佸鐞� [瀹夎鍙洖], 鍘熷洜: 瀹夎宸ヤ綅 娌℃湁浼樺厛闃熷垪
- QueueStatusEnum.READY.getStatus());
- if (null == updateNum || 0 == updateNum)
+ while (!stopReady && bedBO.getReadyPatNum() < bedBO.getMaxReadyPatNum()) {
+ // 鏌ョ湅 褰撳墠宸ヤ綅 鏄惁鏈夈�屽凡鍙洖(15)銆嶇殑鎮ｈ�咃紙鎺掗槦鍙锋渶灏忕殑閭ｄ竴浣嶏級
+ QueueDO recalledQueueItem = queueMapper.getBedFirstQueueItemByStatus(
+ bedBO.getRoomId(), bedBO.getBedNo(), QueueStatusEnum.RECALLED.getStatus());
+ if (null == recalledQueueItem)
break;
- // 鍙洖 [杩囧彿] 鎮ｈ�呭悗锛屽鐞� 妫�鏌ラ」鐩�.浜插拰鎬� 閫昏緫
- QueueDO recalledQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
+ // 銆愬彿缁熶竴锛堟湰闇�姹傦級銆戣繃鍙峰彫鍥�**涓嶅啀閲嶆帓闃熷彿**锛氬彿鏄鍒版椂瀹氱殑锛�
+ // 鎮ｈ�呮寜鍘熷彿鍥炲埌鍊欒瘖搴忓垪锛堥渶姹傦細銆岀梾浜鸿繃鍙蜂簡锛屼篃鎺掔潃銆嶏級銆�
+ // 鏃у疄鐜帮紙seq_num = 褰撳墠鍙�+1锛屾帓鍒伴槦灏撅級浼氳浠栦笌灞忓箷涓�/鎮ｈ�呮墜閲岀殑鍙峰涓嶄笂銆�
+ // 涓嶉渶瑕佸鐞� [瀹夎鍙洖], 鍘熷洜: 瀹夎宸ヤ綅 涓嶈繘鍏ュ垎娴侀槦鍒�
+ recalledQueueItem.setStatus(QueueStatusEnum.READY.getStatus());
+ queueMapper.updateById(recalledQueueItem);
+ // [杩囧彿] 鎮ｈ�� => [鍊欒瘖涓璢 锛屽鐞� 妫�鏌ラ」鐩�.浜插拰鎬� 閫昏緫
CheckTypeDO checkTypeDO = getCheckTypeItem( recalledQueueItem.getBookCheckType() );
if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
procAffinityWhenRecalled(recalledQueueItem, checkTypeDO.getAffinityCheckTypes());
}
- curSeqNum.getAndIncrement();
+ // 鍙兘宸茬粡鍦� nextPatient 涓敼鍙樹簡鍊�
+ bedBO.readyPatNum++;
- // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡鍊�
- bedQueueBO.queueNum.incrementAndGet();
-
- // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡浼樺厛闃熷垪椤哄簭
- refreshPriorityQueue(bedQueueBO);
+ // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡鍒嗘祦闃熷垪椤哄簭
+ refreshBedPriorityLevelInRoutingQueue(bedBO);
}
// 澶勭悊 鎺掗槦涓� 鎮ｈ��
- hurryupOneBedCheckTypeList( bedQueueBO );
+ hurryupOneBedCheckTypeList(bedBO);
}
/**
- * Deprecated 浠ｇ爜淇濈暀锛屽疄闄呭凡缁忎笉鍐嶄娇鐢�
- * 鍘熷洜: 鍚屼竴宸ヤ綅鍙互鍚屾椂澶勭悊澶氫釜妫�鏌ラ」鐩紝鎵�浠ラ渶瑕佷繚璇佸涓鏌ラ」鐩殑灏辫瘖鏃堕棿鍏堝悗椤哄簭
+ * 涓�涓伐浣嶅彲浠ユ敮鎸佸涓鏌ラ」鐩紝鎵�浠ラ渶瑕佷繚璇佸涓鏌ラ」鐩殑灏辫瘖鏃堕棿鍏堝悗椤哄簭
* 鎸夌収涓�涓鏌ラ」鐩潵澶勭悊锛屽氨涓嶈兘淇濊瘉鍚屼竴涓伐浣嶇殑澶氫釜妫�鏌ラ」鐩殑灏辫瘖鏃堕棿鐨勫厛鍚庨『搴�
+ * 鎵�浠ュ疄鐜伴�昏緫鏄� 璁╂敮鎸佽妫�鏌ラ」鐩殑鎵�鏈夊伐浣嶅幓鎶㈠崰 銆愭帓闃熶腑銆戙�愬伐浣嶆敮鎸佺殑妫�鏌ラ」鐩�戠殑鎮ｈ��
+ * 瀹為檯鎶㈠崰鐨勬湭蹇呮槸 鍙傛暟涓殑妫�鏌ラ」鐩殑鎮ｈ�咃紝鍙兘鏄叾浠栨鏌ラ」鐩殑鎮ｈ��
* @param checkType
*/
public void hurryupOneCheckType(Integer checkType) {
- PriorityBlockingQueue<BedQueueBO> priorityQueue = mapCheckTypePriorityQueue.get(checkType);
- if (null == priorityQueue)
+ // 銆愪慨澶嶆棦鏈夌己闄枫�戣ˉ涓婂紑璇婇棬闂搞�傚師瀹炵幇**鍞嫭杩欓噷婕忎簡** openingFlag 妫�鏌�
+ // 锛坔urryupAllBed 涓� hurryupOneBed 閮芥湁锛夛紝瀵艰嚧鎵嬪姩"闂瘖"鍚庯紝
+ // 鍙鏈変汉棰勭害纭 / 鍔犳�ワ紝鎮ｈ�呬粛浼氳鎺ㄨ繘鍊欒瘖鍖恒��
+ if (0 == openingFlag.get())
+ return;
+
+ PriorityBlockingQueue<BedBO> routingQueue = mapCheckTypeRoutingQueue.get(checkType);
+ if (null == routingQueue)
return;
while (true) {
- BedQueueBO bedQueueBO = priorityQueue.peek();
- if (null == bedQueueBO)
+ BedBO bedBO = routingQueue.peek();
+ if (null == bedBO)
return;
- int curQueueNum = bedQueueBO.queueNum.get();
- if (curQueueNum > bedQueueBO.maxQueueNum)
+ // 銆愰渶姹�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())
throw new RuntimeException("hurryupOneCheckType: exceed max queue number!");
- if (curQueueNum == bedQueueBO.maxQueueNum)
+ if (curQueueNum == bedBO.getMaxReadyPatNum())
return;
// 鏌ョ湅 鏄惁鏈夋帓闃熶腑鐨勬偅鑰�
- Integer updateNum = queueMapper.preemptWaitingPatient(
- bedQueueBO.getRoomId(),
- bedQueueBO.getRoomName(),
- bedQueueBO.getBedNo(),
- curSeqNum.get() + 1,
+ //
+ // 銆愬彿缁熶竴锛堟湰闇�姹傦級銆戝垎娴佸彧鍋氥�屾帓闃熶腑(10) 鈫� 鍊欒瘖涓�(20)銆嶇殑鎼縼锛�**涓嶅啀鍒嗛厤鎺掗槦鍙�**锛�
+ // 鍙峰湪绛惧埌鏃跺凡鍐欏叆 seq_num锛涘姞鎬ュ彧褰卞搷杩欓噷鐨勫彇浜洪『搴忥紙SQL 鍐� jump_flag 浼樺厛锛夈��
+ // 鏃у疄鐜版槸銆孶PDATE ... 椤哄甫 seq_num=褰撳墠鍙�+1锛屽啀鎸夊彿鏌ュ洖璇ヨ銆嶁�斺��
+ // 鍙蜂笉鍐嶅敮涓�鍚�"鎸夊彿鏌ュ洖"浼氬彇閿欎汉锛屾晠鏀逛负锛氬厛鍙栬 鈫� 鎸� id 鏉′欢鏇存柊銆�
+ QueueDO preemptQueueItem = queueMapper.getFirstWaitingByCheckTypes(
QueueStatusEnum.WAITING.getStatus(),
- QueueStatusEnum.READY.getStatus(),
- checkType);
+ bedBO.checkTypes); //鍏抽敭鐐� 鍏抽敭鐐� 鍏抽敭鐐� checkType
- // 娌℃湁鎶㈠埌鎺掗槦鎮ｈ��
- if (null == updateNum || 0 == updateNum) {
+ // 娌℃湁鎺掗槦涓殑鎮ｈ��
+ if (null == preemptQueueItem) {
return;
}
- QueueDO preemptQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
+ // 鏉′欢鏇存柊锛歴tatus 蹇呴』浠嶆槸銆屾帓闃熶腑銆嶏紝淇濊瘉骞跺彂涓嬪彧鏈変竴鏂规姠鍒拌琛�
+ Integer updateNum = queueMapper.preemptWaitingPatientById(
+ preemptQueueItem.getId(),
+ bedBO.getRoomId(),
+ bedBO.getRoomName(),
+ bedBO.getBedNo(),
+ QueueStatusEnum.WAITING.getStatus(),
+ QueueStatusEnum.READY.getStatus());
+ if (null == updateNum || 0 == updateNum) {
+ // 琚叾瀹冨伐浣嶆姠鍏堬細鏈疆鏀惧純锛岀瓑涓嬩竴娆¤ˉ榻愯Е鍙�
+ return;
+ }
+
+ // 鍐呭瓨瀵硅薄涓庡簱鍐呬繚鎸佷竴鑷� 鈥斺�� 浜插拰椤硅璺熼殢涓婚」鐨勮瘖瀹�/宸ヤ綅
+ preemptQueueItem.setStatus(QueueStatusEnum.READY.getStatus());
+ preemptQueueItem.setRoomId(bedBO.getRoomId());
+ preemptQueueItem.setRoomName(bedBO.getRoomName());
+ preemptQueueItem.setBedNo(bedBO.getBedNo());
+
CheckTypeDO checkTypeDO = getCheckTypeItem( preemptQueueItem.getBookCheckType() );
// 鎶㈠埌鎺掗槦鎮ｈ�呭悗锛屽鐞� 妫�鏌ラ」鐩�.浜插拰鎬� 閫昏緫
@@ -468,13 +813,11 @@
procAffinityWhenPreempt(preemptQueueItem, checkTypeDO.getAffinityCheckTypes());
}
- curSeqNum.getAndIncrement();
+ // 鍙兘宸茬粡鍦� nextPatient 涓敼鍙樹簡鍊�
+ bedBO.readyPatNum++;
- // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡鍊�
- bedQueueBO.queueNum.incrementAndGet();
-
- // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡浼樺厛闃熷垪椤哄簭
- refreshPriorityQueue(bedQueueBO);
+ // 鍙兘宸茬粡銆愬苟鍙戠殑銆戝湪 nextPatient 涓敼鍙樹簡鍒嗘祦闃熷垪椤哄簭
+ refreshBedPriorityLevelInRoutingQueue(bedBO);
}
}
@@ -495,8 +838,8 @@
return mapCheckTypeVsReadyMax.get( checkType );
}
- public BedQueueBO getBedQueueBO(Long roomId, String bedNo) {
- return mapBedVsQueue.get( Utils.formatRoomBed(roomId, bedNo) );
+ public BedBO getBedQueueBO(Long roomId, String bedNo) {
+ return mapOpeningBed.get( Utils.formatRoomBed(roomId, bedNo) );
}
public MonitorInfoVO getMonitorInfo() {
@@ -510,27 +853,58 @@
public void monitorInfo() {
MonitorInfoVO monitorInfoVO = new MonitorInfoVO();
roomBedStatistic(monitorInfoVO);
- log.info(" opening " + openingFlag.get() + " " + monitorInfoVO.getQueueNum() + " " + monitorInfoVO.getActiveQueueNum() + " " + monitorInfoVO.getCheckTypeBedInfo().toString() );
+ log.info(" opening " + openingFlag.get() + " " + monitorInfoVO.getOpeningBedNum() + " " + monitorInfoVO.getDocBedNum() + " " + monitorInfoVO.getCheckTypeBedInfo().toString() );
}
- private void hurryupOneBedCheckTypeList(BedQueueBO bedQueueBO) {
- while (bedQueueBO.queueNum.get() < bedQueueBO.maxQueueNum) {
+ private void hurryupOneBedCheckTypeList(BedBO bedBO) {
+ // 銆愰渶姹�3銆戙�屽仠姝㈠�欒瘖銆嶇殑宸ヤ綅涓嶅啀鏂板鍊欒瘖鎮ｈ�呫��
+ // 宸叉湁鍊欒瘖鎮ｈ�呬粛鍙甯稿彨鍙凤紙鏈柟娉曞彧璐熻矗"琛ラ綈鍊欒瘖"锛屼笉鍙備笌鍙彿锛夈��
+ if (Boolean.TRUE.equals(bedBO.getStopReady())) {
+ // 銆愮幇鍦烘帓鏌ャ�戞槑纭涓�鏉★細宸ヤ綅寮�浜嗐�屽仠姝㈠�欒瘖銆嶆椂涓嶄細鑷姩琛ヤ汉
+ log.warn("[琛ヤ汉] 宸ヤ綅澶勪簬銆愬仠姝㈠�欒瘖銆戯紝璺宠繃鑷姩琛ヤ汉. 宸ヤ綅={}/{}锛堝闇�鎺ユ敹璇峰叧闂寮�鍏筹級",
+ bedBO.getRoomId(), bedBO.getBedNo());
+ return;
+ }
+ if (bedBO.getReadyPatNum() >= bedBO.getMaxReadyPatNum()) {
+ // 銆愮幇鍦烘帓鏌ャ�戝�欒瘖鍖哄凡杈句笂闄愶紙涓婇檺=鍚勬鏌ラ」鐩� check_type.ready_num 鐨勬渶澶у�硷級
+ log.info("[琛ヤ汉] 鍊欒瘖鍖哄凡杈句笂闄愶紝璺宠繃. 宸ヤ綅={}/{} 褰撳墠鍊欒瘖={} 涓婇檺={}",
+ bedBO.getRoomId(), bedBO.getBedNo(), bedBO.getReadyPatNum(), bedBO.getMaxReadyPatNum());
+ refreshBedPriorityLevelInRoutingQueue(bedBO);
+ return;
+ }
+ int pulledNum = 0;
+ while (bedBO.getReadyPatNum() < bedBO.getMaxReadyPatNum()) {
// 鎶㈠崰 鏄惁鏈夋帓闃熶腑鐨勬偅鑰�
- Integer updateNum = queueMapper.preemptWaitingPatientWithBedCheckTypes(
- bedQueueBO.getRoomId(),
- bedQueueBO.getRoomName(),
- bedQueueBO.getBedNo(),
- curSeqNum.get() + 1,
+ //
+ // 銆愬彿缁熶竴锛堟湰闇�姹傦級銆戜笌 hurryupOneCheckType 鐩稿悓锛氬彧鎼縼鐘舵�侊紝**涓嶅啀鍒嗛厤鎺掗槦鍙�**銆�
+ QueueDO preemptQueueItem = queueMapper.getFirstWaitingByCheckTypes(
QueueStatusEnum.WAITING.getStatus(),
- QueueStatusEnum.READY.getStatus(),
- bedQueueBO.checkTypes);
+ bedBO.checkTypes);
- // 娌℃湁鎶㈠埌鎺掗槦鎮ｈ��
- if (null == updateNum || 0 == updateNum) {
+ // 娌℃湁鎺掗槦涓殑鎮ｈ��
+ if (null == preemptQueueItem) {
return;
}
- QueueDO preemptQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
+ // 鏉′欢鏇存柊锛歴tatus 蹇呴』浠嶆槸銆屾帓闃熶腑銆嶏紝淇濊瘉骞跺彂涓嬪彧鏈変竴鏂规姠鍒拌琛�
+ Integer updateNum = queueMapper.preemptWaitingPatientById(
+ preemptQueueItem.getId(),
+ bedBO.getRoomId(),
+ bedBO.getRoomName(),
+ bedBO.getBedNo(),
+ QueueStatusEnum.WAITING.getStatus(),
+ QueueStatusEnum.READY.getStatus());
+ if (null == updateNum || 0 == updateNum) {
+ // 琚叾瀹冨伐浣嶆姠鍏堬細鏈疆鏀惧純锛岀瓑涓嬩竴娆¤ˉ榻愯Е鍙�
+ return;
+ }
+
+ // 鍐呭瓨瀵硅薄涓庡簱鍐呬繚鎸佷竴鑷� 鈥斺�� 浜插拰椤硅璺熼殢涓婚」鐨勮瘖瀹�/宸ヤ綅
+ preemptQueueItem.setStatus(QueueStatusEnum.READY.getStatus());
+ preemptQueueItem.setRoomId(bedBO.getRoomId());
+ preemptQueueItem.setRoomName(bedBO.getRoomName());
+ preemptQueueItem.setBedNo(bedBO.getBedNo());
+
CheckTypeDO checkTypeDO = getCheckTypeItem( preemptQueueItem.getBookCheckType() );
// 鎶㈠埌鎺掗槦鎮ｈ�呭悗锛屽鐞� 妫�鏌ラ」鐩�.浜插拰鎬� 閫昏緫
@@ -538,100 +912,276 @@
procAffinityWhenPreempt(preemptQueueItem, checkTypeDO.getAffinityCheckTypes());
}
- curSeqNum.getAndIncrement();
-
- bedQueueBO.queueNum.incrementAndGet();
+ bedBO.readyPatNum++;
+ pulledNum++;
}
- // 鏀瑰彉浜嗕紭鍏堥槦鍒楅『搴�
- refreshPriorityQueue(bedQueueBO);
+ if (pulledNum > 0) {
+ log.info("[琛ヤ汉] 宸茶ˉ鍏� {} 浜�. 宸ヤ綅={}/{} 褰撳墠鍊欒瘖={} 涓婇檺={}",
+ pulledNum, bedBO.getRoomId(), bedBO.getBedNo(),
+ bedBO.getReadyPatNum(), bedBO.getMaxReadyPatNum());
+ }
+
+ // 鏀瑰彉浜嗗垎娴侀槦鍒楅『搴�
+ refreshBedPriorityLevelInRoutingQueue(bedBO);
}
+ /** 搴撻噷璇ュ伐浣嶅綋鍓嶃�屽噯澶囦腑(20)銆嶇殑鐪熷疄浜烘暟锛堢敤浜庢牎姝ｅ唴瀛樿鏁颁笌鐜板満璇婃柇锛� */
+ private int countReadyInDb(Long roomId, String bedNo) {
+ List<Integer> readyStatus = new ArrayList<>();
+ readyStatus.add(QueueStatusEnum.READY.getStatus());
+ List<QueueDO> readyList = queueMapper.getBedQueueByStatus(roomId, bedNo, readyStatus);
+ return null == readyList ? 0 : readyList.size();
+ }
+
+ /**
+ * 绔嬪嵆琛ヤ汉锛堢幇鍦鸿嚜鏁� + 鑷姪璇婃柇锛夛細鎵嬪姩瑙﹀彂涓�娆¤宸ヤ綅鐨勮嚜鍔ㄥ垎娴侊紝骞舵妸"涓轰粈涔堟病琛�/琛ヤ簡鍑犱汉"涓�璧疯繑鍥炪��
+ *
+ * <p>鐢ㄤ簬宸ヤ綔鍙板�欒瘖鍖轰负绌烘椂鐨勩�岀珛鍗宠ˉ浜恒�嶆寜閽細涓嶅繀绛夊畾鏃朵换鍔°�佷篃涓嶇敤閲嶅惎鍘荤寽鏄摢閬撻棬闂告尅浣忕殑銆�
+ */
+ public Map<String, Object> hurryUpNow(Long roomId, String bedNo) {
+ Map<String, Object> data = new LinkedHashMap<>();
+ int flag = openingFlag.get();
+ data.put("绯荤粺寮�璇婄姸鎬�", 0 == flag ? "宸查棴璇婏紙姝ゆ椂涓嶄細鑷姩琛ヤ汉锛岃鍏堝湪鐩戞帶椤电偣銆屽紑璇娿�嶏級" : "寮�璇婁腑");
+
+ BedBO bedBO = getBedQueueBO(roomId, bedNo);
+ if (null == bedBO) {
+ data.put("缁撹", "璇ュ伐浣嶄笉鍦ㄣ�屽凡寮�璇婂伐浣嶃�嶅垪琛ㄩ噷锛堝彲鑳藉凡鍏抽棴/鏈鏈紑璇婏級锛屾棤娉曡ˉ浜猴紱璇峰厛鍒伴�夊伐浣嶉〉鍏ュ骇鎴栬绠＄悊鍛樺紑璇�");
+ log.warn("[琛ヤ汉] hurryUpNow 宸ヤ綅涓嶅瓨鍦�. 宸ヤ綅={}/{}", roomId, bedNo);
+ return data;
+ }
+
+ boolean stopReady = Boolean.TRUE.equals(bedBO.getStopReady());
+ int before = countReadyInDb(roomId, bedNo);
+ int memoryBefore = bedBO.getReadyPatNum();
+ // 鍏堟寜搴撳唴鐪熷疄鍊兼牎姝ｅ唴瀛橈紙鍐呭瓨铏氶珮浼氬鑷存案涔�"宸叉弧"锛�
+ bedBO.setReadyPatNum(before);
+
+ data.put("宸ヤ綅", bedBO.getRoomName() + " " + bedNo);
+ data.put("妫�鏌ラ」鐩�", null == bedBO.getCheckTypes() ? "[]" : java.util.Arrays.toString(bedBO.getCheckTypes()));
+ data.put("鍋滄鍊欒瘖", stopReady);
+ data.put("鍊欒瘖涓婇檺", bedBO.getMaxReadyPatNum());
+ data.put("琛ヤ汉鍓嶅�欒瘖浜烘暟", before + (memoryBefore == before ? "" : "锛堝唴瀛樻浘涓� " + memoryBefore + "锛屽凡鏍℃锛�"));
+
+ if (0 == flag) {
+ data.put("缁撹", "绯荤粺宸查棴璇婏紝鏈鏈ˉ浜猴紱璇峰厛鍦ㄧ洃鎺ч〉鐐广�屽紑璇娿��");
+ return data;
+ }
+ if (stopReady) {
+ data.put("缁撹", "鏈伐浣嶅紑浜嗐�屽仠姝㈠�欒瘖銆嶏紝鏈鏈ˉ浜猴紱濡傞渶鎺ユ敹鎮ｈ�呰鍏抽棴璇ュ紑鍏�");
+ return data;
+ }
+
+ hurryupOneBed(roomId, bedNo);
+
+ int after = countReadyInDb(roomId, bedNo);
+ int pulled = Math.max(0, after - before);
+ data.put("琛ヤ汉鍚庡�欒瘖浜烘暟", after);
+ data.put("鏈琛ュ叆", pulled);
+ if (pulled > 0) {
+ data.put("缁撹", "宸茶ˉ鍏� " + pulled + " 浜�");
+ } else if (after >= bedBO.getMaxReadyPatNum()) {
+ data.put("缁撹", "鍊欒瘖鍖哄凡杈句笂闄愶紙" + after + "/" + bedBO.getMaxReadyPatNum() + "锛夛紝涓嶅啀琛ヤ汉");
+ } else {
+ data.put("缁撹", "娌℃湁鍖归厤鏈伐浣嶆鏌ラ」鐩殑銆屾帓闃熶腑銆嶆偅鑰咃紙鍙埌宸ヤ綔鍙版煡鐪嬨�屾湰璇婂鎺掗槦涓紙鏈垎閰嶏級銆嶅垎鍖猴級");
+ }
+ log.info("[琛ヤ汉] hurryUpNow 宸ヤ綅={}/{} 鍓�={} 鍚�={} 缁撹={}", roomId, bedNo, before, after, data.get("缁撹"));
+ return data;
+ }
+
+ /**
+ * 鏈夋鏌ラ」鍒嗘祦鍒拌瘖瀹ゅ悗锛屼篃灏辨槸杩涘叆[鍊欒瘖涓璢鍚庯紝鎷� [鎺掗槦涓璢 + 鍏锋湁浜插拰鎬х殑 妫�鏌ラ」 鏉ヤ緷闄勮妫�鏌ラ」銆�
+ *
+ * <p>銆愪翰鍜岄」涓庢帓闃熷彿銆戜翰鍜岄」鐩紙鍚屼竴鎮ｈ�呫�佸彲鍦ㄤ竴涓伐浣嶄竴璧峰仛鐨勫涓鏌ラ」锛夊湪鍊欒瘖鍖�
+ * <b>璺熼殢涓婚」鏄剧ず</b>锛氳繖閲屾妸浜插拰椤圭殑鎺掗槦鍙锋敼鎴�**涓婚」鐨勫彿**銆佸苟鎼埌涓婚」鎵�鍦ㄨ瘖瀹�/宸ヤ綅锛�
+ * 鐣岄潰锛堝伐浣滃彴/璇婇棿灞�/澶у睆锛夋墠鑳芥妸涓よ�呮帓鍦ㄤ竴璧枫��
+ * <p>娉ㄦ剰杩�**涓嶆槸**"閲嶆柊璧嬪彿"锛氬彿浠嶆槸绛惧埌鏃跺畾鐨勯偅涓紝鍙槸浜插拰椤规部鐢ㄤ富椤圭殑鍙凤紝
+ * 涓�"鍒嗘祦/鍙彿/鍙洖涓嶅啀鏀瑰彿"骞朵笉鍐茬獊銆�
+ */
private void procAffinityWhenPreempt(QueueDO preemptQueueItem, Integer[] affinityCheckTypes) {
List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(
preemptQueueItem.getPatId(), affinityCheckTypes, QueueStatusEnum.WAITING.getStatus());
for (int i = 0; i < affinityItems.size(); i++) {
QueueDO queueItem = affinityItems.get(i);
- queueItem.setStatus(QueueStatusEnum.AFFINITY_WAITING.getStatus()); //鏀瑰彉 鎺掗槦鐘舵��
+ queueItem.setStatus(QueueStatusEnum.AFFINITY.getStatus()); //鏀瑰彉 鎺掗槦鐘舵��
queueItem.setAffinityItem( 1 );
queueItem.setRoomId(preemptQueueItem.getRoomId());
queueItem.setRoomName(preemptQueueItem.getRoomName());
queueItem.setBedNo(preemptQueueItem.getBedNo());
- queueItem.setSeqNum( preemptQueueItem.getSeqNum()); // 浣跨敤鍚屼竴涓� 鍐呴儴搴忓彿
+ queueItem.setSeqNum( preemptQueueItem.getSeqNum()); // 浜插拰椤规部鐢ㄤ富椤圭殑鎺掗槦鍙凤紙璺熼殢鏄剧ず锛�
queueMapper.updateById(queueItem);
}
}
+ /**
+ * [杩囧彿] 鎮ｈ�� => [鍊欒瘖涓璢 锛屽鐞� 妫�鏌ラ」鐩�.浜插拰鎬� 閫昏緫銆�
+ *
+ * <p>鍙洖鏃朵富椤圭殑鍙蜂笉鍙橈紝鍥犳鍙渶璁╁凡缁忚窡闅忕殑浜插拰椤逛繚鎸佷竴鑷达紙淇濇寔鍚屽彿 鈫� 鐣岄潰浠嶆帓鍦ㄤ竴璧凤級銆�
+ */
private void procAffinityWhenRecalled(QueueDO recalledQueueItem, Integer[] affinityCheckTypes) {
List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(
- recalledQueueItem.getPatId(), affinityCheckTypes, QueueStatusEnum.AFFINITY_WAITING.getStatus());
+ recalledQueueItem.getPatId(), affinityCheckTypes, QueueStatusEnum.AFFINITY.getStatus());
for (int i = 0; i < affinityItems.size(); i++) {
QueueDO queueItem = affinityItems.get(i);
- queueItem.setSeqNum( recalledQueueItem.getSeqNum() ); // 鍙洖鍚庯紝鍘熷唴閮ㄥ簭鍙锋洿鏂�
+ queueItem.setSeqNum( recalledQueueItem.getSeqNum() ); // 浜插拰椤逛笌涓婚」淇濇寔鍚屼竴涓彿
queueMapper.updateById(queueItem);
}
}
- private Integer getBedReadyMax(Long roomId, String bedNo) {
- RoomDO roomDO = roomMapper.getRoom(roomId, bedNo);
- Integer[] checkTypes = roomDO.getCheckTypes();
- Integer ret = 0;
- for (int i=0; i<checkTypes.length; i++) {
- CheckTypeDO checkTypeDO = mapCheckTypeVsReadyMax.get(checkTypes[i]);
+ /**
+ * 宸ヤ綅銆屽�欒瘖鍖哄閲忎笂闄愩��= 璇ュ伐浣嶅紑灞曠殑**鍚勬鏌ラ」鐩�** {@code check_type.ready_num}
+ * 锛堥〉闈㈠瓧娈碉細銆屾鏌ョ被鍨嬬鐞嗐�嶁啋銆屽�欒瘖鍑嗗浜烘暟銆嶏級鐨�**鏈�澶у��**銆�
+ *
+ * <p><b>杩斿洖 0 琛ㄧず"涓嶈嚜鍔ㄥ垎娴�"</b>锛氭鏃舵帓闃熶腑(10) 鐨勬偅鑰�**涓嶄細**琚富鍔ㄦ惉杩涘�欒瘖鍖�(20)锛�
+ * 闇�瑕佸尰鐢熷湪鍊欒瘖鍖虹敤銆屾媺鍏ャ�嶆墜鍔ㄨˉ浜猴紙鐜板満纭鐨勫彛寰勶級銆�
+ *
+ * <p>銆愭湰娆″姞鍥恒��
+ * <ul>
+ * <li><b>瀹炴椂璇诲簱</b>锛氬師鏉ヨ繖浠介厤缃彧鍦ㄦ湇鍔″惎鍔ㄦ椂鍔犺浇涓�娆�
+ * 锛坽@code MySpringEventListener} 鈫� {@code initCheckType()}锛夛紝
+ * 鍦ㄩ〉闈笂鏀逛簡銆屽�欒瘖鍑嗗浜烘暟銆嶅繀椤�**閲嶅惎鏈嶅姟**鎵嶇敓鏁堬紱</li>
+ * <li><b>瀹归敊</b>锛氭鏌ラ」鐩湪閰嶇疆閲屾煡涓嶅埌銆佹垨 {@code ready_num} 涓虹┖ 鈫� **璺宠繃骞惰璀﹀憡**锛�
+ * 涓嶅啀鎶� NPE銆傚師鍏堣繖涓� NPE 鍙戠敓鍦� {@code addBedToRoutingQueue}锛堝叆搴�/寮�璇�/閲嶈浇閮戒細璧帮級锛�
+ * 浼氳繛甯︽妸鍏ュ骇寮勫け璐ャ��</li>
+ * </ul>
+ */
+ private Integer getBedReadyMax(BedBO bedBO) {
+ Integer[] checkTypes = bedBO.getCheckTypes();
+ if (null == checkTypes || 0 == checkTypes.length) {
+ return 0;
+ }
+ Map<Integer, CheckTypeDO> fresh = readCheckTypeMapFresh();
+ int ret = 0;
+ for (Integer checkType : checkTypes) {
+ CheckTypeDO checkTypeDO = fresh.get(checkType);
+ if (null == checkTypeDO) {
+ // 鍏煎锛氬疄鏃惰澶辫触鏃跺洖钀藉埌鍚姩缂撳瓨锛屼袱杈归兘娌℃湁灏辫烦杩囷紙涓嶅啀 NPE锛�
+ checkTypeDO = getCheckTypeItem(checkType);
+ }
+ if (null == checkTypeDO) {
+ log.warn("[getBedReadyMax] 妫�鏌ラ」鐩湪 check_type 閲屼笉瀛樺湪锛岃烦杩囷紙鎸� 0 璁★級. checkType={} 宸ヤ綅={}/{}",
+ checkType, bedBO.getRoomId(), bedBO.getBedNo());
+ continue;
+ }
Integer tmp = checkTypeDO.getReadyNum();
- ret = ret < tmp ? tmp : ret; //鍙栧ぇ鍊�
+ if (null == tmp) {
+ log.warn("[getBedReadyMax] 妫�鏌ラ」鐩甗鍊欒瘖鍑嗗浜烘暟]涓虹┖锛岃烦杩�. checkType={} name={}",
+ checkType, checkTypeDO.getName());
+ continue;
+ }
+ ret = Math.max(ret, tmp); //銆愬�欒瘖涓�戞暟閲� 鍙栧ぇ鍊�
}
return ret;
}
- private void addPriorityQueue(BedQueueBO bedQueueBO) {
- Integer[] checkTypes = bedQueueBO.getCheckTypes();
+ /**
+ * 瀹炴椂璇诲彇銆屾鏌ラ」鐩�� 鈫� 妫�鏌ラ」鐩厤缃�嶆槧灏勶紙姣忔瑁呴厤宸ヤ綅鏃惰涓�娆″叏琛紝妫�鏌ラ」鐩彧鏈夊崄鍑犱釜锛岄噺绾у緢灏忥級銆�
+ * 杩欐牱绠＄悊鍛樺湪銆屾鏌ョ被鍨嬬鐞嗐�嶉噷鏀逛簡銆屽�欒瘖鍑嗗浜烘暟銆�**绔嬪埢鐢熸晥锛屼笉鐢ㄩ噸鍚湇鍔�**銆�
+ * 璇诲簱澶辫触鏃跺洖钀藉埌鍚姩鏃跺姞杞界殑缂撳瓨锛坽@link #initCheckType()}锛夈��
+ */
+ private Map<Integer, CheckTypeDO> readCheckTypeMapFresh() {
+ try {
+ List<CheckTypeDO> list = checkTypeMapper.simpleCheckTypeList();
+ Map<Integer, CheckTypeDO> map = new HashMap<>();
+ for (CheckTypeDO item : list) {
+ if (null != item && null != item.getValue()) {
+ map.put(item.getValue(), item);
+ }
+ }
+ return map;
+ } catch (Exception e) {
+ log.warn("[readCheckTypeMapFresh] 瀹炴椂璇绘鏌ラ」鐩け璐ワ紝鏀圭敤鍚姩鏃剁紦瀛�", e);
+ return null == mapCheckTypeVsReadyMax ? new HashMap<>() : mapCheckTypeVsReadyMax;
+ }
+ }
+
+ private void addBedToRoutingQueue(BedBO bedBO) {
+ // 瑁呮満宸ヤ綅 涓嶈繘 鍒嗘祦闃熷垪锛屼笉鎺ユ敹 銆愭帓闃熶腑銆戞偅鑰呭垎娴�
+ if (Objects.equals(BedOpTypeEnum.OP_INSTALL.getOpType(), bedBO.getOpType()))
+ return;
+
+ // 銆愰渶姹�3銆戙�屽仠姝㈠�欒瘖銆嶇殑宸ヤ綅涓嶈繘鍒嗘祦闃熷垪銆�
+ // 杩欐槸**鍞竴鍏ュ彛**鐨勭粺涓�闂ㄩ椄锛氬彧瑕佸伐浣嶈鏍囪涓哄仠姝㈠�欒瘖锛�
+ // 鏃犺浠庡摢鏉¤矾寰勶紙寮�璇� addBedToRoutingQueue銆佸尰鐢熸仮澶嶃�乥edReload銆�
+ // 鎴栨墜鍔ㄦ仮澶嶅紑鍏筹級璇曞浘鍔犲叆锛岄兘浼氳鎷掔粷锛屼粠鑰屼繚璇侊細
+ // 路 宸叉湁鍊欒瘖鎮ｈ�呬粛鍙甯稿彨鍙凤紙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()); //[鍊欒瘖涓璢
+ List<QueueDO> queueDOList = queueMapper.getBedQueueByStatus(bedBO.getRoomId(), bedBO.getBedNo(), queueStatusList);
+ bedBO.setMaxReadyPatNum( getBedReadyMax(bedBO) );
+ bedBO.setReadyPatNum( queueDOList.size() );
+
+ // 銆愮幇鍦烘帓鏌ャ�戞妸"鍊欒瘖鍖轰笂闄� / 褰撳墠浜烘暟 / 鏉ユ簮"鎵撳嚭鏉ワ細
+ // 涓婇檺=0 琛ㄧず**涓嶈嚜鍔ㄥ垎娴�**锛堟帓闃熶腑鐨勬偅鑰呬笉浼氳涓诲姩鎼繘鍊欒瘖鍖猴紝闇�鍦ㄥ�欒瘖鍖烘墜鍔ㄣ�屾媺鍏ャ�嶏級銆�
+ // 鐜板満鍙嶉杩�"鏈夎繖涔堝鎺掗槦鐥呬汉锛屼负浠�涔堟病涓诲姩鍔犺浇鍒板�欒瘖鍖�"锛屼竴鏉℃棩蹇楀嵆鍙嚜璇併��
+ log.info("[addBedToRoutingQueue] 宸ヤ綅 {}/{} 鍊欒瘖涓婇檺={} 褰撳墠鍊欒瘖={} 妫�鏌ラ」鐩�={}"
+ + "锛堜笂闄�=鍚勬鏌ラ」鐩� check_type.ready_num 鐨勬渶澶у�硷紱0=涓嶈嚜鍔ㄥ垎娴侊紝闈犲伐浣嶆墜鍔ㄣ�屾媺鍏ャ�嶏級",
+ bedBO.getRoomId(), bedBO.getBedNo(), bedBO.getMaxReadyPatNum(), bedBO.getReadyPatNum(),
+ null == bedBO.getCheckTypes() ? "[]" : java.util.Arrays.toString(bedBO.getCheckTypes()));
+
+ Integer[] checkTypes = bedBO.getCheckTypes();
Arrays.stream(checkTypes).forEach(checkType -> {
CheckTypeDO checkTypeDO = mapCheckTypeVsReadyMax.get(checkType);
- // 瑁呮満宸ヤ綅 涓嶈繘 浼樺厛闃熷垪锛屼笉浠庢帓闃熶腑鎺ユ敹浜�
- if (checkTypeDO.getNeedDevReady() == 1 && bedQueueBO.getOpType() == 2) {
- return;
- }
-
- PriorityBlockingQueue<BedQueueBO> priorityQueue = mapCheckTypePriorityQueue.get(checkType);
- if (null == priorityQueue) {
- priorityQueue = new PriorityBlockingQueue<BedQueueBO>();
- mapCheckTypePriorityQueue.put( checkType, priorityQueue );
+ PriorityBlockingQueue<BedBO> routingQueue = mapCheckTypeRoutingQueue.get(checkType);
+ if (null == routingQueue) {
+ routingQueue = new PriorityBlockingQueue<BedBO>();
+ mapCheckTypeRoutingQueue.put( checkType, routingQueue );
}
- if (!priorityQueue.contains(bedQueueBO)) {
- priorityQueue.offer(bedQueueBO);
+ if (!routingQueue.contains(bedBO)) {
+ routingQueue.offer(bedBO);
} else {
- log.error("bedDoctorResume priorityQueue still exist!. " + bedQueueBO.getRoomId() + " " + bedQueueBO.getBedNo());
+ log.error("bedDoctorResume routingQueue still exist!. " + bedBO.getRoomId() + " " + bedBO.getBedNo());
}
});
}
- private void removePriorityQueue(BedQueueBO bedQueueBO) {
- Integer[] checkTypes = bedQueueBO.getCheckTypes();
+ private void removeBedFromRoutingQueue(BedBO bedBO) {
+ // 瑁呮満宸ヤ綅 涓嶈繘 鍒嗘祦闃熷垪锛屼笉鎺ユ敹 銆愭帓闃熶腑銆戞偅鑰呭垎娴�
+ if (Objects.equals(BedOpTypeEnum.OP_INSTALL.getOpType(), bedBO.getOpType()))
+ return;
+
+ Integer[] checkTypes = bedBO.getCheckTypes();
Arrays.stream(checkTypes).forEach(checkType -> {
- PriorityBlockingQueue<BedQueueBO> priorityBlockingQueue = mapCheckTypePriorityQueue.get(checkType);
- if (null != priorityBlockingQueue)
- priorityBlockingQueue.remove(bedQueueBO);
+ PriorityBlockingQueue<BedBO> routingQueue = mapCheckTypeRoutingQueue.get(checkType);
+ if (null != routingQueue)
+ routingQueue.remove(bedBO);
});
}
- private void refreshPriorityQueue(BedQueueBO bedQueueBO) {
- Integer[] checkTypes = bedQueueBO.getCheckTypes();
+ private void refreshBedPriorityLevelInRoutingQueue(BedBO bedBO) {
+ // 瑁呮満宸ヤ綅 涓嶈繘 鍒嗘祦闃熷垪锛屼笉鎺ユ敹 銆愭帓闃熶腑銆戞偅鑰呭垎娴�
+ if (Objects.equals(BedOpTypeEnum.OP_INSTALL.getOpType(), bedBO.getOpType()))
+ return;
+
+ Integer[] checkTypes = bedBO.getCheckTypes();
Arrays.stream(checkTypes).forEach(checkType -> {
- PriorityBlockingQueue<BedQueueBO> priorityQueue = mapCheckTypePriorityQueue.get(checkType);
- priorityQueue.remove(bedQueueBO);
- priorityQueue.offer(bedQueueBO);
+ PriorityBlockingQueue<BedBO> routingQueue = mapCheckTypeRoutingQueue.get(checkType);
+ if (null != routingQueue) {
+ routingQueue.remove(bedBO);
+ routingQueue.offer(bedBO);
+ }
});
}
+ /**
+ * 妫�鏌ラ」杩涘叆鍒� [瀹夎涓璢 鏃讹紝鎷� [宸查鐢╙ + 鍏锋湁浜插拰鎬х殑 妫�鏌ラ」 鏉ヤ緷闄勮妫�鏌ラ」
+ */
private void procAffinityWhenSomeOneEntryInstalling(String patId, Long roomId_operator, String bedNo_operator, Integer[] affinityCheckTypes) {
- // 瀵逛簬 鍒氳繘鍏ュ埌 [瀹夎涓璢鐨勯」, 濡傛灉瀛樺湪 [宸查鐢╙ 鐨勪翰鍜岄」锛屽垯闇�瑕佸叾璺熼殢
List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(
patId, affinityCheckTypes, QueueStatusEnum.RECEIVED.getStatus());
for (int i = 0; i < affinityItems.size(); i++) {
QueueDO queueItem = affinityItems.get(i);
- queueItem.setStatus(QueueStatusEnum.AFFINITY_RECEIVED.getStatus()); //鏀瑰彉 鎺掗槦鐘舵��
+ queueItem.setStatus(QueueStatusEnum.AFFINITY_INSTALL.getStatus()); //鏀瑰彉 鎺掗槦鐘舵��
+ queueItem.setAffinityItem(1);
queueItem.setRoomId(roomId_operator);
queueItem.setBedNo(bedNo_operator); // 璺熼殢鍒� 瑁呮満 宸ヤ綅
queueMapper.updateById(queueItem);
@@ -641,17 +1191,17 @@
private void roomBedStatistic(MonitorInfoVO monitorInfoVO) {
Map<Integer, Integer> mapOpeningCheckBedStatInfo = new HashMap<>();
Map<Integer, Integer> mapOpeningInstallBedStatInfo = new HashMap<>();
- Map<Integer, Integer> mapOperatingCheckBedStatInfo = new HashMap<>();
- Map<Integer, Integer> mapOperatingInstallBedStatInfo = new HashMap<>();
+ Map<Integer, Integer> mapDocCheckBedStatInfo = new HashMap<>();
+ Map<Integer, Integer> mapDocInstallBedStatInfo = new HashMap<>();
mapCheckTypeVsReadyMax.keySet().forEach( checkType -> {
mapOpeningCheckBedStatInfo.put(checkType, 0);
mapOpeningInstallBedStatInfo.put(checkType, 0);
- mapOperatingCheckBedStatInfo.put(checkType, 0);
- mapOperatingInstallBedStatInfo.put(checkType, 0);
+ mapDocCheckBedStatInfo.put(checkType, 0);
+ mapDocInstallBedStatInfo.put(checkType, 0);
});
//寮�閫氱殑 鍜� 杩愯惀涓� 鐨勫伐浣嶇粺璁�
- mapBedVsQueue.values().forEach( bedQueueBO -> {
+ mapOpeningBed.values().forEach(bedQueueBO -> {
Integer[] checkTypes = bedQueueBO.getCheckTypes();
Arrays.stream(checkTypes).forEach(checkType -> {
if (bedQueueBO.opType == 0 || bedQueueBO.opType == 1)
@@ -659,19 +1209,20 @@
else
mapOpeningInstallBedStatInfo.put(checkType, mapOpeningInstallBedStatInfo.get(checkType) + 1 );
- if (bedQueueBO.getStatus() == BedStatusEnum.DOCTOR_ON.getStatus()) {
+ if (bedQueueBO.getStatus() == BedStatusEnum.DOCTOR_ON.getStatus() ||
+ bedQueueBO.getStatus() == BedStatusEnum.DOCTOR_PAUSE.getStatus()) {
if (bedQueueBO.opType == 0 || bedQueueBO.opType == 1)
- mapOperatingCheckBedStatInfo.put(checkType, mapOperatingCheckBedStatInfo.get(checkType) + 1);
+ mapDocCheckBedStatInfo.put(checkType, mapDocCheckBedStatInfo.get(checkType) + 1);
else
- mapOperatingInstallBedStatInfo.put(checkType, mapOperatingInstallBedStatInfo.get(checkType) + 1);
+ mapDocInstallBedStatInfo.put(checkType, mapDocInstallBedStatInfo.get(checkType) + 1);
}
});
});
- // 鎺ユ敹..鎺掗槦涓偅鑰�..鐨勪紭鍏堥槦鍒�
- HashSet<BedQueueBO> hashSetOperatingBedQueue = new HashSet<>();
- mapCheckTypePriorityQueue.values().forEach(priorityQueue->{
- priorityQueue.stream().forEach(bedQueueBO -> hashSetOperatingBedQueue.add(bedQueueBO));
+ // 鎺ユ敹..鎺掗槦涓偅鑰�..鐨勫垎娴侀槦鍒�
+ HashSet<BedBO> hashSetOperatingBedQueue = new HashSet<>();
+ mapCheckTypeRoutingQueue.values().forEach(routingQueue->{
+ routingQueue.stream().forEach(bedQueueBO -> hashSetOperatingBedQueue.add(bedQueueBO));
});
@@ -679,16 +1230,32 @@
mapCheckTypeVsReadyMax.keySet().forEach( checkType -> {
String str = mapOpeningCheckBedStatInfo.get(checkType) + " " +
mapOpeningInstallBedStatInfo.get(checkType) + " " +
- mapOperatingCheckBedStatInfo.get(checkType) + " " +
- mapOperatingInstallBedStatInfo.get(checkType) + " ";
+ mapDocCheckBedStatInfo.get(checkType) + " " +
+ mapDocInstallBedStatInfo.get(checkType) + " ";
mapCheckTypeBedInfo.put( checkType, str);
});
monitorInfoVO.setCheckTypeBedInfo(mapCheckTypeBedInfo);
- monitorInfoVO.setQueueNum(mapBedVsQueue.size());
- monitorInfoVO.setActiveQueueNum((int) mapBedVsQueue.values().stream().filter(item -> item.getStatus() == BedStatusEnum.DOCTOR_ON.getStatus()).count());
- monitorInfoVO.setPriorityQueueNum( hashSetOperatingBedQueue.size() );
- monitorInfoVO.setMapBedVsQueue( mapBedVsQueue );
+ monitorInfoVO.setOpeningBedNum(mapOpeningBed.size());
+ monitorInfoVO.setDocBedNum((int) mapOpeningBed.values().stream().filter(item ->
+ item.getStatus() == BedStatusEnum.DOCTOR_ON.getStatus() ||
+ item.getStatus() == BedStatusEnum.DOCTOR_PAUSE.getStatus())
+ .count());
+ // 銆愭湰闇�姹偮风粺璁℃寜浜哄悎骞躲�戝湪搴�**鍖荤敓鏁�**锛氫竴浜哄宸ヤ綅鏃朵笂闈㈢殑 docBedNum 浼氭寜宸ヤ綅绱锛�
+ // 杩欓噷鎸� doc_id 鍘婚噸锛岀粰鐩戞帶椤典竴涓�"鍒板簳鍑犱釜鍖荤敓鍦ㄥ矖"鐨勬寚鏍囥��
+ List<Integer> seatedStatusList = new ArrayList<>();
+ seatedStatusList.add(BedStatusEnum.DOCTOR_ON.getStatus());
+ seatedStatusList.add(BedStatusEnum.DOCTOR_PAUSE.getStatus());
+ try {
+ Integer docNum = roomMapper.countSeatedDoctors(seatedStatusList);
+ monitorInfoVO.setDocNum(null == docNum ? 0 : docNum);
+ } catch (Exception e) {
+ // 缁熻澶辫触涓嶅奖鍝嶇洃鎺ч〉鍏跺畠鏁版嵁
+ log.warn("[roomBedStatistic] 缁熻鍦ㄥ骇鍖荤敓鏁板け璐ワ紙涓嶅奖鍝嶅叾瀹冩寚鏍囷級", e);
+ monitorInfoVO.setDocNum(0);
+ }
+ monitorInfoVO.setRoutingBedNum( hashSetOperatingBedQueue.size() );
+ monitorInfoVO.setMapBedVsQueue(mapOpeningBed);
}
}
--
Gitblit v1.9.3