按工位的多个检查项目 抢占 排队中 患者

eight

2024-11-28 d1708b4b2bc6596f9c62354274f1af97be45401c

 jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/service/queue/QueueServiceTxFunctions.java

@@ -286,7 +286,7 @@
    public ErrorCode nextInstallPatient(Long roomId, String bedNo) {
        // 从 DB 把 序号最小的 [已领用] [已召回-安装] 的人 设置为 [安装中]
        QueueDO firstItem = queueMapper.getFirstItemByRoomAndStatus(roomId, List.of(QueueStatusEnum.RECEIVED.getStatus(), QueueStatusEnum.RECALLED_INSTALL.getStatus()));
        // 该工位 没有 [已领用] [已召回-安装] 人员
        // 该工位 没有 [已领用] | [已召回-安装] 人员
        if (null == firstItem) {
            return QUEUE_NOT_READY_PATIENT;
        }
@@ -298,14 +298,7 @@
        // 检查项目.亲和性 处理逻辑
        CheckTypeDO checkTypeDO = getCheckTypeItem( firstItem.getBookCheckType() );
        if (checkTypeDO.getAffinityCheckTypes().length > 0) {
            List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(firstItem.getPatId(),
                                    checkTypeDO.getAffinityCheckTypes(), QueueStatusEnum.RECEIVED.getStatus());
            for (int i = 0; i < affinityItems.size(); i++) {
                QueueDO queueItem = affinityItems.get(i);
                queueItem.setStatus(QueueStatusEnum.AFFINITY_RECEIVED.getStatus()); //改变 排队状态
                queueItem.setBedNo( bedNo );  // 跟随到 装机 工位
                queueMapper.updateById(queueItem);
            }
            procAffinityWhenSomeOneEntryInstalling(firstItem.getPatId(), roomId, bedNo, checkTypeDO.getAffinityCheckTypes() );
        }

        // 装机工位 无优先队列
@@ -364,16 +357,16 @@
    }

    public void resetRoom(Boolean needCloseBed) {
        // 踢出在座的医生
        List<BedStatusEnum> bedStatusEnumList = new ArrayList<BedStatusEnum>();
        bedStatusEnumList.add(BedStatusEnum.DOCTOR_ON);
        bedStatusEnumList.add(BedStatusEnum.PAUSE);
        List<RoomDO> roomDOList = roomMapper.simpleRoomList(bedStatusEnumList);
        List<Long> userIdList = roomDOList.stream().map(roomDO -> roomDO.getDocId()).toList();
        oAuth2TokenApi.tick(userIdList);

        // 关闭所有工位
        if (needCloseBed) {
            // 踢出在座的医生
            List<BedStatusEnum> bedStatusEnumList = new ArrayList<BedStatusEnum>();
            bedStatusEnumList.add(BedStatusEnum.DOCTOR_ON);
            bedStatusEnumList.add(BedStatusEnum.PAUSE);
            List<RoomDO> roomDOList = roomMapper.simpleRoomList(bedStatusEnumList);
            List<Long> userIdList = roomDOList.stream().map(roomDO -> roomDO.getDocId()).toList();
            oAuth2TokenApi.tick(userIdList);

            // 所有工位状态 => 关闭
            Integer ret = roomMapper.resetRoom(BedStatusEnum.CLOSED.getStatus());
        }
    }
@@ -409,7 +402,11 @@

            // 召回 [过号] 患者后，处理 检查项目.亲和性 逻辑
            QueueDO recalledQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
            updateAffinityItemsWhenRecalled( recalledQueueItem );

            CheckTypeDO checkTypeDO = getCheckTypeItem( recalledQueueItem.getBookCheckType() );
            if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
                procAffinityWhenRecalled(recalledQueueItem, checkTypeDO.getAffinityCheckTypes());
            }

            curSeqNum.getAndIncrement();

