ai优化

yxh

5 天以前 68ff33beff11310e830b0615b5a81f83fad0f683

 jh-module-ecg/jh-module-ecg-biz/src/main/java/cn/lihu/jh/module/ecg/controller/admin/devrent/DevRentController.java

@@ -1,319 +1,705 @@
package cn.lihu.jh.module.ecg.controller.admin.devrent;



import cn.lihu.jh.framework.security.core.util.SecurityFrameworkUtils;

import cn.lihu.jh.module.ecg.dal.dataobject.appointment.AppointmentDO;

import cn.lihu.jh.module.ecg.dal.dataobject.devmanage.DeviceDO;

import cn.lihu.jh.module.ecg.enums.DevStateEnum;

import cn.lihu.jh.module.ecg.annotation.RequireBedOwner;

import cn.lihu.jh.module.ecg.service.appointment.AppointmentService;


import cn.lihu.jh.module.ecg.service.devmanage.DeviceService;


import cn.lihu.jh.module.ecg.service.queue.QueueService;

import lombok.extern.slf4j.Slf4j;

import org.springframework.web.bind.annotation.*;

import org.springframework.validation.annotation.Validated;

import org.springframework.security.access.prepost.PreAuthorize;

import io.swagger.v3.oas.annotations.tags.Tag;

import io.swagger.v3.oas.annotations.Parameter;

import io.swagger.v3.oas.annotations.Operation;



import java.util.*;

import java.io.IOException;



import cn.lihu.jh.framework.common.pojo.PageParam;

import cn.lihu.jh.framework.common.pojo.PageResult;

import cn.lihu.jh.framework.common.pojo.CommonResult;

import cn.lihu.jh.framework.common.util.object.BeanUtils;



import cn.lihu.jh.framework.excel.core.util.ExcelUtils;



import cn.lihu.jh.framework.apilog.core.annotation.ApiAccessLog;



import static cn.lihu.jh.framework.apilog.core.enums.OperateTypeEnum.*;



import cn.lihu.jh.module.ecg.controller.admin.devrent.vo.*;

import cn.lihu.jh.module.ecg.dal.dataobject.devrent.DevRentDO;


import cn.lihu.jh.module.ecg.service.devrent.DevRentService;



import javax.annotation.Resource;

import javax.servlet.http.HttpServletResponse;

import javax.validation.Valid;



@Tag(name = "装机拆机")

@RestController

@RequestMapping("/ecg/dev-rent")

@Validated

@Slf4j

public class DevRentController {



    @Resource

    private DevRentService devRentService;



    @Resource

    private DeviceService deviceService;



    @Resource

    private QueueService queueService;



    @Resource

    private AppointmentService appointmentService;

    /** 【主/围观】写操作的工位主人校验（只带患者信息的接口在方法里显式调用） */
    @Resource

    private cn.lihu.jh.module.ecg.service.room.RoomService roomService;



    // 常规检查 完成

    @RequireBedOwner("检查完成")

    @PostMapping("/routine-finish")

    @Operation(summary = "常规检查完成")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> routineFinish(@Valid @RequestBody RoutineFinishReqVO routineFinishReqVO) {

        CommonResult<Long> result = devRentService.routineFinishOperation(routineFinishReqVO);



        try {

            String userNickname = SecurityFrameworkUtils.getLoginUserNickname();

            String userHisId = SecurityFrameworkUtils.getLoginUserHisId();
            Long rentId = routineFinishReqVO.getId();

            // 【缺陷修复】优先用**服务返回的 rentId**（= 本次完成实际写入的检查单 id）：
            //   · 普通患者：请求里带了 id，两者相同；
            //   · 紧急加做患者：请求里没有 id（没签到过），服务会新建检查单 ——
            //     原实现用 routineFinishReqVO.getId()（null）去确费，必然失败（且被 catch 吞掉），
            //     现场表现为"加急患者检查完成后没有确费"。
            Long rentId = null != result && null != result.getData()
                    ? result.getData() : routineFinishReqVO.getId();

            devRentService.feeConfirm(rentId, userHisId, userNickname, true);  // 故意 不检查返回值

        } catch (Exception e) {

            log.error("常规检查完成, 自动确费失败", e);

        }



        return result;

    }



