NB_NetPump/nb-system/src/main/java/com/nb/bus/controller/BusPatientController.java

package com.nb.bus.controller;

import cn.dev33.satoken.SaManager;
import cn.dev33.satoken.annotation.SaCheckPermission;
import cn.dev33.satoken.stp.StpLogic;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.mapper.Mapper;
import com.nb.bus.controller.vo.GetPatientInfoVo;
import com.nb.bus.controller.vo.MonitorDetailVo;
import com.nb.bus.controller.vo.MonitorFinishedVo;
import com.nb.bus.entity.*;
import com.nb.bus.enums.DeviceStatusEnum;
import com.nb.bus.enums.PatientAlarmEnum;
import com.nb.bus.registry.patient.PatientOperator;
import com.nb.bus.registry.patient.PatientRegistry;
import com.nb.bus.service.*;
import com.nb.bus.service.dto.*;
import com.nb.bus.utils.WsPublishUtils;
import com.nb.common.annotation.Log;
import com.nb.common.crud.BaseService;
import com.nb.common.crud.controller.BaseQueryController;
import com.nb.common.exception.CustomException;
import com.nb.common.result.R;
import io.swagger.annotations.*;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.context.request.async.DeferredResult;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

/**
 * @author lifang
 * @version 1.0.0
 * @ClassName BusHospitalController.java
 * @Description TODO
 * @createTime 2022年03月19日 09:28:00
 */
@RestController
@AllArgsConstructor
@RequestMapping("/bus/patient")
@Slf4j
@Api(tags = "医院病人管理",description = "关于病人的相关操作,查询操作权限【bus:patient:query】")
public class BusPatientController  implements BaseQueryController<BusPatientEntity,String> {
    private final LocalBusPatientService patientService;

    private final LocalBusClinicService clinicService;

    private final PatientRegistry patientRegistry;

    private final LocalBusInfusionHistoryService infusionService;

    private final LocalBusDeviceManualService manualService;