@@ -421,8 +418,41 @@
        }

        // 处理 排队中 患者
        Integer[] checkTypes = bedQueueBO.getCheckTypes();
        Arrays.stream(checkTypes).forEach(checkType -> hurryupOneCheckType(checkType));
        hurryupOneBedCheckTypes( bedQueueBO );
    }

    public void hurryupOneBedCheckTypes(BedQueueBO bedQueueBO) {
        while (bedQueueBO.queueNum.get() < bedQueueBO.maxQueueNum) {
            // 抢占 是否有排队中的患者
            Integer updateNum = queueMapper.preemptWaitingPatientWithBedCheckTypes(
                    bedQueueBO.getRoomId(),
                    bedQueueBO.getRoomName(),
                    bedQueueBO.getBedNo(),
                    curSeqNum.get() + 1,
                    QueueStatusEnum.WAITING.getStatus(),
                    QueueStatusEnum.READY.getStatus(),
                    bedQueueBO.checkTypes);

            // 没有抢到排队患者
            if (null == updateNum || 0 == updateNum) {
                return;
            }

            QueueDO preemptQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
            CheckTypeDO checkTypeDO = getCheckTypeItem( preemptQueueItem.getBookCheckType() );

            // 抢到排队患者后，处理 检查项目.亲和性 逻辑
            if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
                procAffinityWhenPreempt(preemptQueueItem, checkTypeDO.getAffinityCheckTypes());
            }

            curSeqNum.getAndIncrement();

            bedQueueBO.queueNum.incrementAndGet();
        }

        // 改变了优先队列顺序
        refreshPriorityQueue(bedQueueBO);
    }

    public void hurryupOneCheckType(Integer checkType) {
@@ -458,9 +488,13 @@
                return;
            }

            // 抢到排队患者后，处理 检查项目.亲和性 逻辑
            QueueDO preemptQueueItem = queueMapper.getQueueItemBySeqNum(curSeqNum.get() + 1);
            updateAffinityItemsWhenPreempt( preemptQueueItem );
            CheckTypeDO checkTypeDO = getCheckTypeItem( preemptQueueItem.getBookCheckType() );

            // 抢到排队患者后，处理 检查项目.亲和性 逻辑
            if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
                procAffinityWhenPreempt(preemptQueueItem, checkTypeDO.getAffinityCheckTypes());
            }

            curSeqNum.getAndIncrement();

@@ -507,33 +541,28 @@
        log.info(" opening " + openingFlag.get() + " " + monitorInfoVO.getQueueNum() + " " + monitorInfoVO.getActiveQueueNum() + " " + monitorInfoVO.getCheckTypeBedInfo().toString() );
    }

    private void updateAffinityItemsWhenPreempt(QueueDO preemptQueueItem) {
        CheckTypeDO checkTypeDO = getCheckTypeItem( preemptQueueItem.getBookCheckType() );
        if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
            List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(preemptQueueItem.getPatId(),
                    checkTypeDO.getAffinityCheckTypes(), QueueStatusEnum.WAITING.getStatus());
            for (int i = 0; i < affinityItems.size(); i++) {
                QueueDO queueItem = affinityItems.get(i);
                queueItem.setStatus(QueueStatusEnum.AFFINITY_WAITING.getStatus()); //改变 排队状态
                queueItem.setRoomId(preemptQueueItem.getRoomId());
                queueItem.setRoomName(preemptQueueItem.getRoomName());
                queueItem.setBedNo(preemptQueueItem.getBedNo());
                queueItem.setSeqNum( preemptQueueItem.getSeqNum());  // 使用同一个 内部序号
                queueMapper.updateById(queueItem);
            }
    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.setAffinityItem( 1 );
            queueItem.setRoomId(preemptQueueItem.getRoomId());
            queueItem.setRoomName(preemptQueueItem.getRoomName());
            queueItem.setBedNo(preemptQueueItem.getBedNo());
            queueItem.setSeqNum( preemptQueueItem.getSeqNum());  // 使用同一个 内部序号
            queueMapper.updateById(queueItem);
        }
    }

    private void updateAffinityItemsWhenRecalled(QueueDO recalledQueueItem) {
        CheckTypeDO checkTypeDO = getCheckTypeItem( recalledQueueItem.getBookCheckType() );
        if ( checkTypeDO.getAffinityCheckTypes().length > 0) {
            List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(recalledQueueItem.getPatId(),
                    checkTypeDO.getAffinityCheckTypes(), QueueStatusEnum.AFFINITY_WAITING.getStatus());
            for (int i = 0; i < affinityItems.size(); i++) {
                QueueDO queueItem = affinityItems.get(i);
                queueItem.setSeqNum( recalledQueueItem.getSeqNum() );  // 召回后，原内部序号更新
                queueMapper.updateById(queueItem);
            }
    private void procAffinityWhenRecalled(QueueDO recalledQueueItem, Integer[] affinityCheckTypes) {
        List<QueueDO> affinityItems = queueMapper.getCurPatGivenCheckTypesAndStatus(
                recalledQueueItem.getPatId(), affinityCheckTypes, QueueStatusEnum.AFFINITY_WAITING.getStatus());
        for (int i = 0; i < affinityItems.size(); i++) {
            QueueDO queueItem = affinityItems.get(i);
            queueItem.setSeqNum( recalledQueueItem.getSeqNum() );  // 召回后，原内部序号更新
            queueMapper.updateById(queueItem);
        }
    }

@@ -590,6 +619,19 @@
        });
    }

    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.setRoomId(roomId_operator);
            queueItem.setBedNo(bedNo_operator);  // 跟随到 装机 工位
            queueMapper.updateById(queueItem);
        }
    }

    private void roomBedStatistic(MonitorInfoVO monitorInfoVO) {
        Map<Integer, Integer>  mapOpeningCheckBedStatInfo = new HashMap<>();
        Map<Integer, Integer>  mapOpeningInstallBedStatInfo = new HashMap<>();