    @RequireBedOwner("设备领用完成")

    @PostMapping("/dev-ready")

    @Operation(summary = "设备领用完成")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devReady(@Valid @RequestBody DevRentSaveReqVO createReqVO) {

        String userHisId = SecurityFrameworkUtils.getLoginUserHisId();

        String userNickname = SecurityFrameworkUtils.getLoginUserNickname();

        createReqVO.setOperater(userNickname);

        CommonResult<Long> result = devRentService.readyOperation(createReqVO);



        try {

            Long rentId = createReqVO.getId();

            devRentService.feeConfirm(rentId, userHisId, userNickname, true);  // 故意 不检查返回值

        } catch (Exception e) {

            log.error("设备领用完成, 自动确费失败", e);

        }



        return result;

    }



    @RequireBedOwner("装机完成")

    @PostMapping("/dev-install")

    @Operation(summary = "装机")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devInstall(@Valid @RequestBody DevRentSaveReqVO createReqVO) {

        return devRentService.installOperation(createReqVO);

    }



    @RequireBedOwner("拆机")

    @PostMapping("/dev-dismantle")

    @Operation(summary = "拆机")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devDismantle(@Valid @RequestBody DevRentSaveReqVO createReqVO) {

        devRentService.dismantleOperation(createReqVO);

        return CommonResult.success(0L);

    }



    @RequireBedOwner("数据录入")

    @PostMapping("/dev-data-entry")

    @Operation(summary = "数据录入")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devDataEntry(@Valid @RequestBody DevRentSaveReqVO createReqVO) {

        devRentService.dataEntryOperation(createReqVO);

        return CommonResult.success(0L);

    }



    @PostMapping("/routine-check-cancel")

    @Operation(summary = "取消常规检查")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> routineCheckCancel(@Valid @RequestBody DevCancelReqVO cancelReqVO) {

        // 【主/围观】该接口没有 roomId/bedNo，按「患者 + 检查项目」反查其所在工位再校验主人身份
        roomService.assertBedOwnerByPatient(cancelReqVO.getPatId(), cancelReqVO.getCheckType());

        return devRentService.cancelRoutineOperation(cancelReqVO);

    }



    @PostMapping("/dev-ready-cancel")

    @Operation(summary = "取消领用")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devReadyCancel(@Valid @RequestBody DevCancelReqVO cancelReqVO) {

        // 【主/围观】按「患者 + 检查项目」反查工位再校验主人身份
        roomService.assertBedOwnerByPatient(cancelReqVO.getPatId(), cancelReqVO.getCheckType());

        return devRentService.cancelReadyOperation(cancelReqVO);

    }



    @PostMapping("/dev-install-cancel")

    @Operation(summary = "取消装机")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devInstallCancel(@Valid @RequestBody DevCancelReqVO cancelReqVO) {

        // 【主/围观】按「患者 + 检查项目」反查工位再校验主人身份
        roomService.assertBedOwnerByPatient(cancelReqVO.getPatId(), cancelReqVO.getCheckType());

        return devRentService.cancelInstallOperation(cancelReqVO);

    }



    @RequireBedOwner("设备遗失")

    @PostMapping("/dev-lose")

    @Operation(summary = "遗失")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devLose(@Valid @RequestBody DevRentSaveReqVO loseReqVO) {

        loseReqVO.setState(DevStateEnum.LOST.getState());

        return devRentService.dismantleExceptionOperation(loseReqVO);

    }



    @RequireBedOwner("设备损坏")

    @PostMapping("/dev-damage")

    @Operation(summary = "损坏")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> devDamage(@Valid @RequestBody DevRentSaveReqVO damageReqVO) {

        damageReqVO.setState(DevStateEnum.DAMAGED.getState());

        return devRentService.dismantleExceptionOperation(damageReqVO);

    }



    @PostMapping("/create")

    @Operation(summary = "创建装机拆机")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Long> createDevRent(@Valid @RequestBody DevRentSaveReqVO createReqVO) {

        return CommonResult.success(devRentService.createDevRent(createReqVO));

    }



    @PutMapping("/update")