    private final WsPublishUtils wsPublishUtils;
    @PostMapping("/no_page")
    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "输注监控列表",notes = "病人监控管理列表，权限【device:patient:query】")
    public R<List<PatientMonitorResult>> selectPage(@RequestBody PatientMonitorQuery query){
        log.info("输注监控列表,【{}】",JSONUtil.toJsonStr(query));
        return R.success(patientService.selectAll(query));
    }


    @Log(title = "查询该次临床过程中所用的所有输注信息")
    @PostMapping("/look/{clinicId}/infusion")
    @SaCheckPermission("bus:patient:query")
    @ApiOperation(value = "查询该次临床过程中所用的所有输注信息",notes = "查询该次临床过程中所用的所有输注信息,权限【bus:patient:query】")
    public R lookUpAllInfusion(@PathVariable("clinicId") String clinicId){
        List<BusInfusionHistoryEntity> infusionHistories = infusionService.list(new QueryWrapper<BusInfusionHistoryEntity>().lambda().eq(BusInfusionHistoryEntity::getClinicId, clinicId));
        return R.success(infusionHistories.stream()
                .map(InfusionHistorySmallResult::of)
                .sorted(Comparator.comparing(InfusionHistorySmallResult::getStartTime))
                .collect(Collectors.toList()));
    }

    @GetMapping("/repeat/device")
    @ApiOperation(value = "设备重复提示列表",notes = "当出现病患同一时间绑定了多个泵时,调用该接口查询出所有设备重复报警数据，权限【无】")
    public R<List<PatientDeviceRepeatResult>> repeatDevice(){
        log.info("设备重复提示列表");
        return R.success(patientService.repeatDevice());
    }

    @GetMapping("/none/device")
    @ApiOperation(value = "临床无泵列表",notes = "当出现病患同一时间没有泵时,调用该接口查询出所有没有泵信息的病患临床数据，权限【无】")
    public R<List<PatientDeviceNoneResult>> noneDevice(){
        log.info("设备重复提示列表");
        return R.success(patientService.noneDevice());
    }

    @PostMapping("/judge/repeat")
    @ApiOperation(value = "判断所给病号中是否出现了绑定设备重复",notes = "当结束管理时，调用改接口判断所结束病号是否出现了设备重复异常,权限【无】")
    @ApiResponses({
            @ApiResponse(code = 200,message = "0 病人中未出现重复,非0 病人中出现重复"),
    })
    public R<Long> judgeRepeat(@RequestBody List<String> patientIds){
        log.info("判断所给病号中是否出现了绑定设备重复,【{}】",patientIds);
        return R.success(patientService.count(new QueryWrapper<BusPatientEntity>().lambda().in(BusPatientEntity::getId,patientIds).eq(BusPatientEntity::getAlarm,PatientAlarmEnum.DEVICE_REPEAT)));
    }

    @PostMapping("/judge/finished")
    @ApiOperation(value = "判断给定病号中是否可以结束临床管理",notes = "病患当前绑定主设备必须要在关机、不在服务器、待机中才能结束管理,权限【无】")
    @ApiResponses({
            @ApiResponse(code = 500,message = "没有选择病号"),
            @ApiResponse(code =200 ,message = "若存在不可以结束的临床信息，返回1",response = BusDeviceRunningEntity.class)
    })
    public R<Boolean> judgeFinished(@RequestBody List<String> patientIds){
        log.info("判断给定病号中是否可以结束临床管理,【{}】",patientIds);
        if(CollUtil.isEmpty(patientIds)){
            throw new CustomException("请选择一个病患");
        }
        List<BusPatientEntity> patients = patientService.list(new QueryWrapper<BusPatientEntity>()
                .lambda().in(BusPatientEntity::getId, patientIds));
        if(CollUtil.isEmpty(patients)){
            throw new CustomException("病号不存在,请刷新后重试");
        }
        return R.success(infusionService.count(new QueryWrapper<BusInfusionHistoryEntity>()
                .lambda()
                .nested(i->i.ne(BusInfusionHistoryEntity::getRunState,DeviceStatusEnum.Shutdown)
                        .ne(BusInfusionHistoryEntity::getRunState,DeviceStatusEnum.NoSignal))
                .in(BusInfusionHistoryEntity::getPatientId,patients.stream().map(BusPatientEntity::getId).collect(Collectors.toList()))
                .eq(BusInfusionHistoryEntity::getFinished,false))!=0);
    }

    @PostMapping("/do/{monitorType}/finished")
    @SaCheckPermission("bus:patient:finished")
    @ApiResponse(code = 4001,message = "病号当前绑定了多个设备，不可结束管理")
    @ApiOperation(value = "结束管理",notes = "病患当前绑定主设备必须要在关机、不在服务器、待机中才能结束管理,权限【bus:patient:finished】")
    public R<Boolean> finished(@PathVariable("monitorType")@ApiParam(value = "是否为无泵管理 false、无泵 true、有泵",defaultValue = "false" ) boolean haveDevice,
                               @RequestBody MonitorFinishedVo monitorFinishedVo,
                               @RequestAttribute("tenantId")@ApiParam(hidden = true) String tenantId){
        log.info("结束管理,【{}】",JSONUtil.toJsonStr(monitorFinishedVo));
        if(haveDevice){
            R<Boolean> result = monitorFinished(monitorFinishedVo, tenantId);
            CompletableFuture.runAsync(()->wsPublishUtils.publishMonitorTotalCount(tenantId))
                    .thenRunAsync(()->wsPublishUtils.publishDeviceNone(tenantId))
                    .thenRunAsync(()->wsPublishUtils.publishMonitorStateCount(tenantId));
            return result;
        }else {
            return manualFinished(monitorFinishedVo);
        }
    }

    /**
     * 描述: 输注监控结束管理（即使用驼人网络泵产品）
     * @author lifang
     * @date 2022/5/10 11:48
     * @param monitorFinishedVo
     * @param tenantId
     * @return R
     */
    private R<Boolean> monitorFinished(MonitorFinishedVo monitorFinishedVo, String tenantId){
        List<String> patientIds = monitorFinishedVo.getPatientIds();
        if(CollUtil.isEmpty(patientIds)){
            List<String> clinicIds = monitorFinishedVo.getClinicIds();
            if (CollUtil.isEmpty(clinicIds)) {
                throw new CustomException("未选择临床信息");
            }
        }
        List<BusPatientEntity> patients = patientService.list(new QueryWrapper<BusPatientEntity>().lambda().in(BusPatientEntity::getId, patientIds));
        List<ManualUndoConfig> undoConfigs=new ArrayList<>();
        for (BusPatientEntity patient : patients) {
            undoConfigs.add(
                    ManualUndoConfig.of(
                            Collections.singletonList(patient.getInfusionId()),
                            patient.getId(),
                            patient.getClinicId(),
                            tenantId,
                            true,
                            monitorFinishedVo.getUndo())
            );
        }
        //病患绑定的有设备,对设备进行撤泵操作,且结束临床
        infusionService.batchUndo(undoConfigs,true);
        return R.success(true);
    }

    /**
     * 描述: 其他监控手动结束管理（即未采用驼人网络泵产品）
     * @author lifang
     * @date 2022/5/10 11:49
     * @param monitorFinishedVo
     * @return R
     */
    private R<Boolean> manualFinished(MonitorFinishedVo monitorFinishedVo){
        List<String> clinicIds = monitorFinishedVo.getClinicIds();
        if (CollUtil.isEmpty(clinicIds)) {
            throw new CustomException("未选择临床信息");
        }
        manualService.finishedMonitor(monitorFinishedVo);
        return R.success(true);
    }


    @PostMapping("/monitor/reset/{clinicId}")
    @SaCheckPermission("device:patient:edit")
    @ApiOperation(value = "病人当前监控时间重启",notes = "当结束临床后有新的输注信息产生，那么病人监控会重新显示，此时监控时间不会重新计算，需先调用该接口，权限标识为【device:patient:edit】")
    public R<Boolean> reset(@ApiParam("临床id")@PathVariable("clinicId")String clinicId){
        log.info("病人当前监控时间重启,【{}】",clinicId);
        R<Boolean> result = R.success(clinicService.update(new UpdateWrapper<BusClinicEntity>().lambda().eq(BusClinicEntity::getId, clinicId)
                .set(BusClinicEntity::getEndTime, null)));
        BusClinicEntity clinic = clinicService.getById(clinicId);
        wsPublishUtils.publishPatientMonitor(clinic.getPatientId(),clinic.getTenantId());
        return result;
    }

    @PostMapping("/{alarm}/_count")
    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "病人报警数量统计",notes = "病人报警数量统计 0、未报警 1、泵重复 2、无泵，权限标识为【device:patient:query】")
    public R<Integer> alarmCount(@PathVariable("alarm") int alarm){
        PatientAlarmEnum alarmEnum = PatientAlarmEnum.of(alarm);
        if(alarmEnum==null){
            return R.success(0);
        }
        log.info("病人报警数量统计,【{}】",alarmEnum);
        switch (alarmEnum){
            case DEVICE_REPEAT:
                return this.noneCount();
            case NONE:
                return this.repeatCount();
            default:return R.success(0);

        }

    }

    @PostMapping("/shift")
    @SaCheckPermission("device:patient:shift")
    @ApiOperation(value = "主泵切换的操作,只切换，不结束",notes = "当出现泵重复状态时，若用户想要进行主泵的切换，调用该接口进行操作，主泵切换完成后，会将副泵自动撤泵，权限标识为【device:patient:shift】")
    public R shift(@RequestBody@Validated DeviceShiftConfig shiftConfig){
        log.info("主泵切换的操作,【{}】",JSONUtil.toJsonStr(shiftConfig));
        patientService.shift(shiftConfig);
        wsPublishUtils.publishPatientMonitor(shiftConfig.getPatientId(),shiftConfig.getTenantId());
        return R.success();
    }

    @PostMapping("/undo")
    @SaCheckPermission("device:patient:undo")
    @ApiOperation(value = "批量撤泵,只撤泵，不切换",notes = "当出现泵重复状态时，若用户想要取消对其他副泵的监控，则调用此接口进行撤泵操作，权限标识为【device:patient:undo】")
    public R shift(@RequestBody@Validated ManualUndoConfig undoConfig, @RequestAttribute("tenantId")@ApiParam(hidden = true) String tenantId){
        log.info("批量撤泵,【{}】",JSONUtil.toJsonStr(undoConfig));
        undoConfig.setTenantId(tenantId);
        BusPatientEntity patient = patientService.getById( undoConfig.getPatientId());
        if(patient==null){
            return R.success();
        }
        //泵切换完成后，对病号报警解除
        infusionService.undo(undoConfig,false);
        PatientOperator operator = patientRegistry.getOperator(undoConfig.getTenantId(), patient.getOriginCode());
        //判断当前病号下是否还存在副泵
        long count = infusionService.count(new QueryWrapper<BusInfusionHistoryEntity>().lambda()
                .eq(BusInfusionHistoryEntity::getClinicId, operator.getClinicId())
                .eq(BusInfusionHistoryEntity::getFinished,false)
                .eq(BusInfusionHistoryEntity::getIsUndo,false));
        //处理缓存信息
        if(count==1){
            patientService.update(new UpdateWrapper<BusPatientEntity>().lambda()
                    .eq(BusPatientEntity::getId,patient.getId())
                    .set(BusPatientEntity::getAlarm, PatientAlarmEnum.NONE));
            wsPublishUtils.publishDeviceRepeat(undoConfig.getTenantId());
        }
        wsPublishUtils.publishPatientMonitor(patient.getId(),undoConfig.getTenantId());
        return R.success();
    }


    @PostMapping("/monitor")
    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "查看病人当前监控详情",notes = "查看病人当前监控详情，权限标识为【device:patient:query】")
    public R<PatientMonitorDetailResult> monitor(@RequestBody@Validated MonitorDetailVo vo){
        log.info("查看病人监控详情,【{}】", JSONUtil.toJsonStr(vo));
        PatientMonitorDetailResult result = new PatientMonitorDetailResult();
        BusClinicEntity clinic =null;
        Boolean monitorType = vo.getMonitorType();
        if(Boolean.TRUE.equals(monitorType)){
            if (StrUtil.isEmpty(vo.getPatientId())) {
                throw new CustomException("病号id不能为空");
            }
            String infusionId=vo.getInfusionId();
            if(CharSequenceUtil.isAllBlank(infusionId)){
                BusPatientEntity patient = patientService.getById(vo.getPatientId());
                if(patient==null){
                    throw new CustomException("该病号信息不存在,请刷新后重试");
                }
                clinic = clinicService.getById(patient.getClinicId());
                infusionId=patient.getInfusionId();
            }else {
                clinic= clinicService.getById(vo.getClinicId());
            }
            BusInfusionHistoryEntity infusion =infusionService.getById(infusionId);
            result.setInfusion(infusion);
        }else {
            String clinicId = vo.getClinicId();
            clinic = clinicService.getById(clinicId);
            result.setClinic(clinic);
            if(clinic!=null){
                //无泵查看
                result.setDeviceManual( manualService.getOne(new QueryWrapper<BusDeviceManualEntity>().lambda().eq(BusDeviceManualEntity::getClinicId, clinic.getId())));
            }
        }
        if(clinic==null){
            throw new CustomException("该临床信息不存在,请刷新后重试");
        }
        result.setClinic(clinic);
        return R.success(result);
    }

    @PostMapping("/stats/status")
    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "按照状态统计病人监控状态数量",notes = "权限【device:patient:query】")
    public R<MonitorStatusStatsCountResult> statsStatus(){
        return R.success(patientService.statusStats(null));
    }


    @PostMapping("/stats/time")
    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "按照时间统计病人监控数量",notes = "权限【device:patient:query】")
    public R<MonitorTimeStatsCountResult> statsTime(){
        return R.success(patientService.timeStats(null));
    }



    @PostMapping("/pull/async")
    @SaCheckPermission("device:patient:pull")
    @ApiOperation(value = "异步更新患者信息,超时时间默认为10s,超时后数据返回继续处理,输注监控",notes = "权限标识为【bus:patient:pull】")
    public DeferredResult<R<BusClinicEntity>> syn(@RequestAttribute("tenantId")@ApiParam(hidden = true) String tenantId, @Validated@RequestBody GetPatientInfoVo vo){
        return patientService.getPatientInfoFromHis(tenantId,vo.getPatientCode(),vo.getTimeout(),false);
    }


    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "泵重复绑定数量",notes = "权限标识为【bus:patient:query】")
    @PostMapping("/_count/repeat")
    public R<Integer> repeatCount(){
        return R.success(CollUtil.size(patientService.repeatDevice()));
    }

    @SaCheckPermission("device:patient:query")
    @ApiOperation(value = "无泵数量",notes = "权限标识为【bus:patient:query】")
    @PostMapping("/_count/none")
    public R<Integer> noneCount(){
        return R.success(CollUtil.size(patientService.noneDevice()));
    }
    /**
     * 描述:
     * @author lifang
     * @date 2022/5/15 21:56
     * @param tenantId
     * @param vo
     * @return R
     */
    @PostMapping("/pull/sync")
    @SaCheckPermission("device:patient:pull")
    @ApiOperation(value = "同步更新患者信息,超时时间默认为10s,超时后数据返回则不进行处理,无泵更新",notes = "权限标识为【bus:patient:pull】")
    public DeferredResult<R<BusClinicEntity>>  async(@RequestAttribute("tenantId")@ApiParam(hidden = true) String tenantId,@Validated @RequestBody GetPatientInfoVo vo){
        return patientService.getPatientInfoFromHis(tenantId,vo.getPatientCode(),vo.getTimeout(),true);
    }


    @Override
    public BaseService<? extends Mapper<BusPatientEntity>, BusPatientEntity, String> getService() {
        return patientService;
    }

    @Override
    public String getPermissionPrefix() {
        return "bus:patient:";
    }

    @Override
    public StpLogic getStpLogin() {
        return SaManager.getStpLogic("");
    }
}