    @Operation(summary = "更新装机拆机")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Boolean> updateDevRent(@Valid @RequestBody DevRentSaveReqVO updateReqVO) {

        devRentService.updateDevRent(updateReqVO);

        return CommonResult.success(true);

    }



    @DeleteMapping("/delete")

    @Operation(summary = "删除装机拆机")

    @Parameter(name = "id", description = "编号", required = true)

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Boolean> deleteDevRent(@RequestParam("id") Long id) {

        devRentService.deleteDevRent(id);

        return CommonResult.success(true);

    }



    @GetMapping("/get")

    @Operation(summary = "获得装机拆机")

    @Parameter(name = "id", description = "编号", required = true, example = "1024")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<DevRentRespVO> getDevRent(@RequestParam("id") Long id) {

        DevRentDO devRent = devRentService.getDevRent(id);



        DevRentRespVO devRentRespVO = BeanUtils.toBean(devRent, DevRentRespVO.class);



        DeviceDO deviceDO = deviceService.getDevice(devRent.getDevId());

        if (null != deviceDO) {

            devRentRespVO.setCategory(deviceDO.getCategory());

            devRentRespVO.setBrand(deviceDO.getBrand());

            devRentRespVO.setModel(deviceDO.getModel());

            devRentRespVO.setDevState(deviceDO.getState());

        }

        return CommonResult.success(devRentRespVO);

    }



    @GetMapping("/page")

    @Operation(summary = "获得装机拆机分页")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<PageResult<DevRentRespVO>> getDevRentPage(@Valid DevRentPageReqVO pageReqVO) {

        PageResult<DevRentDO> pageResult = devRentService.getDevRentPage(pageReqVO);

        return CommonResult.success(BeanUtils.toBean(pageResult, DevRentRespVO.class));

    }



    @GetMapping("/export-excel")

    @Operation(summary = "导出装机拆机 Excel")

    @PreAuthorize("@ss.hasPermission('ecg:dev-rent:export')")

    @ApiAccessLog(operateType = EXPORT)

    public void exportDevRentExcel(@Valid DevRentPageReqVO pageReqVO, HttpServletResponse response) throws IOException {

        pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);

        List<DevRentDO> list = devRentService.getDevRentPage(pageReqVO).getList();

        // 导出 Excel

        ExcelUtils.write(response, "装机拆机.xls", "数据", DevRentRespVO.class, BeanUtils.toBean(list, DevRentRespVO.class));

    }



    @GetMapping("/get-free-rent")

    @Operation(summary = "根据患者或设备, 获取已领取租赁情况")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<DevRentRespVO> getFreeRent(@Valid DevRentSearchReqVO searchReqVO) {

        DevRentDO devRent = devRentService.getFreeRent(searchReqVO);

        if (null == devRent) {

            return CommonResult.success(null);

        }



        DevRentRespVO devRentRespVO = BeanUtils.toBean(devRent, DevRentRespVO.class);

        return CommonResult.success(devRentRespVO);

    }



    @GetMapping("/get-ready-rent")

    @Operation(summary = "获取已领取租赁情况")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<DevRentRespVO> getReadyRent(@Valid DevRentSearchReqVO searchReqVO) {

        DevRentDO devRent = devRentService.getReadyOrCancelledRent(searchReqVO);

        if (null == devRent) {

            return CommonResult.success(null);

        }



        DevRentRespVO devRentRespVO = BeanUtils.toBean(devRent, DevRentRespVO.class);



        DeviceDO deviceDO = deviceService.getDevice(devRent.getDevId());

        if (null != deviceDO) {

            devRentRespVO.setCategory(deviceDO.getCategory());

            devRentRespVO.setBrand(deviceDO.getBrand());

            devRentRespVO.setModel(deviceDO.getModel());

            devRentRespVO.setDevState(deviceDO.getState());

        }

        return CommonResult.success(devRentRespVO);

    }



    @GetMapping("/get-existing-rent")

    @Operation(summary = "获取已安装、已领用的租赁情况")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<DevRentRespVO> getInstalledRent(@Valid DevRentSearchReqVO searchReqVO) {

        DevRentDO devRent = devRentService.getExistingRent(searchReqVO);

        if (null == devRent) {

            return CommonResult.success(null);

        }



        DeviceDO deviceDO = deviceService.getDevice(devRent.getDevId());



        DevRentRespVO devRentRespVO = BeanUtils.toBean(devRent, DevRentRespVO.class);

        devRentRespVO.setCategory(deviceDO.getCategory());

        devRentRespVO.setBrand(deviceDO.getBrand());

        devRentRespVO.setModel(deviceDO.getModel());

        devRentRespVO.setDevState(devRent.getState());

        return CommonResult.success(devRentRespVO);

    }



    @GetMapping("/get-dismantled-rent")

    @Operation(summary = "获取已拆卸租赁情况")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<DevRentRespVO> getDismantledRent(@Valid DevRentSearchReqVO searchReqVO) {

        DevRentDO devRent = devRentService.getDismantledRent(searchReqVO);

        if (null == devRent) {

            return CommonResult.success(null);

        }



        DeviceDO deviceDO = deviceService.getDevice(devRent.getDevId());



        DevRentRespVO devRentRespVO = BeanUtils.toBean(devRent, DevRentRespVO.class);

        devRentRespVO.setCategory(deviceDO.getCategory());

        devRentRespVO.setBrand(deviceDO.getBrand());

        devRentRespVO.setModel(deviceDO.getModel());

        return CommonResult.success(devRentRespVO);

    }



    // 确费

    @GetMapping("/fee-confirm")

    @Operation(summary = "确费")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Integer> feeConfirm(@Valid Long rentId) {

        Long userId = SecurityFrameworkUtils.getLoginUserId();

        String userNickname = SecurityFrameworkUtils.getLoginUserNickname();

        String userHisId = SecurityFrameworkUtils.getLoginUserHisId();



        // 【主/围观】确费也要拦围观人：按该租赁单的患者反查其当前工位并校验主人身份。
        // 用 Soft 版本：确费常在流程末端调用，患者可能已不在队列上，查不到工位时只记警告放行。
        assertRentBedOwnerSoft(rentId);

        Integer result = devRentService.feeConfirm(rentId, userHisId, userNickname, true);

        if (1 == result) return CommonResult.error(result, "确费失败");



        return CommonResult.success(result);

    }



    // 取消确费

    @GetMapping("/fee-cancel")

    @Operation(summary = "取消确费")

    @PreAuthorize("@ss.hasPermission('ecg:doctor:task')")

    public CommonResult<Integer> feeCancel(@Valid Long rentId) {

        Long userId = SecurityFrameworkUtils.getLoginUserId();

        String userNickname = SecurityFrameworkUtils.getLoginUserNickname();

        String userHisId = SecurityFrameworkUtils.getLoginUserHisId();



        // 【主/围观】取消确费同样要拦围观人（Soft：查不到工位只记警告）
        assertRentBedOwnerSoft(rentId);

        Integer result = devRentService.feeConfirm(rentId, userHisId, userNickname, false);

        if (1 == result) return CommonResult.error(result, "取消确费失败");



        return CommonResult.success(result);

    }

    /**
     * 【主/围观】确费 / 取消确费的主人校验。
     *
     * <p>接口只带 rentId，拿不到 roomId/bedNo，因此先按租赁单找到患者，
     * 再由 {@link cn.lihu.jh.module.ecg.service.room.RoomService#assertBedOwnerByPatientSoft}
     * 按患者当前所在工位校验主人身份（查不到工位时只记警告放行，避免误伤末端流程）。
     *
     * <p>注意：只包住"读租赁单"这一步，**不能**把主人校验的异常也吞掉，否则等于没有校验。
     */
    private void assertRentBedOwnerSoft(Long rentId) {
        cn.lihu.jh.module.ecg.dal.dataobject.devrent.DevRentDO rent;
        try {
            rent = devRentService.getDevRent(rentId);
        } catch (Exception e) {
            log.error("[assertRentBedOwnerSoft] 读取租赁单失败，跳过主人校验. rentId={}", rentId, e);
            return;
        }
        roomService.assertBedOwnerByPatientSoft(null == rent ? null : rent.getPatId(),
                null == rent ? null : rent.getCheckType());
    }

}