wangyizhe/his
3
3
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

后端最新版本同步

Browse Source
This commit is contained in:
Zhang.WH
2025-09-25 10:43:25 +08:00
parent 1276dc4adb
commit c8014404f1
355 changed files with 10070 additions and 5578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

69
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IChineseMedicineDispenseAppService.java
View File

@@ -1,69 +0,0 @@
package com.openhis.web.pharmacymanage.appservice;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
/**
* 处方管理 应用实现接口
*
* @author wangyang
* @date 2025/3/18
*/
public interface IChineseMedicineDispenseAppService {
/**
* 页面初始化
*
* @return 初始化信息
*/
R<?> init();
/**
* 分页查询就诊病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 就诊病人分页列表
*/
R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
/**
* 查询处方单列表
*
* @param encounterId 就诊号
* @return 处方单列表
*/
R<?> getPrescriptionInfo(Long encounterId);
/**
* 配药
*
* @param prescriptionNo 处方号
* @param preparerId 配药人
* @return 处理结果
*/
R<?> prepare(String prescriptionNo, Long preparerId);
/**
* 处方单核对发药
*
* @param prescriptionNo 处方号
* @return 处理结果
*/
R<?> medicineDispense(String prescriptionNo);
/**
* 处方单作废
*
* @param prescriptionNo 处方号
* @param notPerformedReasonEnum 未发药原因
* @return 处理结果
*/
R<?> medicineCancel(String prescriptionNo, Integer notPerformedReasonEnum);
}

65
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IDeviceDispenseAppService.java
View File

@@ -1,65 +0,0 @@
package com.openhis.web.pharmacymanage.appservice;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.DispenseDeviceDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionDeviceInfoDto;
/**
* 材料发送 应用实现接口
*
* @author yuxj
* @date 2025/8/21
*/
public interface IDeviceDispenseAppService {
/**
* 页面初始化
*
* @return 初始化信息
*/
R<?> init();
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
/**
* 处方单查询
*
* @param prescriptionDeviceInfoDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
R<?> getPrescriptionInfo(PrescriptionDeviceInfoDto prescriptionDeviceInfoDto, Integer pageNo, Integer pageSize);
/**
* 处方单核对发药
*
* @param dispenseDeviceList 发药信息
* @return 处理结果
*/
R<?> deviceDispense(List<DispenseDeviceDto> dispenseDeviceList);
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
R<?> deviceCancel(List<DispenseDeviceDto> dispenseDeviceList);
}

31
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IInpatientMedicineDispenseAppService.java
View File

@@ -1,31 +0,0 @@
package com.openhis.web.pharmacymanage.appservice;//package com.openhis.web.pharmacymanage.appservice;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* 住院发药 应用实现接口
*
* @author yuxj
* @date 2025/6/3
*/
public interface IInpatientMedicineDispenseAppService {
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
}

1
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IInpatientMedicineSummaryDispenseAppService.java
View File

@@ -3,7 +3,6 @@ package com.openhis.web.pharmacymanage.appservice;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import com.openhis.web.pharmacymanage.dto.InpatientMedicineSearchParam;
import java.util.List;

22
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IMedicalConsumablesDispenseAppService.java
View File

@@ -1,22 +0,0 @@
package com.openhis.web.pharmacymanage.appservice;
import java.util.List;
import com.core.common.core.domain.R;
/**
* 处方管理 应用实现接口
*
* @author zwh
* @date 2025/6/20
*/
public interface IMedicalConsumablesDispenseAppService {
/**
* 发放耗材
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
R<?> dispenseMedicalConsumables(List<Long> chargeItemIds);
}

74
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IMedicalDeviceDispenseAppService.java Normal file
View File

@@ -0,0 +1,74 @@
package com.openhis.web.pharmacymanage.appservice;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.DispenseItemDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
/**
* 材料发送 应用实现接口
*
* @author yuxj
* @date 2025/8/21
*/
public interface IMedicalDeviceDispenseAppService {
/**
* 页面初始化
*
* @return 初始化信息
*/
R<?> init();
/**
* 分页查询病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 病人列表
*/
R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey, Integer pageNo, Integer pageSize,
HttpServletRequest request);
/**
* 发耗材单查询
*
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 发耗材单
*/
R<?> getDeviceDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto, Integer pageNo, Integer pageSize);
/**
* 核对发耗材
*
* @param dispenseDeviceList 发耗材信息
* @return 处理结果
*/
R<?> deviceDispense(List<DispenseItemDto> dispenseDeviceList);
/**
* 发放耗材
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
R<?> dispenseMedicalConsumables(List<Long> chargeItemIds);
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
R<?> deviceCancel(List<DispenseItemDto> dispenseDeviceList);
}

8
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IReturnMedicineAppService.java
View File

@@ -5,7 +5,7 @@ import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoDto;
import com.openhis.web.pharmacymanage.dto.ReturnMedicineDto;
/**
@@ -26,15 +26,15 @@ public interface IReturnMedicineAppService {
/**
* 查询退药患者分页列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 退药患者分页列表
*/
R<?> getReturnMedicinePatientPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
R<?> getReturnMedicinePatientPage(EncounterInfoDto encounterInfoDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
/**
* 查询退药信息

37
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/IWesternMedicineDispenseAppService.java
View File

@@ -5,9 +5,9 @@ import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionMedicineInfoDto;
import com.openhis.web.pharmacymanage.dto.DispenseItemDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
/**
* 处方管理 应用实现接口
@@ -25,27 +25,27 @@ public interface IWesternMedicineDispenseAppService {
R<?> init();
/**
* 分页查询发药病人列表
* 分页查询病人列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
* @return 病人列表
*/
R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request);
/**
* 处方单查询
*
* @param prescriptionMedicineInfoDto 查询信息
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
R<?> getPrescriptionInfo(PrescriptionMedicineInfoDto prescriptionMedicineInfoDto, Integer pageNo, Integer pageSize);
R<?> getMedicineDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto, Integer pageNo, Integer pageSize);
/**
* 配药
@@ -53,7 +53,7 @@ public interface IWesternMedicineDispenseAppService {
* @param dispenseMedicineList 配药信息
* @return 处理结果
*/
R<?> medicinePrepare(List<DispenseMedicineDto> dispenseMedicineList);
R<?> medicinePrepare(List<DispenseItemDto> dispenseMedicineList);
/**
* 处方单核对发药
@@ -61,7 +61,7 @@ public interface IWesternMedicineDispenseAppService {
* @param dispenseMedicineList 发药信息
* @return 处理结果
*/
R<?> medicineDispense(List<DispenseMedicineDto> dispenseMedicineList);
R<?> medicineDispense(List<DispenseItemDto> dispenseMedicineList);
/**
* 作废
@@ -69,18 +69,5 @@ public interface IWesternMedicineDispenseAppService {
* @param dispenseMedicineList 作废信息
* @return 处理结果
*/
R<?> medicineCancel(List<DispenseMedicineDto> dispenseMedicineList);
/**
* 处方详情
*
* @param locationId 库房id
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 单据详情
*/
R<?> getMonthlySettlementPatientInfoList(Long locationId, String startTime, String endTime,Integer pageNo, Integer pageSize);
R<?> medicineCancel(List<DispenseItemDto> dispenseMedicineList);
}

443
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/DeviceDispenseAppServiceImpl.java
View File

@@ -1,443 +0,0 @@
package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import com.openhis.web.pharmacymanage.appservice.IDeviceDispenseAppService;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.workflow.domain.DeviceDispense;
import com.openhis.workflow.service.IDeviceDispenseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.core.domain.entity.SysDictData;
import com.core.common.exception.ServiceException;
import com.core.common.utils.*;
import com.core.system.mapper.SysDictDataMapper;
import com.openhis.administration.domain.*;
import com.openhis.administration.service.*;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.utils.EnumUtils;
import com.openhis.common.utils.HisQueryUtils;
;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.IDeviceDispenseMapper;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.service.IInventoryItemService;
/**
* 材料发送 应用实现类
*
* @author yuxj
* @date 2025/8/21
*/
@Service
public class DeviceDispenseAppServiceImpl implements IDeviceDispenseAppService {
@Autowired
private IOrganizationService organizationService;
@Autowired
private IDeviceDispenseService deviceDispenseService;
@Autowired
private IInventoryItemService iInventoryItemService;
@Autowired
private IDeviceDispenseMapper deviceDispenseMapper;
@Autowired
private ReturnMedicineMapper returnMedicineMapper;
@Resource
private SysDictDataMapper sysDictDataMapper;
@Autowired
private ITraceNoManageService traceNoManageService;
@Resource
private IWesternMedicineDispenseAppServiceImpl westernMedicineDispenseAppService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@Override
public R<?> init() {
DispenseInitDto initDto = new DispenseInitDto();
// 获取科室下拉选列表
List<Organization> organizationList =
organizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
List<DispenseInitDto.DepartmentOption> organizationOptions = organizationList.stream()
.map(organization -> new DispenseInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());
// 获取配药人下拉选列表
List<Practitioner> preparerDoctorList =
deviceDispenseMapper.getPreparerDoctorList(PractitionerRoles.PHARMACIST.getCode());
List<DispenseInitDto.PreparerDoctorOption> preparerDoctorOptions = preparerDoctorList.stream()
.map(practitioner -> new DispenseInitDto.PreparerDoctorOption(practitioner.getId(), practitioner.getName()))
.collect(Collectors.toList());
// 未发药原因下拉选列表
List<DispenseInitDto.NotPerformedReasonOption> notPerformedReasonOptions =
Stream.of(NotPerformedReasonEnum.values())
.map(notPerformedReason -> new DispenseInitDto.NotPerformedReasonOption(notPerformedReason.getValue(),
notPerformedReason.getInfo()))
.collect(Collectors.toList());
// 发药状态
List<DispenseInitDto.DispenseStatusOption> dispenseStatusOptions = new ArrayList<>();
dispenseStatusOptions.add(new DispenseInitDto.DispenseStatusOption(DispenseStatus.IN_PROGRESS.getValue(),
DispenseStatus.IN_PROGRESS.getInfo()));
dispenseStatusOptions.add(new DispenseInitDto.DispenseStatusOption(DispenseStatus.COMPLETED.getValue(),
DispenseStatus.COMPLETED.getInfo()));
initDto.setDepartmentOptions(organizationOptions).setNotPerformedReasonOptions(notPerformedReasonOptions)
.setDispenseStatusOptions(dispenseStatusOptions).setPreparerDoctorOptions(preparerDoctorOptions);
return R.ok(initDto);
}
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
@Override
public R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request) {
// 发药状态初始化
Integer statusEnum = encounterInfoPageDto.getStatusEnum();
encounterInfoPageDto.setStatusEnum(null);
// 构建查询条件
QueryWrapper<EncounterInfoPageDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoPageDto, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询就诊病人列表
Page<EncounterInfoPageDto> encounterInfoPage = deviceDispenseMapper.selectEncounterInfoListPage(
new Page<>(pageNo, pageSize), queryWrapper, statusEnum, DispenseStatus.IN_PROGRESS.getValue(),
DispenseStatus.COMPLETED.getValue(), DispenseStatus.PREPARATION.getValue(),
DispenseStatus.PREPARED.getValue(), EncounterClass.AMB.getValue());
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
encounterInfo.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, encounterInfo.getGenderEnum()));
// 发药状态
encounterInfo
.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, encounterInfo.getStatusEnum()));
});
return R.ok(encounterInfoPage);
}
/**
* 处方单查询
*
* @param prescriptionDeviceInfoDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@Override
public R<?> getPrescriptionInfo(PrescriptionDeviceInfoDto prescriptionDeviceInfoDto, Integer pageNo,
Integer pageSize) {
// 发药状态初始化
Integer dispenseStatus = prescriptionDeviceInfoDto.getStatusEnum();
prescriptionDeviceInfoDto.setStatusEnum(null);
// 构建查询条件
QueryWrapper<PrescriptionDeviceInfoDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(prescriptionDeviceInfoDto, null, null, null);
// 获取所属医院id
Long hospitalId = SecurityUtils.getLoginUser().getHospitalId();
// 患者基本信息查询
PrescriptionPatientInfoDto prescriptionPatientInfoDto = deviceDispenseMapper
.selectPrescriptionPatientInfo(prescriptionDeviceInfoDto.getEncounterId(), hospitalId);
// 年龄
prescriptionPatientInfoDto.setAge(AgeCalculatorUtil.getAge(prescriptionPatientInfoDto.getBirthDate()));
// 性别
prescriptionPatientInfoDto.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, prescriptionPatientInfoDto.getGenderEnum()));
// 合同类型
if (StringUtils.isNotNull(prescriptionPatientInfoDto.getCategoryEnum())) {
prescriptionPatientInfoDto.setCategoryEnum_enumText(
EnumUtils.getInfoByValue(FinCategory.class, prescriptionPatientInfoDto.getCategoryEnum()));
}
// 处方单信息查询
Page<PrescriptionDeviceInfoDto> prescriptionDeviceInfoPage =
deviceDispenseMapper.selectPrescriptionDeviceInfoList(new Page<>(pageNo, pageSize), queryWrapper,
DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue(), dispenseStatus);
// 查询字典值
List<SysDictData> unitCodeList = sysDictDataMapper.selectDictDataByType("unit_code");
Map<String, String> unitCodeLabel = unitCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<SysDictData> methodCodeList = sysDictDataMapper.selectDictDataByType("method_code");
Map<String, String> methodCodeLabel = methodCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<PrescriptionDeviceInfoDto> prescriptionDeviceInfoList = prescriptionDeviceInfoPage.getRecords();
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
);
prescriptionDeviceInfoList.forEach(prescriptionDeviceInfo -> {
// 发药状态
prescriptionDeviceInfo.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, prescriptionDeviceInfo.getStatusEnum()));
// // 匹配剂量单位字典文本
// String doseUnitCode = prescriptionDeviceInfo.getDoseUnitCode();
// String doseUnitLabel = unitCodeLabel.getOrDefault(doseUnitCode, "");
// prescriptionDeviceInfo.setDoseUnitCode_dictText(doseUnitLabel);
// 匹配单位字典文本
String unitCode = prescriptionDeviceInfo.getUnitCode();
String unitLabel = unitCodeLabel.getOrDefault(unitCode, "");
prescriptionDeviceInfo.setUnitCode_dictText(unitLabel);
// // 匹配用法字典文本
// String methodCode = prescriptionDeviceInfo.getMethodCode();
// String methodLabel = methodCodeLabel.getOrDefault(methodCode, "");
// prescriptionDeviceInfo.setMethodCode_dictText(methodLabel);
// switch (prescriptionDeviceInfo.getPharmacologyCategoryCode()) {
// case "2": // 麻醉药品
// prescriptionDeviceInfo.setPharmacologyCategoryCode_Text("麻醉");
// case "3": // 毒性药品
// prescriptionDeviceInfo.setPharmacologyCategoryCode_Text("毒性");
// case "4": // 一类精神药
// prescriptionDeviceInfo.setPharmacologyCategoryCode_Text("精一");
// case "5": // 二类精神药
// prescriptionDeviceInfo.setPharmacologyCategoryCode_Text("精二");
// default: // 普通药品
// prescriptionDeviceInfo.setPharmacologyCategoryCode_Text("普通");
// }
// 判断是否为慢病
if (EncounterYbClass.CHRONIC_DISEASE_OUTPATIENT.getCode()
.equals(prescriptionDeviceInfo.getMedTypeCode())) {
prescriptionDeviceInfo.setChronicDisease(Whether.YES.getInfo());
} else {
prescriptionDeviceInfo.setChronicDisease(Whether.NO.getInfo());
}
// // 皮试flag为是时
// if (Whether.YES.getValue().equals(prescriptionDeviceInfo.getSkinTestFlag())) {
// // 获取皮试结果
// ServiceRequest serReqObj =
// serviceRequestService.selectByMedRequestId(prescriptionDeviceInfo.getRequestId());
// if (serReqObj != null) {
// Integer clinicalStatus = allergyIntoleranceService.getPsResultByRequestId(serReqObj.getId());
// prescriptionDeviceInfo.setPsResult(ClinicalStatus.getByValue(clinicalStatus).getInfo());
// }
// } else {
// prescriptionDeviceInfo.setPsResult("无");
// }
});
// 计算合计金额
if (!prescriptionDeviceInfoList.isEmpty()) {
double totalPrice = 0d;
for (PrescriptionDeviceInfoDto item : prescriptionDeviceInfoList) {
totalPrice += item.getTotalPrice().doubleValue();
}
prescriptionPatientInfoDto.setTotalPrice(totalPrice);
}
PrescriptionInfoDto prescriptionInfoDto = new PrescriptionInfoDto();
prescriptionInfoDto.setPrescriptionPatientInfoDto(prescriptionPatientInfoDto);
prescriptionInfoDto.setPrescriptionDeviceInfoDtoList(prescriptionDeviceInfoList);
return R.ok(prescriptionInfoDto);
}
/**
* 处方单核对发药
*
* @param dispenseDeviceList 发药信息
* @return 处理结果
*/
@Override
public R<?> deviceDispense(List<DispenseDeviceDto> dispenseDeviceList) {
List<InventoryItem> inventoryItemList = new ArrayList<>();
// 获取发药单id列表
List<Long> devDispenseIdList =
dispenseDeviceList.stream().map(DispenseDeviceDto::getDispenseId).collect(Collectors.toList());
// 获取药品申请id列表
List<Long> devRequestIdList =
dispenseDeviceList.stream().map(DispenseDeviceDto::getRequestId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(devDispenseIdList, null,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
// 按每个药品分组
Map<Long, List<InventoryDto>> groupedByItemId =
inventoryList.stream().collect(Collectors.groupingBy(InventoryDto::getItemId));
// 遍历每个分组校验库存状态
for (Map.Entry<Long, List<InventoryDto>> entry : groupedByItemId.entrySet()) {
List<InventoryDto> groupItems = entry.getValue();
if (groupItems.stream().map(InventoryDto::getInventoryStatusEnum)
.allMatch(x -> x.equals(PublicationStatus.RETIRED.getValue()))) {
// 库存停供校验
return R.fail(groupItems.get(0).getItemName() + "库存已停供");
}
}
if (!inventoryList.isEmpty()) {
for (InventoryDto inventoryDto : inventoryList) {
if (PublicationStatus.ACTIVE.getValue().equals(inventoryDto.getInventoryStatusEnum())) {
InventoryItem inventoryItem = new InventoryItem();
// 库存数量判定
if (inventoryDto.getDispenseUnit().equals(inventoryDto.getInventoryUnitCode())) {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
BigDecimal quantity = inventoryDto.getInventoryQuantity().subtract(inventoryDto.getQuantity());
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
} else {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-拆零数量（拆零比×请求数量）
BigDecimal quantity = inventoryDto.getInventoryQuantity()
.subtract(inventoryDto.getPartPercent().multiply(inventoryDto.getQuantity()));
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
}
inventoryItemList.add(inventoryItem);
}
}
}
// 材料发放信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
// 追溯码列表
List<TraceNoManage> tracesNoManageList = new ArrayList<>();
TraceNoManage traceNoManage;
if (dispenseList != null) {
if (dispenseList.stream().map(DeviceDispense::getStatusEnum)
.anyMatch(x -> x.equals(DispenseStatus.COMPLETED.getValue()))) {
throw new ServiceException("材料已发放，请勿重复发放");
} else {
for (DeviceDispense deviceDispense : dispenseList) {
// 材料发放状态
deviceDispense.setStatusEnum(DispenseStatus.COMPLETED.getValue());
// 发药数量
deviceDispense.setDispenseQuantity(deviceDispense.getQuantity());
// 发药时间
deviceDispense.setDispenseTime(DateUtils.getNowDate());
// 发药人
deviceDispense.setPerformerId(SecurityUtils.getLoginUser().getPractitionerId());
// 根据数量设置追溯码
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA,
Collections.nCopies(deviceDispense.getQuantity(), CommonConstants.Common.DEV_TRACE_NO)));
// 使用逗号分割追溯码并转换为List
String[] traceNoList = deviceDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION)
// 项目id
.setItemId(deviceDispense.getDeviceDefId())
// 仓库类型
.setLocationTypeEnum(LocationForm.WAREHOUSE.getValue())
// 仓库
.setLocationId(deviceDispense.getLocationId())
// 产品批号
.setLotNumber(deviceDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.OUT.getValue())
// 追溯码单位
.setUnitCode(deviceDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.DISPENSE_MEDICATION.getValue());
tracesNoManageList.add(traceNoManage);
}
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
}
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 库存更新
iInventoryItemService.updateBatchById(inventoryItemList);
// 追溯码管理表数据追加
boolean result = traceNoManageService.saveBatch(tracesNoManageList);
if (!result) {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 返回信息
String returnMsg = null;
// 调用医保商品销售接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH);
// 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
List<String> uploadFailedNoList =
westernMedicineDispenseAppService.ybMedicineIntegrated(null, devDispenseIdList);
if (uploadFailedNoList != null) {
returnMsg = "3505商品销售上传错误，错误项目编码" + uploadFailedNoList;
} else {
returnMsg = "3505商品销售上传成功";
}
}
return R.ok(returnMsg, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
@Override
public R<?> deviceCancel(List<DispenseDeviceDto> dispenseDeviceList) {
// 获取发材料单id列表
List<Long> devDispenseIdList =
dispenseDeviceList.stream().map(DispenseDeviceDto::getDispenseId).collect(Collectors.toList());
// 材料发放信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
if (dispenseList != null) {
for (DeviceDispense medicationDispense : dispenseList) {
// 材料发放状态
medicationDispense.setStatusEnum(DispenseStatus.DECLINED.getValue());
// 未发药原因
medicationDispense.setNotPerformedReasonEnum(dispenseDeviceList.get(0).getNotPerformedReasonEnum());
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
return R.ok(MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
}

329
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/IChineseMedicineDispenseAppServiceImpl.java
View File

@@ -1,329 +0,0 @@
package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.servlet.http.HttpServletRequest;
import com.openhis.yb.service.YbManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.utils.*;
import com.openhis.administration.domain.Organization;
import com.openhis.administration.service.IOrganizationService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.utils.EnumUtils;
import com.openhis.common.utils.HisQueryUtils;
import com.openhis.medication.domain.MedicationDispense;
import com.openhis.medication.service.IMedicationDispenseService;
import com.openhis.web.pharmacymanage.appservice.IChineseMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.ChineseMedicineDispenseMapper;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.service.IInventoryItemService;
/**
* 中药发放 应用实现类
*
* @author wangyang
* @date 2025/3/14
*/
@Service
public class IChineseMedicineDispenseAppServiceImpl implements IChineseMedicineDispenseAppService {
@Autowired
private IOrganizationService iOrganizationService;
@Autowired
IMedicationDispenseService iMedicationDispenseService;
@Autowired
IInventoryItemService iInventoryItemService;
@Autowired
ChineseMedicineDispenseMapper chineseMedicineDispenseMapper;
@Autowired
YbManager ybService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@Override
public R<?> init() {
DispenseInitDto initDto = new DispenseInitDto();
// 获取科室下拉选列表
List<Organization> organizationList =
iOrganizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
List<DispenseInitDto.DepartmentOption> organizationOptions = organizationList.stream()
.map(organization -> new DispenseInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());
// 未发药原因下拉选列表
List<DispenseInitDto.NotPerformedReasonOption> notPerformedReasonOptions =
Stream.of(NotPerformedReasonEnum.values())
.map(notPerformedReason -> new DispenseInitDto.NotPerformedReasonOption(notPerformedReason.getValue(),
notPerformedReason.getInfo()))
.collect(Collectors.toList());
initDto.setDepartmentOptions(organizationOptions).setNotPerformedReasonOptions(notPerformedReasonOptions);
return R.ok(initDto);
}
/**
* 分页查询就诊病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 就诊病人列表
*/
@Override
public R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
Integer pageNo, Integer pageSize, HttpServletRequest request) {
// 构建查询条件
QueryWrapper<EncounterInfoSearchParam> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoSearchParam, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询就诊病人列表
Page<EncounterInfoPageDto> encounterInfoPage =
chineseMedicineDispenseMapper.selectEncounterInfoListPage(new Page<>(pageNo, pageSize), queryWrapper);
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
encounterInfo.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, encounterInfo.getGenderEnum()));
// 性别
encounterInfo
.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, encounterInfo.getStatusEnum()));
});
return R.ok(encounterInfoPage);
}
/**
* 查询处方单列表
*
* @param encounterId 就诊号
* @return 处方单列表
*/
@Override
public R<?> getPrescriptionInfo(Long encounterId) {
// 患者基本信息查询
PrescriptionPatientInfoDto prescriptionPatientInfoDto =
chineseMedicineDispenseMapper.selectPrescriptionPatientInfo(encounterId);
// 年龄
prescriptionPatientInfoDto.setAge(AgeCalculatorUtil.getAge(prescriptionPatientInfoDto.getBirthDate()));
// 性别
prescriptionPatientInfoDto.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, prescriptionPatientInfoDto.getGenderEnum()));
// 合同类型
if (StringUtils.isNotNull(prescriptionPatientInfoDto.getCategoryEnum())) {
prescriptionPatientInfoDto.setCategoryEnum_enumText(
EnumUtils.getInfoByValue(FinCategory.class, prescriptionPatientInfoDto.getCategoryEnum()));
}
// 处方单信息查询
List<PrescriptionMedicineInfoDto> prescriptionMedicineInfoList =
chineseMedicineDispenseMapper.selectPrescriptionMedicineInfoList(encounterId);
// 计算合计金额
if (!prescriptionMedicineInfoList.isEmpty()) {
double totalPrice = 0d;
for (PrescriptionMedicineInfoDto item : prescriptionMedicineInfoList) {
totalPrice += item.getTotalPrice().doubleValue();
}
prescriptionPatientInfoDto.setTotalPrice(totalPrice);
}
PrescriptionInfoDto prescriptionInfoDto = new PrescriptionInfoDto();
prescriptionInfoDto.setPrescriptionPatientInfoDto(prescriptionPatientInfoDto);
prescriptionInfoDto.setPrescriptionMedicineInfoDtoList(prescriptionMedicineInfoList);
return R.ok(prescriptionInfoDto);
}
/**
* 配药
*
* @param prescriptionNo 处方号
* @param preparerId 配药人
* @return 处理结果
*/
@Override
public R<?> prepare(String prescriptionNo, Long preparerId) {
List<MedicationDispense> medicationDispenseList = new ArrayList<>();
boolean iMedicationDispenseUpdFlg = true;
// 配药人检查
if (!preparerId.equals(SecurityUtils.getLoginUser().getPractitionerId())) {
// 获取药品待发放信息
List<DispenseInventoryDto> dispenseInventoryList =
chineseMedicineDispenseMapper.selectDispenseInventoryInfoByPrescriptionNo(prescriptionNo,
CommonConstants.TableName.MED_MEDICATION_DEFINITION);
if (!dispenseInventoryList.isEmpty()) {
MedicationDispense medicationDispense;
for (DispenseInventoryDto dispenseInventoryDto : dispenseInventoryList) {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
BigDecimal quantity = dispenseInventoryDto.getInventoryQuantity()
.subtract(new BigDecimal(dispenseInventoryDto.getDispenseQuantity()));
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Inventory.M00002, null));
}
// 药品发放表项目设定
medicationDispense = new MedicationDispense();
// id
medicationDispense.setId(dispenseInventoryDto.getDispenseId());
// 药品发放状态
medicationDispense.setStatusEnum(DispenseStatus.PREPARED.getValue());
// 状态变更时间
medicationDispense.setStatusChangedTime(DateUtils.getNowDate());
// 配药人
medicationDispense.setPreparerId(preparerId);
// 配药时间
medicationDispense.setPrepareTime(DateUtils.getNowDate());
medicationDispenseList.add(medicationDispense);
}
// 药品发放更新
iMedicationDispenseUpdFlg = iMedicationDispenseService.updateBatchById(medicationDispenseList);
return iMedicationDispenseUpdFlg
? R.ok(MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null))
: R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00011, null));
}
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00010, null));
}
return R.fail(MessageUtils.createMessage(PromptMsgConstant.MedicationDispense.M00001, null));
}
/**
* 处方单核对发药
*
* @param prescriptionNo 处方号
* @return 处理结果
*/
@Override
public R<?> medicineDispense(String prescriptionNo) {
List<MedicationDispense> medicationDispenseList = new ArrayList<>();
List<InventoryItem> inventoryItemList = new ArrayList<>();
boolean iMedicationDispenseUpdFlg = true;
boolean iInventoryItemUpdFlg = true;
// 获取药品待发放和库存信息
List<DispenseInventoryDto> dispenseInventoryList =
chineseMedicineDispenseMapper.selectDispenseInventoryInfoByPrescriptionNo(prescriptionNo,
CommonConstants.TableName.MED_MEDICATION_DEFINITION);
if (!dispenseInventoryList.isEmpty()) {
MedicationDispense medicationDispense;
InventoryItem inventoryItem;
for (DispenseInventoryDto dispenseInventoryDto : dispenseInventoryList) {
// 药品发放表项目设定
medicationDispense = new MedicationDispense();
// id
medicationDispense.setId(dispenseInventoryDto.getDispenseId());
// 药品发放状态
medicationDispense.setStatusEnum(DispenseStatus.COMPLETED.getValue());
// 状态变更时间
medicationDispense.setStatusChangedTime(DateUtils.getNowDate());
// 发药人
medicationDispense.setPractitionerId(SecurityUtils.getLoginUser().getPractitionerId());
// 已发药数量
medicationDispense.setDispenseQuantity(dispenseInventoryDto.getDispenseQuantity());
// 发药时间
medicationDispense.setDispenseTime(DateUtils.getNowDate());
medicationDispenseList.add(medicationDispense);
// 库存表项目设定
inventoryItem = new InventoryItem();
inventoryItem.setId(dispenseInventoryDto.getInventoryId());
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
inventoryItem.setQuantity(dispenseInventoryDto.getInventoryQuantity()
.subtract(new BigDecimal(dispenseInventoryDto.getDispenseQuantity())));
inventoryItemList.add(inventoryItem);
}
// 药品发放更新
iMedicationDispenseUpdFlg = iMedicationDispenseService.updateBatchById(medicationDispenseList);
// 库存更新
iInventoryItemUpdFlg = iInventoryItemService.updateBatchById(inventoryItemList);
return iMedicationDispenseUpdFlg && iInventoryItemUpdFlg
? R.ok(MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null))
: R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00011, null));
}
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00010, null));
}
/**
* 作废
*
* @param prescriptionNo 处方号
* @param notPerformedReasonEnum 未发药原因
* @return 处理结果
*/
@Override
public R<?> medicineCancel(String prescriptionNo, Integer notPerformedReasonEnum) {
List<MedicationDispense> medicationDispenseList = new ArrayList<>();
boolean iMedicationDispenseUpdFlg = true;
// 获取药品待发放记录
List<DispenseInventoryDto> dispenseInventoryList =
chineseMedicineDispenseMapper.selectDispenseInventoryInfoByPrescriptionNo(prescriptionNo,
CommonConstants.TableName.MED_MEDICATION_DEFINITION);
if (!dispenseInventoryList.isEmpty()) {
MedicationDispense medicationDispense;
for (DispenseInventoryDto dispenseInventoryDto : dispenseInventoryList) {
// 药品发放表项目设定
medicationDispense = new MedicationDispense();
// id
medicationDispense.setId(dispenseInventoryDto.getDispenseId());
// 药品发放状态
medicationDispense.setStatusEnum(DispenseStatus.DECLINED.getValue());
// 未发药原因
medicationDispense.setNotPerformedReasonEnum(notPerformedReasonEnum);
// 状态变更时间
medicationDispense.setStatusChangedTime(DateUtils.getNowDate());
// 发药人
medicationDispense.setPractitionerId(SecurityUtils.getLoginUser().getPractitionerId());
medicationDispenseList.add(medicationDispense);
}
// 药品发放更新
iMedicationDispenseUpdFlg = iMedicationDispenseService.updateBatchById(medicationDispenseList);
}
return iMedicationDispenseUpdFlg ? R.ok(null, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null))
: R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00010, null));
}
}

226
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/IMedicalConsumablesDispenseAppServiceImpl.java
View File

@@ -1,226 +0,0 @@
package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.core.common.core.domain.R;
import com.core.common.exception.ServiceException;
import com.core.common.utils.DateUtils;
import com.core.common.utils.MessageUtils;
import com.core.common.utils.SecurityUtils;
import com.openhis.administration.domain.ChargeItem;
import com.openhis.administration.service.IChargeItemService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.DispenseStatus;
import com.openhis.common.enums.HospitalCodeEnum;
import com.openhis.common.enums.PublicationStatus;
import com.openhis.common.enums.Whether;
import com.openhis.web.inventorymanage.appservice.ITraceNoAppService;
import com.openhis.web.pharmacymanage.appservice.IMedicalConsumablesDispenseAppService;
import com.openhis.web.pharmacymanage.dto.InventoryDto;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.workflow.domain.DeviceDispense;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.service.IDeviceDispenseService;
import com.openhis.workflow.service.IDeviceRequestService;
import com.openhis.workflow.service.IInventoryItemService;
/*
*
*
* 耗材发放 应用实现类
*
* @author wangyang
*
* @date 2025/3/14
*
*/
@Service
public class IMedicalConsumablesDispenseAppServiceImpl implements IMedicalConsumablesDispenseAppService {
@Resource
private ITraceNoAppService traceNoAppService;
@Resource
private IDeviceDispenseService deviceDispenseService;
@Resource
private IDeviceRequestService deviceRequestService;
@Resource
private ReturnMedicineMapper returnMedicineMapper;
@Resource
private IInventoryItemService iInventoryItemService;
@Resource
private IWesternMedicineDispenseAppServiceImpl westernMedicineDispenseAppService;
@Resource
private IChargeItemService chargeItemService;
/**
* 发放耗材
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
@Override
public R<?> dispenseMedicalConsumables(List<Long> chargeItemIds) {
// 查看所属医院
String fixmedinsCode =
SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.FIXMEDINS_CODE);
if (!HospitalCodeEnum.CCU.getCode().equals(fixmedinsCode)) {
return R.ok();
}
List<ChargeItem> chargeItemList = chargeItemService.listByIds(chargeItemIds);
if (chargeItemList == null || chargeItemList.isEmpty()) {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
List<InventoryItem> inventoryItemList = new ArrayList<>();
// 获取发申请id列表
List<Long> devRequestIdList =
chargeItemList.stream().map(ChargeItem::getServiceId).collect(Collectors.toList());
// 获取耗材发放id列表
List<Long> devDispenseIdList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getDeviceReqId, devRequestIdList))
.stream().map(DeviceDispense::getId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(devDispenseIdList, null,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
// 按每个耗材分组
Map<Long, List<InventoryDto>> groupedByItemId =
inventoryList.stream().collect(Collectors.groupingBy(InventoryDto::getItemId));
// 遍历每个分组校验库存状态
for (Map.Entry<Long, List<InventoryDto>> entry : groupedByItemId.entrySet()) {
List<InventoryDto> groupItems = entry.getValue();
if (groupItems.stream().map(InventoryDto::getInventoryStatusEnum)
.allMatch(x -> x.equals(PublicationStatus.RETIRED.getValue()))) {
// 库存停供校验
return R.fail(groupItems.get(0).getItemName() + "库存已停供");
}
}
if (!inventoryList.isEmpty()) {
for (InventoryDto inventoryDto : inventoryList) {
if (PublicationStatus.ACTIVE.getValue().equals(inventoryDto.getInventoryStatusEnum())) {
InventoryItem inventoryItem = new InventoryItem();
// 库存数量判定
if (inventoryDto.getDispenseUnit().equals(inventoryDto.getInventoryUnitCode())) {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
BigDecimal quantity = inventoryDto.getInventoryQuantity().subtract(inventoryDto.getQuantity());
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
} else {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-拆零数量（拆零比×请求数量）
BigDecimal quantity = inventoryDto.getInventoryQuantity()
.subtract(inventoryDto.getPartPercent().multiply(inventoryDto.getQuantity()));
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
}
inventoryItemList.add(inventoryItem);
}
}
}
// 发耗材信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
// todo 耗材追溯码待定
// // 追溯码列表
// List<TraceNoInfoParam> traceNoInfoList = new ArrayList<>();
// TraceNoInfoParam traceNoInfo;
if (dispenseList != null) {
if (dispenseList.stream().map(DeviceDispense::getStatusEnum)
.anyMatch(x -> x.equals(DispenseStatus.COMPLETED.getValue()))) {
throw new ServiceException("耗材已发放，请勿重复操作");
} else {
for (DeviceDispense deviceDispense : dispenseList) {
// 耗材发放状态
deviceDispense.setStatusEnum(DispenseStatus.COMPLETED.getValue());
// 发药数量
deviceDispense.setDispenseQuantity(deviceDispense.getQuantity());
// 发药时间
deviceDispense.setDispenseTime(DateUtils.getNowDate());
// 发药人（长大写死发耗材人）
deviceDispense.setPerformerId(CommonConstants.CCU.DisDeviceDoctor);
// 根据数量设置追溯码
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA,
Collections.nCopies(deviceDispense.getQuantity(), CommonConstants.Common.DEV_TRACE_NO)));
// // 使用逗号分割追溯码并转换为List
// String[] traceNoList = deviceDispense.getTraceNo().split(",");
// for (String item : traceNoList) {
// traceNoInfo = new TraceNoInfoParam();
// // 追溯码处理
// // 项目所属表
// traceNoInfo.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION)
// // 项目id
// .setItemId(deviceDispense.getDeviceDefId())
// // 仓库类型
// .setLocationTypeEnum(null)
// // 仓库
// .setLocationId(deviceDispense.getLocationId())
// // 仓位
// .setLocationStoreId(null)
// // 产品批号
// .setLotNumber(deviceDispense.getLotNumber())
// // 追溯码
// .setTraceNo(item)
// // 追溯码状态
// .setStatusEnum(TraceNoStatus.OUT.getValue())
// // 追溯码单位
// .setUnitCode(deviceDispense.getUnitCode())
// // 操作类型
// .setOperationType(SupplyType.DISPENSE_MEDICATION.getValue());
// traceNoInfoList.add(traceNoInfo);
// }
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
}
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 库存更新
iInventoryItemService.updateBatchById(inventoryItemList);
// // 追溯码管理表数据追加
// R<?> request = traceNoAppService.addTraceNoInfo(traceNoInfoList);
// if (request.getCode() != 200) {
// return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
// }
// 返回信息
String returnMsg = null;
// 调用医保商品销售接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH);
// 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
List<String> uploadFailedNoList =
westernMedicineDispenseAppService.ybMedicineIntegrated(null, devDispenseIdList);
if (uploadFailedNoList != null) {
returnMsg = "3505商品销售上传错误，错误项目编码" + uploadFailedNoList;
} else {
returnMsg = "3505商品销售上传成功";
}
}
return R.ok(returnMsg, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
}

99
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/InpatientMedicineDispenseAppServiceImpl.java
View File

@@ -1,99 +0,0 @@
package com.openhis.web.pharmacymanage.appservice.impl;//package com.openhis.web.pharmacymanage.appservice.impl;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.core.domain.entity.SysDictData;
import com.core.common.exception.ServiceException;
import com.core.common.utils.*;
import com.core.system.mapper.SysDictDataMapper;
import com.openhis.administration.domain.*;
import com.openhis.administration.service.IAccountService;
import com.openhis.administration.service.IChargeItemService;
import com.openhis.administration.service.IEncounterDiagnosisService;
import com.openhis.administration.service.IOrganizationService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.enums.ybenums.YbMdtrtCertType;
import com.openhis.common.utils.EnumUtils;
import com.openhis.common.utils.HisQueryUtils;
import com.openhis.financial.domain.Contract;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.financial.service.IContractService;
import com.openhis.financial.service.IPaymentReconciliationService;
import com.openhis.medication.domain.MedicationDispense;
import com.openhis.medication.service.IMedicationDispenseService;
import com.openhis.medication.service.IMedicationRequestService;
import com.openhis.web.pharmacymanage.appservice.IInpatientMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.InpatientMedicineDispenseMapper;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.web.pharmacymanage.mapper.WesternMedicineDispenseMapper;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.service.IInventoryItemService;
import com.openhis.yb.domain.ClinicSettle;
import com.openhis.yb.dto.Medical3505Param;
import com.openhis.yb.service.IClinicSettleService;
import com.openhis.yb.service.YbManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 住院发放 应用实现类
*
* @author yuxj
* @date 2025/6/3
*/
@Service public class InpatientMedicineDispenseAppServiceImpl implements IInpatientMedicineDispenseAppService {
@Autowired
private WesternMedicineDispenseMapper westernMedicineDispenseMapper;
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
@Override
public R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request) {
// 发药状态初始化
Integer statusEnum = encounterInfoPageDto.getStatusEnum();
encounterInfoPageDto.setStatusEnum(null);
// 构建查询条件
QueryWrapper<EncounterInfoPageDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoPageDto, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询就诊病人列表
Page<EncounterInfoPageDto> encounterInfoPage = westernMedicineDispenseMapper.selectEncounterInfoListPage(
new Page<>(pageNo, pageSize), queryWrapper, statusEnum, DispenseStatus.IN_PROGRESS.getValue(),
DispenseStatus.COMPLETED.getValue(), DispenseStatus.PREPARATION.getValue(),
DispenseStatus.PREPARED.getValue(), EncounterClass.IMP.getValue());
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
encounterInfo.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, encounterInfo.getGenderEnum()));
// 发药状态
encounterInfo
.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, encounterInfo.getStatusEnum()));
});
return R.ok(encounterInfoPage);
}
}

56
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/InpatientMedicineSummaryDispenseAppServiceImpl.java
View File

@@ -1,61 +1,51 @@
package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.constant.HttpStatus;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.administration.domain.*;
import com.openhis.common.annotation.Dict;
import com.openhis.common.utils.HisQueryUtils;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.medication.domain.MedicationRequest;
import com.openhis.web.inhospitalnursestation.appservice.IInpatientMedicineCollectionAppService;
import com.openhis.web.pharmacyDispensarymanage.appservice.IPharmacyDispensaryDispensingOrderService;
import com.openhis.web.pharmacyWarehousemanage.dto.PharmacyWarehouseDetailDto;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.workflow.domain.DeviceDispense;
import com.openhis.workflow.domain.SupplyDelivery;
import com.openhis.workflow.domain.SupplyRequest;
import com.openhis.workflow.service.IDeviceDispenseService;
import com.openhis.yb.service.YbManager;
import com.openhis.web.pharmacymanage.dto.InpatientMedicineSummaryDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.constant.HttpStatus;
import com.core.common.core.domain.R;
import com.core.common.exception.ServiceException;
import com.core.common.utils.DateUtils;
import com.core.common.utils.MessageUtils;
import com.core.common.utils.SecurityUtils;
import com.core.system.mapper.SysDictDataMapper;
import com.openhis.administration.service.*;
import com.openhis.administration.domain.Practitioner;
import com.openhis.administration.domain.TraceNoManage;
import com.openhis.administration.service.ILocationService;
import com.openhis.administration.service.IPractitionerService;
import com.openhis.administration.service.ITraceNoManageService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.utils.EnumUtils;
import com.openhis.financial.service.IContractService;
import com.openhis.financial.service.IPaymentReconciliationService;
import com.openhis.common.utils.HisQueryUtils;
import com.openhis.medication.domain.MedicationDispense;
import com.openhis.medication.service.IMedicationDispenseService;
import com.openhis.medication.service.IMedicationRequestService;
import com.openhis.web.inhospitalnursestation.appservice.IInpatientMedicineCollectionAppService;
import com.openhis.web.pharmacymanage.appservice.IInpatientMedicineSummaryDispenseAppService;
import com.openhis.web.pharmacymanage.dto.InpatientMedicineInitDto;
import com.openhis.web.pharmacymanage.dto.InpatientMedicineSearchParam;
import com.openhis.web.pharmacymanage.mapper.InpatientMedicineSummaryDispenseMapper;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.workflow.domain.DeviceDispense;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.domain.SupplyDelivery;
import com.openhis.workflow.domain.SupplyRequest;
import com.openhis.workflow.service.IDeviceDispenseService;
import com.openhis.workflow.service.IInventoryItemService;
import com.openhis.workflow.service.ISupplyDeliveryService;
import com.openhis.workflow.service.ISupplyRequestService;
import com.openhis.yb.service.IClinicSettleService;
/**
* 住院汇总发放 应用实现类
@@ -92,7 +82,7 @@ public class InpatientMedicineSummaryDispenseAppServiceImpl implements IInpatien
@Autowired
private ITraceNoManageService traceNoManageService;
@Autowired
private IWesternMedicineDispenseAppServiceImpl westernMedicineDispenseAppServiceImpl;
private WesternMedicineDispenseAppServiceImpl westernMedicineDispenseAppServiceImpl;
@Autowired
private IInpatientMedicineCollectionAppService inpatientMedicineCollectionAppService;
@@ -158,23 +148,23 @@ public class InpatientMedicineSummaryDispenseAppServiceImpl implements IInpatien
queryWrapper.orderByDesc(CommonConstants.FieldName.applyTime);
// 查询医嘱详细信息
Page<InpatientMedicineSummaryPrescriptionInfoDto> prescriptionItemInfoPageDto =
Page<InpatientMedicineSummaryDto> prescriptionItemInfoPageDto =
inpatientMedicineDispenseMapper.selectMedicationSummaryInfo(new Page<>(pageNo, pageSize), queryWrapper,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION,
SupplyType.DISPENSING_ORDER.getValue(), SupplyCategory.INPATIENT_PATIENT_SUMMARY_DISPENSING.getValue());
List<InpatientMedicineSummaryPrescriptionInfoDto.Option> unitList;
List<InpatientMedicineSummaryDto.Option> unitList;
// 个别项目设定
for (InpatientMedicineSummaryPrescriptionInfoDto prescriptionInfoDto : prescriptionItemInfoPageDto
for (InpatientMedicineSummaryDto prescriptionInfoDto : prescriptionItemInfoPageDto
.getRecords()) {
// 状态
prescriptionInfoDto.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, prescriptionInfoDto.getStatusEnum()));
// 追溯码单位列表
unitList = new ArrayList<>();
unitList.add(new InpatientMedicineSummaryPrescriptionInfoDto.Option(prescriptionInfoDto.getMaxUnitCode(),
unitList.add(new InpatientMedicineSummaryDto.Option(prescriptionInfoDto.getMaxUnitCode(),
prescriptionInfoDto.getMaxUnitCode_dictText()));
unitList.add(new InpatientMedicineSummaryPrescriptionInfoDto.Option(prescriptionInfoDto.getMinUnitCode(),
unitList.add(new InpatientMedicineSummaryDto.Option(prescriptionInfoDto.getMinUnitCode(),
prescriptionInfoDto.getMinUnitCode_dictText()));
prescriptionInfoDto.setUnitList(unitList);

542
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/MedicalDeviceDispenseAppServiceImpl.java Normal file
View File

@@ -0,0 +1,542 @@
package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.stereotype.Service;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.exception.ServiceException;
import com.core.common.utils.AgeCalculatorUtil;
import com.core.common.utils.DateUtils;
import com.core.common.utils.MessageUtils;
import com.core.common.utils.SecurityUtils;
import com.openhis.administration.domain.*;
import com.openhis.administration.service.IChargeItemService;
import com.openhis.administration.service.IDeviceDefinitionService;
import com.openhis.administration.service.IOrganizationService;
import com.openhis.administration.service.ITraceNoManageService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.enums.ybenums.YbInvChgType;
import com.openhis.common.utils.EnumUtils;
import com.openhis.common.utils.HisQueryUtils;
import com.openhis.web.inventorymanage.appservice.impl.ReceiptApprovalAppServiceImpl;
import com.openhis.web.inventorymanage.dto.SupplyItemDetailDto;
import com.openhis.web.pharmacymanage.appservice.IMedicalDeviceDispenseAppService;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.MedicalDeviceDispenseMapper;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.workflow.domain.DeviceDispense;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.service.IDeviceDispenseService;
import com.openhis.workflow.service.IInventoryItemService;
;
/**
* 材料发送 应用实现类
*
* @author yuxj
* @date 2025/8/21
*/
@Service
public class MedicalDeviceDispenseAppServiceImpl implements IMedicalDeviceDispenseAppService {
@Resource
private IOrganizationService organizationService;
@Resource
private IDeviceDispenseService deviceDispenseService;
@Resource
private IInventoryItemService inventoryItemService;
@Resource
private MedicalDeviceDispenseMapper medicalDeviceDispenseMapper;
@Resource
private ReturnMedicineMapper returnMedicineMapper;
@Resource
private ITraceNoManageService traceNoManageService;
@Resource
private WesternMedicineDispenseAppServiceImpl westernMedicineDispenseAppService;
@Resource
private IChargeItemService chargeItemService;
@Resource
private IDeviceDefinitionService deviceDefinitionService;
@Resource
private ReceiptApprovalAppServiceImpl receiptApprovalAppService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@Override
public R<?> init() {
DispenseInitDto initDto = new DispenseInitDto();
// 获取科室下拉选列表
List<Organization> organizationList =
organizationService.getList(OrganizationType.DEPARTMENT.getValue(), OrganizationClass.CLINIC.getValue());
List<DispenseInitDto.DepartmentOption> organizationOptions = organizationList.stream()
.map(organization -> new DispenseInitDto.DepartmentOption(organization.getId(), organization.getName()))
.collect(Collectors.toList());
// 获取配药人下拉选列表
List<Practitioner> preparerDoctorList =
medicalDeviceDispenseMapper.getPreparerDoctorList(PractitionerRoles.PHARMACIST.getCode());
List<DispenseInitDto.PreparerDoctorOption> preparerDoctorOptions = preparerDoctorList.stream()
.map(practitioner -> new DispenseInitDto.PreparerDoctorOption(practitioner.getId(), practitioner.getName()))
.collect(Collectors.toList());
// 未发药原因下拉选列表
List<DispenseInitDto.NotPerformedReasonOption> notPerformedReasonOptions =
Stream.of(NotPerformedReasonEnum.values())
.map(notPerformedReason -> new DispenseInitDto.NotPerformedReasonOption(notPerformedReason.getValue(),
notPerformedReason.getInfo()))
.collect(Collectors.toList());
// 发药状态
List<DispenseInitDto.DispenseStatusOption> dispenseStatusOptions = new ArrayList<>();
dispenseStatusOptions.add(new DispenseInitDto.DispenseStatusOption(DispenseStatus.IN_PROGRESS.getValue(),
DispenseStatus.IN_PROGRESS.getInfo()));
dispenseStatusOptions.add(new DispenseInitDto.DispenseStatusOption(DispenseStatus.COMPLETED.getValue(),
DispenseStatus.COMPLETED.getInfo()));
initDto.setDepartmentOptions(organizationOptions).setNotPerformedReasonOptions(notPerformedReasonOptions)
.setDispenseStatusOptions(dispenseStatusOptions).setPreparerDoctorOptions(preparerDoctorOptions);
return R.ok(initDto);
}
/**
* 分页查询病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 病人列表
*/
@Override
public R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
Integer pageNo, Integer pageSize, HttpServletRequest request) {
// 发药状态初始化
Integer statusEnum = encounterInfoSearchParam.getStatusEnum();
encounterInfoSearchParam.setStatusEnum(null);
// 构建查询条件
QueryWrapper<EncounterInfoSearchParam> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoSearchParam, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询就诊病人列表
Page<EncounterInfoDto> encounterInfoPage =
medicalDeviceDispenseMapper.selectEncounterInfoListPage(new Page<>(pageNo, pageSize), queryWrapper,
statusEnum, DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue());
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
encounterInfo.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, encounterInfo.getGenderEnum()));
// 发药状态
encounterInfo
.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, encounterInfo.getStatusEnum()));
if (encounterInfo.getBirthDate() != null) {
// 计算年龄
encounterInfo.setAge(AgeCalculatorUtil.getAge(encounterInfo.getBirthDate()));
}
});
return R.ok(encounterInfoPage);
}
/**
* 发耗材单查询
*
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 发耗材单
*/
@Override
public R<?> getDeviceDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto, Integer pageNo,
Integer pageSize) {
// 发药状态初始化
Integer dispenseStatus = itemDispenseOrderDto.getStatusEnum();
itemDispenseOrderDto.setStatusEnum(null);
// 构建查询条件
QueryWrapper<ItemDispenseOrderDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(itemDispenseOrderDto, null, null, null);
// 处方单信息查询
Page<ItemDispenseOrderDto> deviceDispenseOrderPage =
medicalDeviceDispenseMapper.selectDeviceDispenseOrderPage(new Page<>(pageNo, pageSize), queryWrapper,
DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue(), dispenseStatus);
deviceDispenseOrderPage.getRecords().forEach(deviceDispenseOrder -> {
// 发药状态
deviceDispenseOrder.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, deviceDispenseOrder.getStatusEnum()));
// 设置所在表名
deviceDispenseOrder.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION);
});
return R.ok(deviceDispenseOrderPage);
}
/**
* 核对发耗材
*
* @param dispenseDeviceList 发耗材信息
* @return 处理结果
*/
@Override
public R<?> deviceDispense(List<DispenseItemDto> dispenseDeviceList) {
// 配药人检查
if (dispenseDeviceList.get(0).getPreparerId() == null
|| dispenseDeviceList.get(0).getPreparerId().equals(SecurityUtils.getLoginUser().getPractitionerId())) {
return R.fail("请选择调配药师");
}
List<InventoryItem> inventoryItemList = new ArrayList<>();
// 获取发药单id列表
List<Long> devDispenseIdList =
dispenseDeviceList.stream().map(DispenseItemDto::getDispenseId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(devDispenseIdList, null,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
// 按每个药品分组
Map<Long, List<InventoryDto>> groupedByItemId =
inventoryList.stream().collect(Collectors.groupingBy(InventoryDto::getItemId));
// 遍历每个分组校验库存状态
for (Map.Entry<Long, List<InventoryDto>> entry : groupedByItemId.entrySet()) {
List<InventoryDto> groupItems = entry.getValue();
if (groupItems.stream().map(InventoryDto::getInventoryStatusEnum)
.allMatch(x -> x.equals(PublicationStatus.RETIRED.getValue()))) {
// 库存停供校验
return R.fail(groupItems.get(0).getItemName() + "库存已停供");
}
}
if (!inventoryList.isEmpty()) {
for (InventoryDto inventoryDto : inventoryList) {
if (PublicationStatus.ACTIVE.getValue().equals(inventoryDto.getInventoryStatusEnum())) {
InventoryItem inventoryItem = new InventoryItem();
// 库存数量判定
if (inventoryDto.getDispenseUnit().equals(inventoryDto.getInventoryUnitCode())) {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
BigDecimal quantity = inventoryDto.getInventoryQuantity().subtract(inventoryDto.getQuantity());
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
} else {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-拆零数量（拆零比×请求数量）
BigDecimal quantity = inventoryDto.getInventoryQuantity()
.subtract(inventoryDto.getPartPercent().multiply(inventoryDto.getQuantity()));
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
}
inventoryItemList.add(inventoryItem);
}
}
}
// 材料发放信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
// 追溯码列表
List<TraceNoManage> tracesNoManageList = new ArrayList<>();
TraceNoManage traceNoManage;
List<SupplyItemDetailDto> supplyItemDetailList = new ArrayList<>();
if (dispenseList != null) {
if (dispenseList.stream().map(DeviceDispense::getStatusEnum)
.anyMatch(x -> !x.equals(DispenseStatus.PREPARATION.getValue()))) {
throw new ServiceException("耗材发放失败，请检查发耗材单状态");
} else {
for (DeviceDispense deviceDispense : dispenseList) {
// 材料发放状态
deviceDispense.setStatusEnum(DispenseStatus.COMPLETED.getValue());
// 发药数量
deviceDispense.setDispenseQuantity(deviceDispense.getQuantity());
// 发药时间
deviceDispense.setDispenseTime(DateUtils.getNowDate());
// 发药人
deviceDispense.setPerformerId(SecurityUtils.getLoginUser().getPractitionerId());
// 配药时间
deviceDispense.setPrepareTime(DateUtils.getNowDate());
// 配药人
deviceDispense.setPreparerId(dispenseDeviceList.get(0).getPreparerId());
// 设置库存变更参数
supplyItemDetailList.add(new SupplyItemDetailDto().setItemId(deviceDispense.getDeviceDefId())
.setLotNumber(deviceDispense.getLotNumber())
.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION));
if (deviceDispense.getTraceNo() == null) {
// 根据数量设置追溯码
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA, Collections
.nCopies(deviceDispense.getQuantity().intValue(), CommonConstants.Common.DEV_TRACE_NO)));
} else {
// 使用逗号分割追溯码并转换为List
String[] traceNoList = deviceDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION)
// 项目id
.setItemId(deviceDispense.getDeviceDefId())
// 仓库类型
.setLocationTypeEnum(LocationForm.WAREHOUSE.getValue())
// 仓库
.setLocationId(deviceDispense.getLocationId())
// 产品批号
.setLotNumber(deviceDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.OUT.getValue())
// 追溯码单位
.setUnitCode(deviceDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.DISPENSE_MEDICATION.getValue());
tracesNoManageList.add(traceNoManage);
}
}
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
}
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 库存更新
inventoryItemService.updateBatchById(inventoryItemList);
// 追溯码管理表数据追加
traceNoManageService.saveBatch(tracesNoManageList);
// 返回信息
String returnMsg = null;
List<String> uploadFailedNoList;
// 调用医保商品销售接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH);
// 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
// 设置进销存参数
List<DeviceDefinition> deviceDefinitions = deviceDefinitionService.listByIds(
supplyItemDetailList.stream().map(SupplyItemDetailDto::getItemId).collect(Collectors.toList()));
// 用itemId分组
Map<Long, DeviceDefinition> deviceMap =
deviceDefinitions.stream().collect(Collectors.toMap(DeviceDefinition::getId, Function.identity()));
// 设置库存变更参数
for (SupplyItemDetailDto dto : supplyItemDetailList) {
if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(dto.getItemTable())) {
DeviceDefinition dev = deviceMap.get(dto.getItemId());
if (dev != null) {
dto.setItemBusNo(dev.getBusNo()).setPartPercent(dev.getPartPercent()).setRxFlag(dev.getRxFlag())
.setYbNo(dev.getYbNo());
}
}
}
uploadFailedNoList = westernMedicineDispenseAppService.ybMedicineIntegrated(null, devDispenseIdList);
uploadFailedNoList = receiptApprovalAppService.ybInventoryIntegrated(supplyItemDetailList,
YbInvChgType.OTHER_OUT, DateUtils.getNowDate());
if (uploadFailedNoList != null) {
returnMsg = "3505商品销售上传错误，错误项目编码" + uploadFailedNoList;
} else {
returnMsg = "3505商品销售上传成功";
}
}
return R.ok(returnMsg, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
/**
* 发放耗材
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
@Override
public R<?> dispenseMedicalConsumables(List<Long> chargeItemIds) {
// 查看所属医院
String fixmedinsCode =
SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.FIXMEDINS_CODE);
if (!HospitalCodeEnum.CCU.getCode().equals(fixmedinsCode)) {
return R.ok();
}
List<ChargeItem> chargeItemList = chargeItemService.listByIds(chargeItemIds);
if (chargeItemList == null || chargeItemList.isEmpty()) {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
List<InventoryItem> inventoryItemList = new ArrayList<>();
// 获取发申请id列表
List<Long> devRequestIdList =
chargeItemList.stream().map(ChargeItem::getServiceId).collect(Collectors.toList());
// 获取耗材发放id列表
List<Long> devDispenseIdList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getDeviceReqId, devRequestIdList))
.stream().map(DeviceDispense::getId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(devDispenseIdList, null,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
// 按每个耗材分组
Map<Long, List<InventoryDto>> groupedByItemId =
inventoryList.stream().collect(Collectors.groupingBy(InventoryDto::getItemId));
// 遍历每个分组校验库存状态
for (Map.Entry<Long, List<InventoryDto>> entry : groupedByItemId.entrySet()) {
List<InventoryDto> groupItems = entry.getValue();
if (groupItems.stream().map(InventoryDto::getInventoryStatusEnum)
.allMatch(x -> x.equals(PublicationStatus.RETIRED.getValue()))) {
// 库存停供校验
return R.fail(groupItems.get(0).getItemName() + "库存已停供");
}
}
if (!inventoryList.isEmpty()) {
for (InventoryDto inventoryDto : inventoryList) {
if (PublicationStatus.ACTIVE.getValue().equals(inventoryDto.getInventoryStatusEnum())) {
InventoryItem inventoryItem = new InventoryItem();
// 库存数量判定
if (inventoryDto.getDispenseUnit().equals(inventoryDto.getInventoryUnitCode())) {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-请求数量
BigDecimal quantity = inventoryDto.getInventoryQuantity().subtract(inventoryDto.getQuantity());
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
} else {
// 当前库存数量(拆零单位)=当前库存数量(拆零单位)-拆零数量（拆零比×请求数量）
BigDecimal quantity = inventoryDto.getInventoryQuantity()
.subtract(inventoryDto.getPartPercent().multiply(inventoryDto.getQuantity()));
// 库存数量判定
if (quantity.compareTo(BigDecimal.ZERO) < 0) {
// 库存数量不足
return R.fail(inventoryDto.getItemName() + "当前库存数量不足");
} else {
inventoryItem.setId(inventoryDto.getInventoryId()).setQuantity(quantity);
}
}
inventoryItemList.add(inventoryItem);
}
}
}
// 发耗材信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
List<SupplyItemDetailDto> supplyItemDetailList = new ArrayList<>();
if (dispenseList != null) {
if (dispenseList.stream().map(DeviceDispense::getStatusEnum)
.anyMatch(x -> x.equals(DispenseStatus.COMPLETED.getValue()))) {
throw new ServiceException("耗材已发放，请勿重复操作");
} else {
for (DeviceDispense deviceDispense : dispenseList) {
// 耗材发放状态
deviceDispense.setStatusEnum(DispenseStatus.COMPLETED.getValue());
// 发药数量
deviceDispense.setDispenseQuantity(deviceDispense.getQuantity());
// 发药时间
deviceDispense.setDispenseTime(DateUtils.getNowDate());
// 发药人（长大写死发耗材人）
deviceDispense.setPerformerId(CommonConstants.CCU.DisDeviceDoctor);
// 根据数量设置追溯码
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA, Collections
.nCopies(deviceDispense.getQuantity().intValue(), CommonConstants.Common.DEV_TRACE_NO)));
// 设置库存变更参数
supplyItemDetailList.add(new SupplyItemDetailDto().setItemId(deviceDispense.getDeviceDefId())
.setLotNumber(deviceDispense.getLotNumber())
.setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION));
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
}
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 库存更新
inventoryItemService.updateBatchById(inventoryItemList);
// 返回信息
String returnMsg = null;
// 调用医保商品销售接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH);
List<String> uploadFailedNoList = new ArrayList<>();
// 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
// 设置进销存参数
List<DeviceDefinition> deviceDefinitions = deviceDefinitionService.listByIds(
supplyItemDetailList.stream().map(SupplyItemDetailDto::getItemId).collect(Collectors.toList()));
// 用itemId分组
Map<Long, DeviceDefinition> deviceMap =
deviceDefinitions.stream().collect(Collectors.toMap(DeviceDefinition::getId, Function.identity()));
// 设置库存变更参数
for (SupplyItemDetailDto dto : supplyItemDetailList) {
if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(dto.getItemTable())) {
DeviceDefinition dev = deviceMap.get(dto.getItemId());
if (dev != null) {
dto.setItemBusNo(dev.getBusNo()).setPartPercent(dev.getPartPercent()).setRxFlag(dev.getRxFlag())
.setYbNo(dev.getYbNo());
}
}
}
uploadFailedNoList = westernMedicineDispenseAppService.ybMedicineIntegrated(null, devDispenseIdList);
uploadFailedNoList = receiptApprovalAppService.ybInventoryIntegrated(supplyItemDetailList,
YbInvChgType.OTHER_OUT, DateUtils.getNowDate());
if (uploadFailedNoList != null) {
returnMsg = "3505商品销售上传错误，错误项目编码" + uploadFailedNoList;
} else {
returnMsg = "3505商品销售上传成功";
}
}
return R.ok(returnMsg, MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
@Override
public R<?> deviceCancel(List<DispenseItemDto> dispenseDeviceList) {
// 获取发材料单id列表
List<Long> devDispenseIdList =
dispenseDeviceList.stream().map(DispenseItemDto::getDispenseId).collect(Collectors.toList());
// 材料发放信息查询
List<DeviceDispense> dispenseList = deviceDispenseService
.list(new LambdaQueryWrapper<DeviceDispense>().in(DeviceDispense::getId, devDispenseIdList));
if (dispenseList != null) {
for (DeviceDispense medicationDispense : dispenseList) {
// 材料发放状态
medicationDispense.setStatusEnum(DispenseStatus.DECLINED.getValue());
// 未发药原因
medicationDispense.setNotPerformedReasonEnum(dispenseDeviceList.get(0).getNotPerformedReasonEnum());
}
// 药品发放更新
deviceDispenseService.updateBatchById(dispenseList);
} else {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
return R.ok(MessageUtils.createMessage(PromptMsgConstant.Common.M00004, null));
}
}

20
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/MedicationDetailsAppServiceImpl.java
View File

@@ -78,14 +78,16 @@ public class MedicationDetailsAppServiceImpl implements IMedicationDetailsAppSer
@Override
public R<?> getAmbPractitionerDetailPage(MedDetailsSearchParam medDetailsSearchParam, Integer pageNo,
Integer pageSize, String searchKey, HttpServletRequest request) {
Integer flg = medDetailsSearchParam.getFlag();
medDetailsSearchParam.setFlag(null);
// 构建查询条件
QueryWrapper<MedDetailsSearchParam> queryWrapper = HisQueryUtils.buildQueryWrapper(medDetailsSearchParam,
searchKey, new HashSet<>(Arrays.asList("patient_name", "medication_name", "bus_no", "py_str")), request);
Page<MedDetailedAccountPageDto> medDetailsPage = medicationDetailsMapper.selectAmbPractitionerDetailPage(
new Page<>(pageNo, pageSize), queryWrapper, EncounterClass.AMB.getValue(),
DispenseStatus.COMPLETED.getValue(), DispenseStatus.REFUNDED.getValue(), 1);
Page<MedDetailedAccountPageDto> medDetailsPage =
medicationDetailsMapper.selectAmbPractitionerDetailPage(new Page<>(pageNo, pageSize), queryWrapper,
EncounterClass.AMB.getValue(), DispenseStatus.COMPLETED.getValue(), RequestStatus.COMPLETED.getValue(),
DispenseStatus.REFUNDED.getValue(), 1, flg);
return R.ok(medDetailsPage);
@@ -105,13 +107,17 @@ public class MedicationDetailsAppServiceImpl implements IMedicationDetailsAppSer
public R<?> getAmbMedicationDispenseDetailPage(MedDetailsSearchParam medDetailsSearchParam, Integer pageNo,
Integer pageSize, String searchKey, HttpServletRequest request) {
Integer flg = medDetailsSearchParam.getFlag();
medDetailsSearchParam.setFlag(null);
// 构建查询条件
QueryWrapper<MedDetailsSearchParam> queryWrapper = HisQueryUtils.buildQueryWrapper(medDetailsSearchParam,
searchKey, new HashSet<>(Arrays.asList("patient_name", "medication_name", "bus_no", "py_str")), request);
Page<MedDetailedAccountPageDto> medDetailsPage = medicationDetailsMapper.selectAmbPractitionerDetailPage(
new Page<>(pageNo, pageSize), queryWrapper, EncounterClass.AMB.getValue(),
DispenseStatus.COMPLETED.getValue(), DispenseStatus.REFUNDED.getValue(), 2);
Page<MedDetailedAccountPageDto> medDetailsPage =
medicationDetailsMapper.selectAmbPractitionerDetailPage(new Page<>(pageNo, pageSize), queryWrapper,
EncounterClass.AMB.getValue(), DispenseStatus.COMPLETED.getValue(), RequestStatus.COMPLETED.getValue(),
DispenseStatus.REFUNDED.getValue(), 2, flg);
return R.ok(medDetailsPage);

195
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/IReturnMedicineAppServiceImpl.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/ReturnMedicineAppServiceImpl.java
View File

@@ -2,11 +2,12 @@ package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONArray;
@@ -21,6 +22,7 @@ import com.openhis.administration.service.*;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.enums.ybenums.YbInvChgType;
import com.openhis.common.enums.ybenums.YbMdtrtCertType;
import com.openhis.common.enums.ybenums.YbRxFlag;
import com.openhis.common.utils.EnumUtils;
@@ -29,9 +31,13 @@ import com.openhis.financial.domain.Contract;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.financial.service.IContractService;
import com.openhis.financial.service.IPaymentReconciliationService;
import com.openhis.medication.domain.MedicationDefinition;
import com.openhis.medication.domain.MedicationDispense;
import com.openhis.medication.service.IMedicationDefinitionService;
import com.openhis.medication.service.IMedicationDispenseService;
import com.openhis.medication.service.IMedicationRequestService;
import com.openhis.web.inventorymanage.appservice.impl.ReceiptApprovalAppServiceImpl;
import com.openhis.web.inventorymanage.dto.SupplyItemDetailDto;
import com.openhis.web.pharmacymanage.appservice.IReturnMedicineAppService;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
@@ -43,7 +49,6 @@ import com.openhis.workflow.service.IInventoryItemService;
import com.openhis.yb.domain.ClinicSettle;
import com.openhis.yb.dto.Medical3506Param;
import com.openhis.yb.service.IClinicSettleService;
import com.openhis.yb.service.IRegService;
import com.openhis.yb.service.YbManager;
/**
@@ -53,58 +58,64 @@ import com.openhis.yb.service.YbManager;
* @date 2025/4/4
*/
@Service
public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService {
public class ReturnMedicineAppServiceImpl implements IReturnMedicineAppService {
@Autowired
@Resource
private ITraceNoManageService traceNoManageService;
@Autowired
@Resource
private IOrganizationService iOrganizationService;
@Autowired
@Resource
private IInventoryItemService iInventoryItemService;
@Autowired
@Resource
private ReturnMedicineMapper returnMedicineMapper;
@Autowired
@Resource
private IMedicationRequestService medicationRequestService;
@Autowired
@Resource
private IMedicationDispenseService medicationDispenseService;
@Autowired
@Resource
private IDeviceDispenseService deviceDispenseService;
@Autowired
@Resource
private IDeviceRequestService deviceRequestService;
@Autowired
@Resource
private AssignSeqUtil assignSeqUtil;
@Autowired
@Resource
private YbManager ybService;
@Autowired
@Resource
private IChargeItemService iChargeItemService;
@Autowired
@Resource
private IPaymentReconciliationService iPaymentReconciliationService;
@Autowired
@Resource
private IContractService iContractService;
@Autowired
@Resource
private IClinicSettleService clinicSettleService;
@Autowired
@Resource
private IEncounterDiagnosisService encounterDiagnosisService;
@Autowired
@Resource
private IAccountService accountService;
@Autowired
private IRegService iRegService;
@Resource
private IDeviceDefinitionService deviceDefinitionService;
@Resource
private IMedicationDefinitionService medicationDefinitionService;
@Resource
private ReceiptApprovalAppServiceImpl receiptApprovalAppService;
/**
* 获取页面初始化信息
@@ -136,7 +147,7 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
/**
* 查询退药患者分页列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
@@ -144,16 +155,15 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
* @return 退药患者分页列表
*/
@Override
public R<?> getReturnMedicinePatientPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey,
Integer pageNo, Integer pageSize, HttpServletRequest request) {
public R<?> getReturnMedicinePatientPage(EncounterInfoDto encounterInfoDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request) {
// 构建查询条件
QueryWrapper<EncounterInfoPageDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoPageDto, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
QueryWrapper<EncounterInfoDto> queryWrapper = HisQueryUtils.buildQueryWrapper(encounterInfoDto, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询退药患者分页列表
Page<EncounterInfoPageDto> encounterInfoPage = returnMedicineMapper
Page<EncounterInfoDto> encounterInfoPage = returnMedicineMapper
.selectEncounterInfoListPage(new Page<>(pageNo, pageSize), queryWrapper, EncounterClass.AMB.getValue());
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
@@ -177,21 +187,6 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
*/
@Override
public R<?> getReturnMedicineInfo(Long encounterId, Integer refundStatus) {
// // 患者基本信息查询
// PrescriptionPatientInfoDto prescriptionPatientInfoDto =
// returnMedicineMapper.selectPrescriptionPatientInfo(encounterId);
// // 年龄
// prescriptionPatientInfoDto.setAge(AgeCalculatorUtil.getAge(prescriptionPatientInfoDto.getBirthDate()));
// // 性别
// prescriptionPatientInfoDto.setGenderEnum_enumText(
// EnumUtils.getInfoByValue(AdministrativeGender.class, prescriptionPatientInfoDto.getGenderEnum()));
// // 合同类型
// if (StringUtils.isNotNull(prescriptionPatientInfoDto.getCategoryEnum())) {
// prescriptionPatientInfoDto.setCategoryEnum_enumText(
// EnumUtils.getInfoByValue(FinCategory.class, prescriptionPatientInfoDto.getCategoryEnum()));
// }
// 获取退药信息
List<ReturnMedicineInfoDto> returnMedicineInfoList = returnMedicineMapper.selectReturnMedicineInfo(encounterId,
CommonConstants.TableName.WOR_DEVICE_REQUEST, CommonConstants.TableName.MED_MEDICATION_REQUEST,
@@ -205,7 +200,6 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
returnMedicineInfoDto.setReqStatus_enumText(
EnumUtils.getInfoByValue(RequestStatus.class, returnMedicineInfoDto.getReqStatus()));
});
return R.ok(returnMedicineInfoList);
}
@@ -255,6 +249,7 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
}
// 退药单列表
List<MedicationDispense> medicationRefundList = new ArrayList<>();
List<SupplyItemDetailDto> supplyItemDetailList = new ArrayList<>();
if (!medDispenseIdList.isEmpty()) {
// 药品已发放信息查询
List<MedicationDispense> medicationDispenseList = medicationDispenseService
@@ -279,31 +274,37 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
medicationDispense.setPractitionerId(SecurityUtils.getLoginUser().getPractitionerId());
medicationDispense.setId(null);
medicationRefundList.add(medicationDispense);
// 使用逗号分割追溯码并转换为List
String[] traceNoList = medicationDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION)
// 项目id
.setItemId(medicationDispense.getMedicationId())
// 仓库类型
.setLocationTypeEnum(null)
// 仓库
.setLocationId(medicationDispense.getLocationId())
// 仓位
.setLocationStoreId(null)
// 产品批号
.setLotNumber(medicationDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.IN.getValue())
// 追溯码单位
.setUnitCode(medicationDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.RETURN_MEDICATION.getValue());
traceNoManageList.add(traceNoManage);
// 设置库存变更参数
supplyItemDetailList.add(new SupplyItemDetailDto()
.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION)
.setItemId(medicationDispense.getMedicationId()).setLotNumber(medicationDispense.getLotNumber()));
if (medicationDispense.getTraceNo() != null) {
// 使用逗号分割追溯码并转换为List
String[] traceNoList = medicationDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION)
// 项目id
.setItemId(medicationDispense.getMedicationId())
// 仓库类型
.setLocationTypeEnum(null)
// 仓库
.setLocationId(medicationDispense.getLocationId())
// 仓位
.setLocationStoreId(null)
// 产品批号
.setLotNumber(medicationDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.IN.getValue())
// 追溯码单位
.setUnitCode(medicationDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.RETURN_MEDICATION.getValue());
traceNoManageList.add(traceNoManage);
}
}
}
medicationDispenseService.saveBatch(medicationRefundList);
@@ -342,8 +343,8 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
if (returnDeviceDto.getDispenseId().equals(deviceDispense.getId())) {
deviceDispense.setDeviceReqId(returnDeviceDto.getRequestId());
// 根据数量设置追溯码
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA,
Collections.nCopies(deviceDispense.getQuantity(), CommonConstants.Common.DEV_TRACE_NO)));
deviceDispense.setTraceNo(String.join(CommonConstants.Common.COMMA, Collections
.nCopies(deviceDispense.getQuantity().intValue(), CommonConstants.Common.DEV_TRACE_NO)));
}
}
// 退药时间
@@ -352,6 +353,10 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
deviceDispense.setStatusEnum(DispenseStatus.REFUNDED.getValue());
deviceDispense.setId(null);
devRefundList.add(deviceDispense);
// 设置库存变更参数
supplyItemDetailList
.add(new SupplyItemDetailDto().setItemTable(CommonConstants.TableName.ADM_DEVICE_DEFINITION)
.setItemId(deviceDispense.getDeviceDefId()).setLotNumber(deviceDispense.getLotNumber()));
// // 使用逗号分割追溯码并转换为List
// String[] traceNoList = deviceDispense.getTraceNo().split(CommonConstants.Common.COMMA);
// for (String item : traceNoList) {
@@ -408,18 +413,49 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
// 库存更新
iInventoryItemService.updateBatchById(inventoryItemList);
// 追溯码管理表数据追加
boolean result = traceNoManageService.saveBatch(traceNoManageList);
if (!result) {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
traceNoManageService.saveBatch(traceNoManageList);
}
// 返回信息
String returnMsg = null;
List<String> uploadFailedNoList;
// 调用医保商品销售退货接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH); // 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
if (!medicationRefundList.isEmpty() || !devRefundList.isEmpty()) {
List<String> uploadFailedNoList = this.ybReturnIntegrated(medDispenseIdList, devDispenseIdList);
// 设置进销存参数
List<MedicationDefinition> medicationDefinitions =
medicationDefinitionService.listByIds(supplyItemDetailList.stream()
.filter(x -> x.getItemTable().equals(CommonConstants.TableName.MED_MEDICATION_DEFINITION))
.map(SupplyItemDetailDto::getItemId).collect(Collectors.toList()));
List<DeviceDefinition> deviceDefinitions = deviceDefinitionService.listByIds(supplyItemDetailList
.stream().filter(x -> x.getItemTable().equals(CommonConstants.TableName.ADM_DEVICE_DEFINITION))
.map(SupplyItemDetailDto::getItemId).collect(Collectors.toList()));
// 用itemId分组
Map<Long, MedicationDefinition> medicationMap = medicationDefinitions.stream()
.collect(Collectors.toMap(MedicationDefinition::getId, Function.identity()));
Map<Long, DeviceDefinition> deviceMap =
deviceDefinitions.stream().collect(Collectors.toMap(DeviceDefinition::getId, Function.identity()));
// 设置库存变更参数
for (SupplyItemDetailDto dto : supplyItemDetailList) {
if (CommonConstants.TableName.MED_MEDICATION_DEFINITION.equals(dto.getItemTable())) {
MedicationDefinition med = medicationMap.get(dto.getItemId());
if (med != null) {
dto.setItemBusNo(med.getBusNo()).setPartPercent(med.getPartPercent())
.setRxFlag(med.getRxFlag()).setYbNo(med.getYbNo());
}
} else if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(dto.getItemTable())) {
DeviceDefinition dev = deviceMap.get(dto.getItemId());
if (dev != null) {
dto.setItemBusNo(dev.getBusNo()).setPartPercent(dev.getPartPercent())
.setRxFlag(dev.getRxFlag()).setYbNo(dev.getYbNo());
}
}
}
uploadFailedNoList = this.ybReturnIntegrated(medDispenseIdList, devDispenseIdList);
uploadFailedNoList = receiptApprovalAppService.ybInventoryIntegrated(supplyItemDetailList,
YbInvChgType.OTHER_OUT, DateUtils.getNowDate());
if (uploadFailedNoList != null) {
returnMsg = "3506商品销售退货上传错误，错误项目编码" + uploadFailedNoList;
} else {
@@ -556,8 +592,7 @@ public class IReturnMedicineAppServiceImpl implements IReturnMedicineAppService
.setManuDate(dispenseInventoryDto.getProductionDate())
.setSelRetnCnt(new BigDecimal(dispenseInventoryDto.getDispenseQuantity().toString()))
.setSelRetnTime(dispenseInventoryDto.getDispenseTime()).setExpyEnd(dispenseInventoryDto.getExpirationDate())
.setMedinsProdSelNo(dispenseInventoryDto.getDispenseNo()).setDrugtracinfo(medicalTraceNo)
.setCertno(dispenseInventoryDto.getIdCard());
.setDrugtracinfo(medicalTraceNo).setCertno(dispenseInventoryDto.getIdCard());
// 查看所属医院
String fixmedinsCode =
SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.FIXMEDINS_CODE);

483
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/IWesternMedicineDispenseAppServiceImpl.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/appservice/impl/WesternMedicineDispenseAppServiceImpl.java
View File

@@ -2,13 +2,13 @@ package com.openhis.web.pharmacymanage.appservice.impl;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSONArray;
@@ -16,16 +16,17 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.core.common.core.domain.R;
import com.core.common.core.domain.entity.SysDictData;
import com.core.common.exception.ServiceException;
import com.core.common.utils.*;
import com.core.system.mapper.SysDictDataMapper;
import com.core.common.utils.AgeCalculatorUtil;
import com.core.common.utils.DateUtils;
import com.core.common.utils.MessageUtils;
import com.core.common.utils.SecurityUtils;
import com.openhis.administration.domain.*;
import com.openhis.administration.service.*;
import com.openhis.clinical.service.IAllergyIntoleranceService;
import com.openhis.common.constant.CommonConstants;
import com.openhis.common.constant.PromptMsgConstant;
import com.openhis.common.enums.*;
import com.openhis.common.enums.ybenums.YbInvChgType;
import com.openhis.common.enums.ybenums.YbMdtrtCertType;
import com.openhis.common.enums.ybenums.YbRxFlag;
import com.openhis.common.utils.EnumUtils;
@@ -34,18 +35,18 @@ import com.openhis.financial.domain.Contract;
import com.openhis.financial.domain.PaymentReconciliation;
import com.openhis.financial.service.IContractService;
import com.openhis.financial.service.IPaymentReconciliationService;
import com.openhis.medication.domain.MedicationDefinition;
import com.openhis.medication.domain.MedicationDispense;
import com.openhis.medication.service.IMedicationDefinitionService;
import com.openhis.medication.service.IMedicationDispenseService;
import com.openhis.medication.service.IMedicationRequestService;
import com.openhis.web.inventorymanage.appservice.ITraceNoAppService;
import com.openhis.web.inventorymanage.appservice.impl.ReceiptApprovalAppServiceImpl;
import com.openhis.web.inventorymanage.dto.SupplyItemDetailDto;
import com.openhis.web.pharmacymanage.appservice.IWesternMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.*;
import com.openhis.web.pharmacymanage.mapper.ReturnMedicineMapper;
import com.openhis.web.pharmacymanage.mapper.WesternMedicineDispenseMapper;
import com.openhis.workflow.domain.InventoryItem;
import com.openhis.workflow.domain.ServiceRequest;
import com.openhis.workflow.service.IInventoryItemService;
import com.openhis.workflow.service.IServiceRequestService;
import com.openhis.yb.domain.ClinicSettle;
import com.openhis.yb.dto.Medical3505Param;
import com.openhis.yb.service.IClinicSettleService;
@@ -60,62 +61,53 @@ import reactor.util.annotation.Nullable;
* @date 2025/3/14
*/
@Service
public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineDispenseAppService {
@Autowired
private ITraceNoAppService traceNoAppService;
@Autowired
private IOrganizationService organizationService;
@Autowired
private IMedicationDispenseService medicationDispenseService;
@Autowired
private IInventoryItemService iInventoryItemService;
@Autowired
private IMedicationRequestService medicationRequestService;
@Autowired
private WesternMedicineDispenseMapper westernMedicineDispenseMapper;
@Autowired
private ReturnMedicineMapper returnMedicineMapper;
@Autowired
private YbManager ybService;
@Autowired
private IChargeItemService iChargeItemService;
@Autowired
private IPaymentReconciliationService iPaymentReconciliationService;
@Autowired
private IContractService iContractService;
@Autowired
private IAccountService accountService;
@Autowired
private IClinicSettleService clinicSettleService;
@Autowired
private IEncounterDiagnosisService encounterDiagnosisService;
@Autowired
private IServiceRequestService serviceRequestService;
@Autowired
private IAllergyIntoleranceService allergyIntoleranceService;
public class WesternMedicineDispenseAppServiceImpl implements IWesternMedicineDispenseAppService {
@Resource
private SysDictDataMapper sysDictDataMapper;
private IOrganizationService organizationService;
@Autowired
@Resource
private IMedicationDispenseService medicationDispenseService;
@Resource
private IInventoryItemService inventoryItemService;
@Resource
private WesternMedicineDispenseMapper westernMedicineDispenseMapper;
@Resource
private ReturnMedicineMapper returnMedicineMapper;
@Resource
private YbManager ybService;
@Resource
private IChargeItemService chargeItemService;
@Resource
private IPaymentReconciliationService paymentReconciliationService;
@Resource
private IContractService contractService;
@Resource
private IAccountService accountService;
@Resource
private IClinicSettleService clinicSettleService;
@Resource
private IEncounterDiagnosisService encounterDiagnosisService;
@Resource
private ITraceNoManageService traceNoManageService;
@Resource
private ReceiptApprovalAppServiceImpl receiptApprovalAppService;
@Resource
private IMedicationDefinitionService medicationDefinitionService;
/**
* 获取页面初始化信息
*
@@ -147,6 +139,12 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
notPerformedReason.getInfo()))
.collect(Collectors.toList());
// 患者类型
List<DispenseInitDto.EncounterClassOption> encounterClassOptions = Stream.of(EncounterClass.values())
.map(encounterClass -> new DispenseInitDto.EncounterClassOption(encounterClass.getValue(),
encounterClass.getInfo()))
.toList();
// 发药状态
List<DispenseInitDto.DispenseStatusOption> dispenseStatusOptions = new ArrayList<>();
dispenseStatusOptions.add(new DispenseInitDto.DispenseStatusOption(DispenseStatus.IN_PROGRESS.getValue(),
@@ -155,37 +153,38 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
DispenseStatus.COMPLETED.getInfo()));
initDto.setDepartmentOptions(organizationOptions).setNotPerformedReasonOptions(notPerformedReasonOptions)
.setDispenseStatusOptions(dispenseStatusOptions).setPreparerDoctorOptions(preparerDoctorOptions);
.setDispenseStatusOptions(dispenseStatusOptions).setPreparerDoctorOptions(preparerDoctorOptions)
.setEncounterClassOptions(encounterClassOptions);
return R.ok(initDto);
}
/**
* 分页查询发药病人列表
* 分页查询病人列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
* @return 病人列表
*/
@Override
public R<?> getEncounterInfoListPage(EncounterInfoPageDto encounterInfoPageDto, String searchKey, Integer pageNo,
Integer pageSize, HttpServletRequest request) {
public R<?> getEncounterInfoListPage(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
Integer pageNo, Integer pageSize, HttpServletRequest request) {
// 发药状态初始化
Integer statusEnum = encounterInfoPageDto.getStatusEnum();
encounterInfoPageDto.setStatusEnum(null);
Integer statusEnum = encounterInfoSearchParam.getStatusEnum();
encounterInfoSearchParam.setStatusEnum(null);
// 构建查询条件
QueryWrapper<EncounterInfoPageDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoPageDto, searchKey,
QueryWrapper<EncounterInfoSearchParam> queryWrapper =
HisQueryUtils.buildQueryWrapper(encounterInfoSearchParam, searchKey,
new HashSet<>(Arrays.asList(CommonConstants.FieldName.PatientName, CommonConstants.FieldName.idCard,
CommonConstants.FieldName.PatientPyStr, CommonConstants.FieldName.PatientWbStr)),
request);
// 查询就诊病人列表
Page<EncounterInfoPageDto> encounterInfoPage = westernMedicineDispenseMapper.selectEncounterInfoListPage(
new Page<>(pageNo, pageSize), queryWrapper, statusEnum, DispenseStatus.IN_PROGRESS.getValue(),
DispenseStatus.COMPLETED.getValue(), DispenseStatus.PREPARATION.getValue(),
DispenseStatus.PREPARED.getValue(), EncounterClass.AMB.getValue());
Page<EncounterInfoDto> encounterInfoPage =
westernMedicineDispenseMapper.selectEncounterInfoListPage(new Page<>(pageNo, pageSize), queryWrapper,
statusEnum, DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue());
encounterInfoPage.getRecords().forEach(encounterInfo -> {
// 性别
encounterInfo.setGenderEnum_enumText(
@@ -193,6 +192,10 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
// 发药状态
encounterInfo
.setStatusEnum_enumText(EnumUtils.getInfoByValue(DispenseStatus.class, encounterInfo.getStatusEnum()));
if (encounterInfo.getBirthDate() != null) {
// 计算年龄
encounterInfo.setAge(AgeCalculatorUtil.getAge(encounterInfo.getBirthDate()));
}
});
return R.ok(encounterInfoPage);
}
@@ -200,118 +203,33 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
/**
* 处方单查询
*
* @param prescriptionMedicineInfoDto 查询信息
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@Override
public R<?> getPrescriptionInfo(PrescriptionMedicineInfoDto prescriptionMedicineInfoDto, Integer pageNo,
public R<?> getMedicineDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto, Integer pageNo,
Integer pageSize) {
// 发药状态初始化
Integer dispenseStatus = prescriptionMedicineInfoDto.getStatusEnum();
prescriptionMedicineInfoDto.setStatusEnum(null);
Integer dispenseStatus = itemDispenseOrderDto.getStatusEnum();
itemDispenseOrderDto.setStatusEnum(null);
// 构建查询条件
QueryWrapper<PrescriptionMedicineInfoDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(prescriptionMedicineInfoDto, null, null, null);
// 获取所属医院id
Long hospitalId = SecurityUtils.getLoginUser().getHospitalId();
// 患者基本信息查询
PrescriptionPatientInfoDto prescriptionPatientInfoDto = westernMedicineDispenseMapper
.selectPrescriptionPatientInfo(prescriptionMedicineInfoDto.getEncounterId(), hospitalId);
// 年龄
prescriptionPatientInfoDto.setAge(AgeCalculatorUtil.getAge(prescriptionPatientInfoDto.getBirthDate()));
// 性别
prescriptionPatientInfoDto.setGenderEnum_enumText(
EnumUtils.getInfoByValue(AdministrativeGender.class, prescriptionPatientInfoDto.getGenderEnum()));
QueryWrapper<ItemDispenseOrderDto> queryWrapper =
HisQueryUtils.buildQueryWrapper(itemDispenseOrderDto, null, null, null);
// 处方单信息查询
Page<PrescriptionMedicineInfoDto> prescriptionMedicineInfoPage =
westernMedicineDispenseMapper.selectPrescriptionMedicineInfoList(new Page<>(pageNo, pageSize), queryWrapper,
Page<ItemDispenseOrderDto> medicineDispenseOrderPage =
westernMedicineDispenseMapper.selectMedicineDispenseOrderPage(new Page<>(pageNo, pageSize), queryWrapper,
DispenseStatus.IN_PROGRESS.getValue(), DispenseStatus.COMPLETED.getValue(),
DispenseStatus.PREPARATION.getValue(), DispenseStatus.PREPARED.getValue(), dispenseStatus);
// 查询字典值
List<SysDictData> unitCodeList = sysDictDataMapper.selectDictDataByType("unit_code");
Map<String, String> unitCodeLabel = unitCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<SysDictData> methodCodeList = sysDictDataMapper.selectDictDataByType("method_code");
Map<String, String> methodCodeLabel = methodCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<PrescriptionMedicineInfoDto> prescriptionMedicineInfoList = prescriptionMedicineInfoPage.getRecords();
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
);
prescriptionMedicineInfoList.forEach(prescriptionMedicineInfo -> {
medicineDispenseOrderPage.getRecords().forEach(medicineDispenseOrder -> {
// 发药状态
prescriptionMedicineInfo.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, prescriptionMedicineInfo.getStatusEnum()));
// 匹配剂量单位字典文本
String doseUnitCode = prescriptionMedicineInfo.getDoseUnitCode();
String doseUnitLabel = unitCodeLabel.getOrDefault(doseUnitCode, "");
prescriptionMedicineInfo.setDoseUnitCode_dictText(doseUnitLabel);
// 匹配单位字典文本
String unitCode = prescriptionMedicineInfo.getUnitCode();
String unitLabel = unitCodeLabel.getOrDefault(unitCode, "");
prescriptionMedicineInfo.setUnitCode_dictText(unitLabel);
// 匹配用法字典文本
String methodCode = prescriptionMedicineInfo.getMethodCode();
String methodLabel = methodCodeLabel.getOrDefault(methodCode, "");
prescriptionMedicineInfo.setMethodCode_dictText(methodLabel);
switch (prescriptionMedicineInfo.getPharmacologyCategoryCode()) {
case "2": // 麻醉药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("麻醉");
case "3": // 毒性药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("毒性");
case "4": // 一类精神药
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("精一");
case "5": // 二类精神药
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("精二");
default: // 普通药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("普通");
}
// 判断是否为慢病
if (EncounterYbClass.CHRONIC_DISEASE_OUTPATIENT.getCode()
.equals(prescriptionMedicineInfo.getMedTypeCode())) {
prescriptionMedicineInfo.setChronicDisease(Whether.YES.getInfo());
} else {
prescriptionMedicineInfo.setChronicDisease(Whether.NO.getInfo());
}
// 皮试flag为是时
if (Whether.YES.getValue().equals(prescriptionMedicineInfo.getSkinTestFlag())) {
// 获取皮试结果
ServiceRequest serReqObj =
serviceRequestService.selectByMedRequestId(prescriptionMedicineInfo.getRequestId());
if (serReqObj != null) {
Integer clinicalStatus = allergyIntoleranceService.getPsResultByRequestId(serReqObj.getId());
prescriptionMedicineInfo.setPsResult(ClinicalStatus.getByValue(clinicalStatus).getInfo());
}
} else {
prescriptionMedicineInfo.setPsResult("无");
}
medicineDispenseOrder.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, medicineDispenseOrder.getStatusEnum()));
// 设置所在表名
medicineDispenseOrder.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION);
});
// 计算合计金额
if (!prescriptionMedicineInfoList.isEmpty()) {
double totalPrice = 0d;
for (PrescriptionMedicineInfoDto item : prescriptionMedicineInfoList) {
totalPrice += item.getTotalPrice().doubleValue();
}
prescriptionPatientInfoDto.setTotalPrice(totalPrice);
}
PrescriptionInfoDto prescriptionInfoDto = new PrescriptionInfoDto();
prescriptionInfoDto.setPrescriptionPatientInfoDto(prescriptionPatientInfoDto);
prescriptionInfoDto.setPrescriptionMedicineInfoDtoList(prescriptionMedicineInfoList);
return R.ok(prescriptionInfoDto);
return R.ok(medicineDispenseOrderPage);
}
/**
@@ -321,7 +239,7 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
* @return 处理结果
*/
@Override
public R<?> medicinePrepare(List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicinePrepare(List<DispenseItemDto> dispenseMedicineList) {
// 配药人检查
if (dispenseMedicineList.get(0).getPreparerId() == null
|| dispenseMedicineList.get(0).getPreparerId().equals(SecurityUtils.getLoginUser().getPractitionerId())) {
@@ -329,7 +247,7 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
}
// 获取发药单id列表
List<Long> medDispenseIdList =
dispenseMedicineList.stream().map(DispenseMedicineDto::getDispenseId).collect(Collectors.toList());
dispenseMedicineList.stream().map(DispenseItemDto::getDispenseId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(null, medDispenseIdList,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
@@ -375,8 +293,8 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
.list(new LambdaQueryWrapper<MedicationDispense>().in(MedicationDispense::getId, medDispenseIdList));
if (dispenseList != null) {
if (dispenseList.stream().map(MedicationDispense::getStatusEnum)
.anyMatch(x -> x.equals(DispenseStatus.PREPARED.getValue()))) {
throw new ServiceException("药品已配药，请勿重复配药");
.anyMatch(x -> !x.equals(DispenseStatus.PREPARATION.getValue()))) {
throw new ServiceException("配药失败，请检查发药单状态");
} else {
for (MedicationDispense medicationDispense : dispenseList) {
// 药品发放状态
@@ -387,10 +305,10 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
medicationDispense.setPreparerId(dispenseMedicineList.get(0).getPreparerId());
// 配药时间
medicationDispense.setPrepareTime(DateUtils.getNowDate());
for (DispenseMedicineDto dispenseMedicineDto : dispenseMedicineList) {
if (medicationDispense.getId().equals(dispenseMedicineDto.getDispenseId()))
for (DispenseItemDto dispenseItemDto : dispenseMedicineList) {
if (medicationDispense.getId().equals(dispenseItemDto.getDispenseId()))
// 药品追溯码
medicationDispense.setTraceNo(dispenseMedicineDto.getTraceNo());
medicationDispense.setTraceNo(dispenseItemDto.getTraceNo());
}
}
// 药品发放更新
@@ -409,14 +327,11 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
* @return 处理结果
*/
@Override
public R<?> medicineDispense(List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicineDispense(List<DispenseItemDto> dispenseMedicineList) {
List<InventoryItem> inventoryItemList = new ArrayList<>();
// 获取发药单id列表
List<Long> medDispenseIdList =
dispenseMedicineList.stream().map(DispenseMedicineDto::getDispenseId).collect(Collectors.toList());
// 获取药品申请id列表
List<Long> medRequestIdList =
dispenseMedicineList.stream().map(DispenseMedicineDto::getRequestId).collect(Collectors.toList());
dispenseMedicineList.stream().map(DispenseItemDto::getDispenseId).collect(Collectors.toList());
// 获取库存信息
List<InventoryDto> inventoryList = returnMedicineMapper.selectInventoryInfoList(null, medDispenseIdList,
CommonConstants.TableName.MED_MEDICATION_DEFINITION, CommonConstants.TableName.ADM_DEVICE_DEFINITION);
@@ -469,10 +384,11 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
// 追溯码列表
List<TraceNoManage> tracesNoManageList = new ArrayList<>();
TraceNoManage traceNoManage;
List<SupplyItemDetailDto> supplyItemDetailList = new ArrayList<>();
if (dispenseList != null) {
if (dispenseList.stream().map(MedicationDispense::getStatusEnum)
.anyMatch(x -> x.equals(DispenseStatus.COMPLETED.getValue()))) {
throw new ServiceException("药品已发药，请勿重复发药");
.anyMatch(x -> !x.equals(DispenseStatus.PREPARED.getValue()))) {
throw new ServiceException("发药失败，请检查发药单状态");
} else {
for (MedicationDispense medicationDispense : dispenseList) {
// 药品发放状态
@@ -485,29 +401,35 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
medicationDispense.setDispenseTime(DateUtils.getNowDate());
// 发药人
medicationDispense.setPractitionerId(SecurityUtils.getLoginUser().getPractitionerId());
// 设置库存变更参数
supplyItemDetailList.add(new SupplyItemDetailDto().setItemId(medicationDispense.getMedicationId())
.setLotNumber(medicationDispense.getLotNumber())
.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION));
// 使用逗号分割追溯码并转换为List
String[] traceNoList = medicationDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION)
// 项目id
.setItemId(medicationDispense.getMedicationId())
// 仓库类型
.setLocationTypeEnum(LocationForm.PHARMACY.getValue())
// 仓库
.setLocationId(medicationDispense.getLocationId())
// 产品批号
.setLotNumber(medicationDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.OUT.getValue())
// 追溯码单位
.setUnitCode(medicationDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.DISPENSE_MEDICATION.getValue());
tracesNoManageList.add(traceNoManage);
if (medicationDispense.getTraceNo() != null) {
String[] traceNoList = medicationDispense.getTraceNo().split(CommonConstants.Common.COMMA);
for (String item : traceNoList) {
traceNoManage = new TraceNoManage();
// 追溯码处理
traceNoManage.setItemTable(CommonConstants.TableName.MED_MEDICATION_DEFINITION)
// 项目id
.setItemId(medicationDispense.getMedicationId())
// 仓库类型
.setLocationTypeEnum(LocationForm.PHARMACY.getValue())
// 仓库
.setLocationId(medicationDispense.getLocationId())
// 产品批号
.setLotNumber(medicationDispense.getLotNumber())
// 追溯码
.setTraceNo(item)
// 追溯码状态
.setStatusEnum(TraceNoStatus.OUT.getValue())
// 追溯码单位
.setUnitCode(medicationDispense.getUnitCode())
// 操作类型
.setOperationType(SupplyType.DISPENSE_MEDICATION.getValue());
tracesNoManageList.add(traceNoManage);
}
}
}
// 药品发放更新
@@ -517,18 +439,34 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
// 库存更新
iInventoryItemService.updateBatchById(inventoryItemList);
inventoryItemService.updateBatchById(inventoryItemList);
// 追溯码管理表数据追加
boolean result = traceNoManageService.saveBatch(tracesNoManageList);
if (!result) {
return R.fail(MessageUtils.createMessage(PromptMsgConstant.Common.M00007, null));
}
traceNoManageService.saveBatch(tracesNoManageList);
// 返回信息
String returnMsg = null;
List<String> uploadFailedNoList;
// 调用医保商品销售接口
String ybSwitch = SecurityUtils.getLoginUser().getOptionJson().getString(CommonConstants.Option.YB_SWITCH); // 医保开关
if (Whether.YES.getCode().equals(ybSwitch)) {
List<String> uploadFailedNoList = this.ybMedicineIntegrated(medDispenseIdList, null);
// 设置进销存参数
List<MedicationDefinition> medicationDefinitions = medicationDefinitionService.listByIds(
supplyItemDetailList.stream().map(SupplyItemDetailDto::getItemId).collect(Collectors.toList()));
// 用itemId分组
Map<Long, MedicationDefinition> medicationMap = medicationDefinitions.stream()
.collect(Collectors.toMap(MedicationDefinition::getId, Function.identity()));
// 设置库存变更参数
for (SupplyItemDetailDto dto : supplyItemDetailList) {
if (CommonConstants.TableName.MED_MEDICATION_DEFINITION.equals(dto.getItemTable())) {
MedicationDefinition med = medicationMap.get(dto.getItemId());
if (med != null) {
dto.setItemBusNo(med.getBusNo()).setPartPercent(med.getPartPercent()).setRxFlag(med.getRxFlag())
.setYbNo(med.getYbNo());
}
}
}
uploadFailedNoList = this.ybMedicineIntegrated(medDispenseIdList, null);
uploadFailedNoList = receiptApprovalAppService.ybInventoryIntegrated(supplyItemDetailList,
YbInvChgType.OTHER_OUT, DateUtils.getNowDate());
if (uploadFailedNoList != null) {
returnMsg = "3505商品销售上传错误，错误项目编码" + uploadFailedNoList;
} else {
@@ -545,10 +483,10 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
* @return 处理结果
*/
@Override
public R<?> medicineCancel(List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicineCancel(List<DispenseItemDto> dispenseMedicineList) {
// 获取发药单id列表
List<Long> medDispenseIdList =
dispenseMedicineList.stream().map(DispenseMedicineDto::getDispenseId).collect(Collectors.toList());
dispenseMedicineList.stream().map(DispenseItemDto::getDispenseId).collect(Collectors.toList());
// 药品发药信息查询
List<MedicationDispense> dispenseList = medicationDispenseService
.list(new LambdaQueryWrapper<MedicationDispense>().in(MedicationDispense::getId, medDispenseIdList));
@@ -604,12 +542,12 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
ChargeItem chargeItem = null;
if (CommonConstants.TableName.MED_MEDICATION_DEFINITION.equals(dispenseInventoryDto.getItemTable())) {
// 查询费用结算信息
chargeItem = iChargeItemService.getOne(new LambdaQueryWrapper<ChargeItem>()
chargeItem = chargeItemService.getOne(new LambdaQueryWrapper<ChargeItem>()
.eq(ChargeItem::getServiceTable, CommonConstants.TableName.MED_MEDICATION_REQUEST)
.eq(ChargeItem::getServiceId, dispenseInventoryDto.getReqId())
.eq(ChargeItem::getTenantId, SecurityUtils.getLoginUser().getTenantId()));
} else if (CommonConstants.TableName.ADM_DEVICE_DEFINITION.equals(dispenseInventoryDto.getItemTable())) {
chargeItem = iChargeItemService.getOne(new LambdaQueryWrapper<ChargeItem>()
chargeItem = chargeItemService.getOne(new LambdaQueryWrapper<ChargeItem>()
.eq(ChargeItem::getServiceTable, CommonConstants.TableName.WOR_DEVICE_REQUEST)
.eq(ChargeItem::getServiceId, dispenseInventoryDto.getReqId())
.eq(ChargeItem::getTenantId, SecurityUtils.getLoginUser().getTenantId()));
@@ -625,7 +563,7 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
}
// 查询付款信息
List<PaymentReconciliation> paymentReconciliationList =
iPaymentReconciliationService.list(new LambdaQueryWrapper<PaymentReconciliation>()
paymentReconciliationService.list(new LambdaQueryWrapper<PaymentReconciliation>()
.eq(PaymentReconciliation::getEncounterId, dispenseInventoryDto.getEncounterId())
.eq(PaymentReconciliation::getTenantId, SecurityUtils.getLoginUser().getTenantId())
.like(PaymentReconciliation::getChargeItemIds, chargeItem.getId())
@@ -646,7 +584,7 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
}
// 查询合同实体
Contract contract =
iContractService.getOne(new LambdaQueryWrapper<Contract>().eq(Contract::getBusNo, account.getContractNo()));
contractService.getOne(new LambdaQueryWrapper<Contract>().eq(Contract::getBusNo, account.getContractNo()));
if (contract == null) {
throw new ServiceException("未查找到合同信息");
}
@@ -732,107 +670,4 @@ public class IWesternMedicineDispenseAppServiceImpl implements IWesternMedicineD
return medical3505Param;
}
/**
* 处方单查询
*
* @param locationId 库房id
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@Override
public R<?> getMonthlySettlementPatientInfoList(Long locationId, String startTime, String endTime,Integer pageNo, Integer pageSize) {
// 患者基本信息查询
PrescriptionPatientInfoDto prescriptionPatientInfoDto =new PrescriptionPatientInfoDto();
// 处方单信息查询
Page<PrescriptionMedicineInfoDto> prescriptionMedicineInfoPage =
westernMedicineDispenseMapper.selectMonthlySettlementPatientInfoList(new Page<>(pageNo, pageSize),
locationId,startTime, endTime, DispenseStatus.COMPLETED.getValue(),ItemType.MEDICINE.getValue(),
ItemType.DEVICE.getValue());
// 查询字典值
List<SysDictData> unitCodeList = sysDictDataMapper.selectDictDataByType("unit_code");
Map<String, String> unitCodeLabel = unitCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<SysDictData> methodCodeList = sysDictDataMapper.selectDictDataByType("method_code");
Map<String, String> methodCodeLabel = methodCodeList.stream().collect(
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
));
List<PrescriptionMedicineInfoDto> prescriptionMedicineInfoList = prescriptionMedicineInfoPage.getRecords();
Collectors.toMap(SysDictData::getDictValue, SysDictData::getDictLabel, (oldValue, newValue) -> oldValue // 如果有重复键，保留旧值
);
prescriptionMedicineInfoList.forEach(prescriptionMedicineInfo -> {
if(prescriptionMedicineInfo.getType().equals(ItemType.MEDICINE.getValue())){
// 发药状态
prescriptionMedicineInfo.setStatusEnum_enumText(
EnumUtils.getInfoByValue(DispenseStatus.class, prescriptionMedicineInfo.getStatusEnum()));
// 匹配剂量单位字典文本
String doseUnitCode = prescriptionMedicineInfo.getDoseUnitCode();
String doseUnitLabel = unitCodeLabel.getOrDefault(doseUnitCode, "");
prescriptionMedicineInfo.setDoseUnitCode_dictText(doseUnitLabel);
// 匹配单位字典文本
String unitCode = prescriptionMedicineInfo.getUnitCode();
String unitLabel = unitCodeLabel.getOrDefault(unitCode, "");
prescriptionMedicineInfo.setUnitCode_dictText(unitLabel);
// 匹配用法字典文本
String methodCode = prescriptionMedicineInfo.getMethodCode();
String methodLabel = methodCodeLabel.getOrDefault(methodCode, "");
prescriptionMedicineInfo.setMethodCode_dictText(methodLabel);
switch (prescriptionMedicineInfo.getPharmacologyCategoryCode()) {
case "2": // 麻醉药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("麻醉");
case "3": // 毒性药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("毒性");
case "4": // 一类精神药
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("精一");
case "5": // 二类精神药
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("精二");
default: // 普通药品
prescriptionMedicineInfo.setPharmacologyCategoryCode_Text("普通");
}
// 判断是否为慢病
if (EncounterYbClass.CHRONIC_DISEASE_OUTPATIENT.getCode()
.equals(prescriptionMedicineInfo.getMedTypeCode())) {
prescriptionMedicineInfo.setChronicDisease(Whether.YES.getInfo());
} else {
prescriptionMedicineInfo.setChronicDisease(Whether.NO.getInfo());
}
// 皮试flag为是时
if (Whether.YES.getValue().equals(prescriptionMedicineInfo.getSkinTestFlag())) {
// 获取皮试结果
ServiceRequest serReqObj =
serviceRequestService.selectByMedRequestId(prescriptionMedicineInfo.getRequestId());
if (serReqObj != null) {
Integer clinicalStatus = allergyIntoleranceService.getPsResultByRequestId(serReqObj.getId());
prescriptionMedicineInfo.setPsResult(ClinicalStatus.getByValue(clinicalStatus).getInfo());
}
} else {
prescriptionMedicineInfo.setPsResult("无");
}
}
});
// 计算合计金额
if (!prescriptionMedicineInfoList.isEmpty()) {
double totalPrice = 0d;
for (PrescriptionMedicineInfoDto item : prescriptionMedicineInfoList) {
totalPrice += item.getTotalPrice().doubleValue();
}
prescriptionPatientInfoDto.setTotalPrice(totalPrice);
}
PrescriptionInfoDto prescriptionInfoDto = new PrescriptionInfoDto();
prescriptionInfoDto.setPrescriptionPatientInfoDto(prescriptionPatientInfoDto);
prescriptionInfoDto.setPrescriptionMedicineInfoDtoList(prescriptionMedicineInfoList);
return R.ok(prescriptionInfoDto);
}
}

101
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/ChineseMedicineDispenseController.java
View File

@@ -1,101 +0,0 @@
package com.openhis.web.pharmacymanage.controller;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IChineseMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* 西药发药
*
* @author wangyang
* @date 2025/3/14
*/
@RestController
@RequestMapping("/pharmacy-manage/chinese-medicine-dispense")
@Slf4j
@AllArgsConstructor
public class ChineseMedicineDispenseController {
@Autowired
public IChineseMedicineDispenseAppService chineseMedicineDispenseService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@GetMapping(value = "/init")
public R<?> medicineDispenseInit() {
return chineseMedicineDispenseService.init();
}
/**
* 分页查询就诊病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 就诊病人列表
*/
@GetMapping("/encounter-list")
public R<?> getEncounterInfoList(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return chineseMedicineDispenseService.getEncounterInfoListPage(encounterInfoSearchParam, searchKey, pageNo,
pageSize, request);
}
/**
* 处方单查询
*
* @param encounterId 就诊Id
*/
@GetMapping("/prescription-list")
public R<?> getPatientInfoList(@RequestParam(value = "encounterId") Long encounterId) {
return chineseMedicineDispenseService.getPrescriptionInfo(encounterId);
}
/**
* 配药
*
* @param prescriptionNo 处方号
* @param preparerId 配药人
*/
@PutMapping("/prepare")
public R<?> prepare(@RequestParam(value = "prescriptionNo") String prescriptionNo,
@RequestParam(value = "preparerId") Long preparerId) {
return chineseMedicineDispenseService.prepare(prescriptionNo, preparerId);
}
/**
* 核对发药
*
* @param prescriptionNo 处方号
*/
@PutMapping("/medicine-dispense")
public R<?> medicineDispense(@RequestParam(value = "prescriptionNo") String prescriptionNo) {
return chineseMedicineDispenseService.medicineDispense(prescriptionNo);
}
/**
* 作废
*
* @param prescriptionNo 处方号
* @param notPerformedReasonEnum 未发药原因
*/
@PutMapping("/medicine-cancel")
public R<?> medicineCancel(@RequestParam(value = "prescriptionNo") String prescriptionNo,
@RequestParam(value = "notPerformedReasonEnum") Integer notPerformedReasonEnum) {
return chineseMedicineDispenseService.medicineCancel(prescriptionNo, notPerformedReasonEnum);
}
}

99
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/DeviceDispenseController.java
View File

@@ -1,99 +0,0 @@
package com.openhis.web.pharmacymanage.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import com.openhis.web.pharmacymanage.appservice.IDeviceDispenseAppService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IDeviceDispenseAppService;
import com.openhis.web.pharmacymanage.dto.DispenseDeviceDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionDeviceInfoDto;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* 材料发送
*
* @author yuxj
* @date 2025/8/21
*/
@RestController
@RequestMapping("/pharmacy-manage/device-dispense")
@Slf4j
@AllArgsConstructor
public class DeviceDispenseController {
@Autowired
public IDeviceDispenseAppService deviceDispenseService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@GetMapping(value = "/init")
public R<?> deviceDispenseInit() {
return deviceDispenseService.init();
}
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
@GetMapping("/encounter-list")
public R<?> getEncounterInfoList(EncounterInfoPageDto encounterInfoPageDto, String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return deviceDispenseService.getEncounterInfoListPage(encounterInfoPageDto, searchKey, pageNo,
pageSize, request);
}
/**
* 处方单查询
*
* @param prescriptionDeviceInfoDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@GetMapping("/prescription-list")
public R<?> getPatientInfoList(PrescriptionDeviceInfoDto prescriptionDeviceInfoDto,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
return deviceDispenseService.getPrescriptionInfo(prescriptionDeviceInfoDto, pageNo, pageSize);
}
/**
* 核对发药
*
* @param dispenseDeviceList 发药信息
* @return 处理结果
*/
@PutMapping("/device-dispense")
public R<?> deviceDispense(@RequestBody List<DispenseDeviceDto> dispenseDeviceList) {
return deviceDispenseService.deviceDispense(dispenseDeviceList);
}
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
@PutMapping("/device-cancel")
public R<?> deviceCancel(@RequestBody List<DispenseDeviceDto> dispenseDeviceList) {
return deviceDispenseService.deviceCancel(dispenseDeviceList);
}
}

112
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/InpatientMedicineDispenseController.java
View File

@@ -1,112 +0,0 @@
package com.openhis.web.pharmacymanage.controller;//package com.openhis.web.pharmacymanage.controller;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IInpatientMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.appservice.IWesternMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionMedicineInfoDto;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.util.List;
/**
* 住院发药
*
* @author yuxj
* @date 2025/6/3
*/
@RestController
@RequestMapping("/pharmacy-manage/inpatient-medicine-dispense")
@Slf4j
@AllArgsConstructor
public class InpatientMedicineDispenseController {
@Resource
public IInpatientMedicineDispenseAppService inpatientMedicineDispenseService;
@Autowired
public IWesternMedicineDispenseAppService westernMedicineDispenseService;
/**
* 分页查询发药病人列表
*
* @param encounterInfoPageDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
*/
@GetMapping("/encounter-list")
public R<?> getEncounterInfoList(EncounterInfoPageDto encounterInfoPageDto, String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return inpatientMedicineDispenseService.getEncounterInfoListPage(encounterInfoPageDto, searchKey, pageNo,
pageSize, request);
}
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@GetMapping(value = "/init")
public R<?> medicineDispenseInit() {
return westernMedicineDispenseService.init();
}
/**
* 处方单查询
*
* @param prescriptionMedicineInfoDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@GetMapping("/prescription-list")
public R<?> getPatientInfoList(PrescriptionMedicineInfoDto prescriptionMedicineInfoDto,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
return westernMedicineDispenseService.getPrescriptionInfo(prescriptionMedicineInfoDto, pageNo, pageSize);
}
/**
* 配药
*
* @param dispenseMedicineList 配药信息
* @return 处理结果
*/
@PutMapping("/prepare")
public R<?> medicinePrepare(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicinePrepare(dispenseMedicineList);
}
/**
* 核对发药
*
* @param dispenseMedicineList 发药信息
* @return 处理结果
*/
@PutMapping("/medicine-dispense")
public R<?> medicineDispense(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicineDispense(dispenseMedicineList);
}
/**
* 作废
*
* @param dispenseMedicineList 作废信息
* @return 处理结果
*/
@PutMapping("/medicine-cancel")
public R<?> medicineCancel(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicineCancel(dispenseMedicineList);
}
}

2
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/InpatientMedicineSummaryDispenseController.java
View File

@@ -3,8 +3,6 @@ package com.openhis.web.pharmacymanage.controller;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import org.apache.ibatis.annotations.Param;
import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;

46
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/MedicalConsumablesDispenseController.java
View File

@@ -1,46 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.controller;
import java.util.List;
import javax.annotation.Resource;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IMedicalConsumablesDispenseAppService;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* 耗材发放
*
* @author zwh
* @date 2025-06-20
*/
@RestController
@RequestMapping("/pharmacy-manage/medical-consumables-dispense")
@Slf4j
@AllArgsConstructor
public class MedicalConsumablesDispenseController {
@Resource
public IMedicalConsumablesDispenseAppService medicalConsumablesDispenseAppService;
/**
* 发放耗材
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
@PutMapping("/consumables-dispense")
public R<?> dispenseMedicalConsumables(@RequestBody List<Long> chargeItemIds) {
return medicalConsumablesDispenseAppService.dispenseMedicalConsumables(chargeItemIds);
}
}

109
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/MedicalDeviceDispenseController.java Normal file
View File

@@ -0,0 +1,109 @@
package com.openhis.web.pharmacymanage.controller;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IMedicalDeviceDispenseAppService;
import com.openhis.web.pharmacymanage.dto.DispenseItemDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* 材料发送
*
* @author yuxj
* @date 2025/8/21
*/
@RestController
@RequestMapping("/pharmacy-manage/device-dispense")
@Slf4j
@AllArgsConstructor
public class MedicalDeviceDispenseController {
@Autowired
public IMedicalDeviceDispenseAppService medicalDeviceDispenseAppService;
/**
* 获取页面初始化信息
*
* @return 初始化信息
*/
@GetMapping(value = "/init")
public R<?> deviceDispenseInit() {
return medicalDeviceDispenseAppService.init();
}
/**
* 分页查询病人列表
*
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 病人列表
*/
@GetMapping("/encounter-list")
public R<?> getEncounterInfoList(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return medicalDeviceDispenseAppService.getEncounterInfoListPage(encounterInfoSearchParam, searchKey, pageNo,
pageSize, request);
}
/**
* 发耗材单查询
*
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 发耗材单
*/
@GetMapping("/device-order")
public R<?> getDeviceDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
return medicalDeviceDispenseAppService.getDeviceDispenseOrderList(itemDispenseOrderDto, pageNo, pageSize);
}
/**
* 核对发耗材
*
* @param dispenseDeviceList 发耗材信息
* @return 处理结果
*/
@PutMapping("/device-dispense")
public R<?> deviceDispense(@RequestBody List<DispenseItemDto> dispenseDeviceList) {
return medicalDeviceDispenseAppService.deviceDispense(dispenseDeviceList);
}
/**
* 发放耗材（长大专属）
*
* @param chargeItemIds 耗材收费单ids
* @return 处理结果
*/
@PutMapping("/consumables-dispense")
public R<?> dispenseMedicalConsumables(@RequestBody List<Long> chargeItemIds) {
return medicalDeviceDispenseAppService.dispenseMedicalConsumables(chargeItemIds);
}
/**
* 作废
*
* @param dispenseDeviceList 作废信息
* @return 处理结果
*/
@PutMapping("/device-cancel")
public R<?> deviceCancel(@RequestBody List<DispenseItemDto> dispenseDeviceList) {
return medicalDeviceDispenseAppService.deviceCancel(dispenseDeviceList);
}
}

10
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/ReturnMedicineController.java
View File

@@ -9,14 +9,14 @@ import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IReturnMedicineAppService;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoDto;
import com.openhis.web.pharmacymanage.dto.ReturnMedicineDto;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
/**
* 退药管理
* 退药(退耗材)管理
*
* @author yangmo
* @date 2025/4/4
@@ -43,7 +43,7 @@ public class ReturnMedicineController {
/**
* 查询退药患者分页列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoDto 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
@@ -51,11 +51,11 @@ public class ReturnMedicineController {
* @return 退药患者分页列表
*/
@GetMapping(value = "/return-patient-page")
public R<?> getReturnMedicinePatientPage(EncounterInfoPageDto encounterInfoPageDto,
public R<?> getReturnMedicinePatientPage(EncounterInfoDto encounterInfoDto,
@RequestParam(value = "searchKey", defaultValue = "") String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return returnMedicineAppService.getReturnMedicinePatientPage(encounterInfoPageDto, searchKey, pageNo, pageSize,
return returnMedicineAppService.getReturnMedicinePatientPage(encounterInfoDto, searchKey, pageNo, pageSize,
request);
}

49
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/controller/WesternMedicineDispenseController.java
View File

@@ -9,9 +9,9 @@ import org.springframework.web.bind.annotation.*;
import com.core.common.core.domain.R;
import com.openhis.web.pharmacymanage.appservice.IWesternMedicineDispenseAppService;
import com.openhis.web.pharmacymanage.dto.DispenseMedicineDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionMedicineInfoDto;
import com.openhis.web.pharmacymanage.dto.DispenseItemDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
import lombok.AllArgsConstructor;
import lombok.extern.slf4j.Slf4j;
@@ -42,36 +42,36 @@ public class WesternMedicineDispenseController {
}
/**
* 分页查询发药病人列表
* 分页查询病人列表
*
* @param encounterInfoPageDto 查询条件
* @param encounterInfoSearchParam 查询条件
* @param searchKey 模糊查询关键字
* @param pageNo 当前页码
* @param pageSize 查询条数
* @param request 请求数据
* @return 发药病人列表
* @return 病人列表
*/
@GetMapping("/encounter-list")
public R<?> getEncounterInfoList(EncounterInfoPageDto encounterInfoPageDto, String searchKey,
public R<?> getEncounterInfoList(EncounterInfoSearchParam encounterInfoSearchParam, String searchKey,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize, HttpServletRequest request) {
return westernMedicineDispenseService.getEncounterInfoListPage(encounterInfoPageDto, searchKey, pageNo,
return westernMedicineDispenseService.getEncounterInfoListPage(encounterInfoSearchParam, searchKey, pageNo,
pageSize, request);
}
/**
* 处方单查询
* 发药单查询
*
* @param prescriptionMedicineInfoDto 查询信息
* @param itemDispenseOrderDto 查询信息
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@GetMapping("/prescription-list")
public R<?> getPatientInfoList(PrescriptionMedicineInfoDto prescriptionMedicineInfoDto,
@GetMapping("/medicine-order")
public R<?> getMedicineDispenseOrderList(ItemDispenseOrderDto itemDispenseOrderDto,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
return westernMedicineDispenseService.getPrescriptionInfo(prescriptionMedicineInfoDto, pageNo, pageSize);
return westernMedicineDispenseService.getMedicineDispenseOrderList(itemDispenseOrderDto, pageNo, pageSize);
}
/**
@@ -81,7 +81,7 @@ public class WesternMedicineDispenseController {
* @return 处理结果
*/
@PutMapping("/prepare")
public R<?> medicinePrepare(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicinePrepare(@RequestBody List<DispenseItemDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicinePrepare(dispenseMedicineList);
}
@@ -92,7 +92,7 @@ public class WesternMedicineDispenseController {
* @return 处理结果
*/
@PutMapping("/medicine-dispense")
public R<?> medicineDispense(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicineDispense(@RequestBody List<DispenseItemDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicineDispense(dispenseMedicineList);
}
@@ -103,24 +103,7 @@ public class WesternMedicineDispenseController {
* @return 处理结果
*/
@PutMapping("/medicine-cancel")
public R<?> medicineCancel(@RequestBody List<DispenseMedicineDto> dispenseMedicineList) {
public R<?> medicineCancel(@RequestBody List<DispenseItemDto> dispenseMedicineList) {
return westernMedicineDispenseService.medicineCancel(dispenseMedicineList);
}
/**
* 处方单查询
*
* @param locationId 库房id
* @param startTime 开始时间
* @param endTime 结束时间
* @param pageNo 当前页码
* @param pageSize 查询条数
* @return 处方单
*/
@GetMapping("/prescription-list-monthly-settlement")
public R<?> getMonthlySettlementPatientInfoList(@RequestParam Long locationId, @RequestParam String startTime,@RequestParam String endTime,
@RequestParam(value = "pageNo", defaultValue = "1") Integer pageNo,
@RequestParam(value = "pageSize", defaultValue = "10") Integer pageSize) {
return westernMedicineDispenseService.getMonthlySettlementPatientInfoList(locationId, startTime,endTime,pageNo,pageSize);
}
}

42
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/DispenseDeviceDto.java
View File

@@ -1,42 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.dto;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 发材料信息
*
* @author yuxj
* @date 2025-08-21
*/
@Data
@Accessors(chain = true)
public class DispenseDeviceDto {
/** 请求ID */
@JsonSerialize(using = ToStringSerializer.class)
private Long requestId;
/** 配药人 */
@JsonSerialize(using = ToStringSerializer.class)
private Long preparerId;
/** 发放ID */
@JsonSerialize(using = ToStringSerializer.class)
private Long dispenseId;
/** 追溯码 */
private String traceNo;
/** 处方号 */
private String prescriptionNo;
/** 未发原因 */
private Integer notPerformedReasonEnum;
}

19
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/DispenseInitDto.java
View File

@@ -7,12 +7,13 @@ import java.util.List;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.enums.DispenseStatus;
import lombok.Data;
import lombok.experimental.Accessors;
/**
*
* 发放列表初始化
*
* @author wangyang
* @date 2025-03-14
*/
@@ -32,6 +33,9 @@ public class DispenseInitDto {
/** 发药状态 */
private List<PreparerDoctorOption> preparerDoctorOptions;
/** 患者类型 */
private List<EncounterClassOption> encounterClassOptions;
@Data
public static class DepartmentOption {
@JsonSerialize(using = ToStringSerializer.class)
@@ -55,6 +59,17 @@ public class DispenseInitDto {
}
}
@Data
public static class EncounterClassOption {
private Integer value;
private String label;
public EncounterClassOption(Integer value, String label) {
this.value = value;
this.label = label;
}
}
@Data
public static class DispenseStatusOption {
private Integer value;

2
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/DispenseInventoryDto.java
View File

@@ -41,7 +41,7 @@ public class DispenseInventoryDto {
private String dispenseUnitCode;
/** 请求数量 */
private Integer dispenseQuantity;
private BigDecimal dispenseQuantity;
/** 发放数量 */
private Integer dispenseStatus;

11
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/DispenseMedicineDto.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/DispenseItemDto.java
View File

@@ -10,18 +10,14 @@ import lombok.Data;
import lombok.experimental.Accessors;
/**
* 发药信息
* 发药/耗材信息
*
* @author zwh
* @date 2025-05-23
*/
@Data
@Accessors(chain = true)
public class DispenseMedicineDto {
/** 请求ID */
@JsonSerialize(using = ToStringSerializer.class)
private Long requestId;
public class DispenseItemDto {
/** 配药人 */
@JsonSerialize(using = ToStringSerializer.class)
@@ -34,9 +30,6 @@ public class DispenseMedicineDto {
/** 追溯码 */
private String traceNo;
/** 处方号 */
private String prescriptionNo;
/** 未发原因 */
private Integer notPerformedReasonEnum;
}

9
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/EncounterInfoPageDto.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/EncounterInfoDto.java
View File

@@ -3,14 +3,14 @@
*/
package com.openhis.web.pharmacymanage.dto;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import lombok.experimental.Accessors;
import java.util.Date;
/**
* 就诊人员列表
*
@@ -19,7 +19,7 @@ import java.util.Date;
*/
@Data
@Accessors(chain = true)
public class EncounterInfoPageDto {
public class EncounterInfoDto {
/** 就诊ID */
@JsonSerialize(using = ToStringSerializer.class)
@@ -78,7 +78,4 @@ public class EncounterInfoPageDto {
/** 生日 */
private Date birthDate;
/** 中药标识 */
private Integer tcmFlag;
}

8
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/EncounterInfoSearchParam.java
View File

@@ -4,15 +4,12 @@
package com.openhis.web.pharmacymanage.dto;
import java.io.Serializable;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 处方列表查询条件
* 患者列表查询条件
*
* @author wangyang
* @date 2025-03-14
@@ -23,4 +20,7 @@ public class EncounterInfoSearchParam implements Serializable {
/** 执行状态 */
private Integer statusEnum;
/** 患者类型 */
private Integer classEnum;
}

2
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/InpatientMedicineInitDto.java
View File

@@ -13,7 +13,7 @@ import lombok.Data;
import lombok.experimental.Accessors;
/**
*住院发药初期dto
* 住院发药初期dto
*
* @author yuxj
* @date 2025-06-03

45
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/InpatientMedicineMapInfoDto.java
View File

@@ -1,45 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.dto;
import java.io.Serializable;
import java.util.List;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.annotation.Dict;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 映射信息
*
* @author yuxj
* @date 2025-06-03
*/
@Data
@Accessors(chain = true)
public class InpatientMedicineMapInfoDto implements Serializable {
/** 项目发放 */
@JsonSerialize(using = ToStringSerializer.class)
private Long dispenseId;
/** 追溯码*/
private String traceNo;
/** 追溯码单位 */
@Dict(dictCode = "unit_code")
private String traceNoUnitCode;
private String traceNoUnitCode_dictText;
/** 供应发放id */
@JsonSerialize(using = ToStringSerializer.class)
private Long deliveryId;
/** 发放表名 */
private String tableName;
}

14
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/InpatientMedicineSummaryPrescriptionInfoDto.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/InpatientMedicineSummaryDto.java
View File

@@ -10,17 +10,18 @@ import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.annotation.Dict;
import com.openhis.web.pharmacyWarehousemanage.dto.PharmacyWarehouseDetailDto;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 医嘱详细
* 汇总发药信息
*
* @author yuxj
* @date 2025-06-03
*/
@Data @Accessors(chain = true) public class InpatientMedicineSummaryPrescriptionInfoDto {
@Data
@Accessors(chain = true)
public class InpatientMedicineSummaryDto {
/**
* 单据号
@@ -109,18 +110,19 @@ import lombok.experimental.Accessors;
/**
* 单位列表
*/
private List<InpatientMedicineSummaryPrescriptionInfoDto.Option> unitList;
private List<InpatientMedicineSummaryDto.Option> unitList;
@Data
public static class Option {
@Dict(dictCode = "unit_code")
private String value;
private String value_dictText;
public Option(String value, String value_dictText) {
this.value = value;
this.value_dictText = value_dictText;
}
public Option() {
}
public Option() {}
}
}

76
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/PrescriptionMedicineInfoDto.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/ItemDispenseOrderDto.java
View File

@@ -3,26 +3,26 @@
*/
package com.openhis.web.pharmacymanage.dto;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.annotation.Dict;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* 处方发药单
* 发药/耗材单
*
* @author wangyang
* @date 2025-03-14
*/
@Data
@Accessors(chain = true)
public class PrescriptionMedicineInfoDto {
public class ItemDispenseOrderDto {
/**
* 发放药房
@@ -31,10 +31,10 @@ public class PrescriptionMedicineInfoDto {
private Long locationId;
/**
* 药品id
* 项目id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long medicineId;
private Long itemId;
/**
* 发放id
@@ -79,11 +79,6 @@ public class PrescriptionMedicineInfoDto {
*/
private String dispenseDoctorName;
/**
* 配药医生
*/
private String preparerDoctorName;
/**
* 项目类型
*/
@@ -108,9 +103,9 @@ public class PrescriptionMedicineInfoDto {
private String prescriptionNo;
/**
* 药品名称
* 项目名称
*/
private String medicineName;
private String itemName;
/**
* 规格
@@ -150,26 +145,6 @@ public class PrescriptionMedicineInfoDto {
private String unitCode;
private String unitCode_dictText;
/**
* 单次最大剂量
*/
private BigDecimal maxDose;
/**
* 首次用量
*/
private BigDecimal firstDose;
/**
* 首次持续时间
*/
private String firstDuration;
/**
* 给药间隔
*/
private String dispenseInterval;
/**
* 单次发药数
*/
@@ -210,33 +185,22 @@ public class PrescriptionMedicineInfoDto {
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private Date reqAuthoredTime;
/**
* 就诊账户类型
*/
private String chargeType;
/** 药品性质 */
private String pharmacologyCategoryCode;
/** 药品性质文本 */
private String pharmacologyCategoryCode_Text;
/** 特殊病种标志 */
private String medTypeCode;
/** 慢性病 是/否 */
private String chronicDisease;
/** 皮试标志 */
private Integer skinTestFlag;
/** 中药标识 */
private Integer tcmFlag;
/** 皮试结果 */
private String psResult;
/** 所在表 */
private String itemTable;
/** 药品类型 */
private Integer type;
/**
* 生产厂家
*/
private String manufacturerText;
/**
* 追溯码
*/
private String traceNo;
}

2
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/MedDetailsSearchParam.java
View File

@@ -38,4 +38,6 @@ public class MedDetailsSearchParam {
/** 出院状态 */
private Integer dischargeStatus;
/** 门诊住院flg */
private Integer flag;
}

81
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/MedRunningAccountPageDto.java
View File

@@ -1,81 +0,0 @@
package com.openhis.web.pharmacymanage.dto;
import com.alibaba.fastjson2.annotation.JSONField;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.annotation.Dict;
import lombok.Data;
import lombok.experimental.Accessors;
import org.springframework.format.annotation.DateTimeFormat;
import java.math.BigDecimal;
import java.util.Date;
/**
* 明细流水账分页列表 dto
*
* @author yuanzs
* @date 2025-04-14
*/
@Data
@Accessors(chain = true)
public class MedRunningAccountPageDto {
/** 门诊号 */
private String outpatientNo;
/** 住院号 */
private Integer admissionNo;
/** 处方号 */
private String prescriptionNo;
/** 患者 */
private String patientName;
/** 发药人 */
@Dict(dictCode = "id", dictText = "name", dictTable = "adm_practitioner")
@JsonSerialize(using = ToStringSerializer.class)
private Long practitionerId;
private String practitionerId_dictText;
/** 药品项目 */
private String medicineName;
/** 规格 */
private String totalVolume;
/** 零售价 */
private BigDecimal retailPrice;
/** 发药数量 */
private Integer dispenseQuantity;
/** 发药金额 */
private BigDecimal dispensePrice;
/** 退药数量 */
private Integer returnQuantity;
/** 退药金额 */
private BigDecimal returnPrice;
/** 批号 */
private String lotNumber;
/** 发药时间 */
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@JSONField(name="dispense_time")
private Date dispenseTime;
/** 厂商 */
private String manufacturerText;
/** 供应商 */
@Dict(dictCode = "id", dictText = "name", dictTable = "adm_supplier")
@JsonSerialize(using = ToStringSerializer.class)
private Long supplyId;
private String supplyId_dictText;
}

230
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/PrescriptionDeviceInfoDto.java
View File

@@ -1,230 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.dto;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.openhis.common.annotation.Dict;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 处方发材料单
*
* @author yuxj
* @date 2025-08-21
*/
@Data
@Accessors(chain = true)
public class PrescriptionDeviceInfoDto {
/**
* 科室
*/
private String departmentName;
/**
* 开单医生
*/
private String doctorName;
/**
* 项目类型
*/
@Dict(dictCode = "med_category_code")
private String itemType;
private String itemType_dictText;
/**
* 诊断名称
*/
private String conditionName;
/**
* 处方号
*/
private String prescriptionNo;
/**
* 批次号
*/
private String lotNumber;
/**
* 请求id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long requestId;
/**
* 材料id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long deviceId;
/**
* 材料名称
*/
private String deviceName;
/**
* 规格
*/
private String totalVolume;
/**
* 单位
*/
@Dict(dictCode = "unit_code")
private String unitCode;
private String unitCode_dictText;
/**
* 就诊id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long encounterId;
/**
* 发药状态
*/
private Integer statusEnum;
private String statusEnum_enumText;
/**
* 用药频次
*/
private String rateCode;
/**
* 发放药房
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long locationId;
/**
* 数量
*/
private Integer quantity;
/**
* 发放id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long dispenseId;
/**
* 发放药房
*/
private String locationName;
/**
* 单价
*/
private BigDecimal unitPrice;
/**
* 金额
*/
private BigDecimal totalPrice;
/**
* 发药医生
*/
private String dispenseDoctorName;
/**
* 就诊NO
*/
@JsonSerialize(using = ToStringSerializer.class)
private String encounterBusNo;
/** 开具日期 */
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private Date reqAuthoredTime;
/**
* 就诊账户类型
*/
private String chargeType;
/** 特殊病种标志 */
private String medTypeCode;
/** 慢性病 是/否 */
private String chronicDisease;
//
// /**
// * 配药医生
// */
// private String preparerDoctorName;
//
// /**
// * 单次剂量
// */
// private BigDecimal dose;
//
// /**
// * 用法
// */
// @Dict(dictCode = "method_code")
// private String methodCode;
// private String methodCode_dictText;
//
// /**
// * 剂量单位
// */
// @Dict(dictCode = "unit_code")
// private String doseUnitCode;
// private String doseUnitCode_dictText;
//
// /**
// * 单次最大剂量
// */
// private BigDecimal maxDose;
//
// /**
// * 首次用量
// */
// private BigDecimal firstDose;
//
// /**
// * 首次持续时间
// */
// private String firstDuration;
//
// /**
// * 给药间隔
// */
// private String dispenseInterval;
//
// /**
// * 单次发药数
// */
// private Integer dispensePerQuantity;
//
// /**
// * 每次发药供应天数
// */
// private Integer dispensePerDuration;
//
// /**
// * 组合号
// */
// @JsonSerialize(using = ToStringSerializer.class)
// private Long groupId;
//
// /** 药品性质 */
// private String pharmacologyCategoryCode;
//
// /** 药品性质文本 */
// private String pharmacologyCategoryCode_Text;
//
//
// /** 皮试标志 */
// private Integer skinTestFlag;
//
// /** 皮试结果 */
// private String psResult;
}

30
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/PrescriptionInfoDto.java
View File

@@ -1,30 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.dto;
import java.util.List;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 处方信息
*
* @author wangyang
* @date 2025-03-14
*/
@Data
@Accessors(chain = true)
public class PrescriptionInfoDto {
/** 患者基本信息 */
private PrescriptionPatientInfoDto prescriptionPatientInfoDto;
/** 处方药品信息 */
private List<PrescriptionMedicineInfoDto> prescriptionMedicineInfoDtoList;
/** 处方材料信息 */
private List<PrescriptionDeviceInfoDto> prescriptionDeviceInfoDtoList;
}

76
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/dto/PrescriptionPatientInfoDto.java
View File

@@ -1,76 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.dto;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import lombok.Data;
import lombok.experimental.Accessors;
/**
* 患者基本信息
*
* @author wangyang
* @date 2025-03-14
*/
@Data
@Accessors(chain = true)
public class PrescriptionPatientInfoDto {
/** 姓名 */
private String patientName;
/** 性别 */
private Integer genderEnum;
private String genderEnum_enumText;
/** 生日 */
private Date birthDate;
/** 年龄 */
private String age;
/** 合同类型 */
private Integer categoryEnum;
private String categoryEnum_enumText;
private String contractName;
/** 证件号 */
private String idCard;
/** 就诊科室 */
private String organizationName;
/** 就诊日期 */
private String encounterDate;
/** 总金额 */
private double totalPrice;
/** 电话 */
private String phone;
/** 医院名字 */
private String hospitalName;
/** 患者院内编码/病历号 */
private String patientBusNo;
/**
* 就诊id
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long encounterId;
/**
* 诊断
*/
@JsonSerialize(using = ToStringSerializer.class)
private Long conditionId;
private String conditionName;
}

53
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/ChineseMedicineDispenseMapper.java
View File

@@ -1,53 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.openhis.web.pharmacymanage.dto.*;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface ChineseMedicineDispenseMapper {
/**
* 就诊病人列表分页查询
*
* @param page 分页
* @param queryWrapper 查询条件
* @return 就诊病人列表
*/
Page<EncounterInfoPageDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoSearchParam> queryWrapper);
/**
* 患者基本信息查询
*
* @param encounterId 就诊号
* @return 患者基本信息
*/
PrescriptionPatientInfoDto selectPrescriptionPatientInfo(@Param("encounterId") Long encounterId);
/**
* 处方单查询
*
* @param encounterId 就诊号
* @return 处方单列表
*/
List<PrescriptionMedicineInfoDto> selectPrescriptionMedicineInfoList(@Param("encounterId") Long encounterId);
/**
* 待发药和库存信息查询
*
* @param prescriptionNo 处方号
* @return 待发药信息
*/
List<DispenseInventoryDto> selectDispenseInventoryInfoByPrescriptionNo(
@Param("prescriptionNo") String prescriptionNo,
@Param("medMedicationDefinition") String medMedicationDefinition);
}

10
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/InpatientMedicineDispenseMapper.java
View File

@@ -1,10 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.mapper;
import org.springframework.stereotype.Repository;
@Repository
public interface InpatientMedicineDispenseMapper {
}

4
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/InpatientMedicineSummaryDispenseMapper.java
View File

@@ -3,8 +3,6 @@
*/
package com.openhis.web.pharmacymanage.mapper;
import java.util.List;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.openhis.web.inhospitalnursestation.dto.InpatientMedicinePrescriptionInfoDto;
@@ -26,7 +24,7 @@ public interface InpatientMedicineSummaryDispenseMapper {
* @param deviceDefinition 耗材定义
* @return 医嘱信息
*/
Page<InpatientMedicineSummaryPrescriptionInfoDto> selectMedicationSummaryInfo(
Page<InpatientMedicineSummaryDto> selectMedicationSummaryInfo(
@Param("page") Page<InpatientMedicinePrescriptionInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<InpatientMedicineSearchParam> queryWrapper,
@Param("medicationDefinition") String medicationDefinition,

53
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/MedicalConsumablesDispenseAppMapper.java
View File

@@ -1,53 +0,0 @@
/*
* Copyright ©2023 CJB-CNIT Team. All rights reserved
*/
package com.openhis.web.pharmacymanage.mapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.openhis.web.pharmacymanage.dto.*;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;
import java.util.List;
@Repository
public interface MedicalConsumablesDispenseAppMapper {
/**
* 就诊病人列表分页查询
*
* @param page 分页
* @param queryWrapper 查询条件
* @return 就诊病人列表
*/
Page<EncounterInfoPageDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoSearchParam> queryWrapper);
/**
* 患者基本信息查询
*
* @param encounterId 就诊号
* @return 患者基本信息
*/
PrescriptionPatientInfoDto selectPrescriptionPatientInfo(@Param("encounterId") Long encounterId);
/**
* 处方单查询
*
* @param encounterId 就诊号
* @return 处方单列表
*/
List<PrescriptionMedicineInfoDto> selectPrescriptionConsumablesInfoList(@Param("encounterId") Long encounterId);
/**
* 待发药和库存信息查询
*
* @param prescriptionNo 处方号
* @return 待发药信息
*/
List<DispenseInventoryDto> selectDispenseInventoryInfoByPrescriptionNo(
@Param("prescriptionNo") String prescriptionNo,
@Param("medMedicationDefinition") String medMedicationDefinition);
}

29
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/IDeviceDispenseMapper.java → openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/MedicalDeviceDispenseMapper.java
View File

@@ -12,12 +12,12 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.openhis.administration.domain.Practitioner;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionDeviceInfoDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionPatientInfoDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
@Repository
public interface IDeviceDispenseMapper {
public interface MedicalDeviceDispenseMapper {
/**
* 就诊病人列表分页查询
@@ -29,23 +29,13 @@ public interface IDeviceDispenseMapper {
* @param completed 发药状态:已发药
* @param preparation 发药状态:待配药
* @param prepared 发药状态:已配药
* @param amb 就诊类型：门诊
* @return 就诊病人列表
*/
Page<EncounterInfoPageDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoPageDto> queryWrapper,
Page<EncounterInfoDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoSearchParam> queryWrapper,
@Param("statusEnum") Integer statusEnum, @Param("inProgress") Integer inProgress,
@Param("completed") Integer completed, @Param("preparation") Integer preparation,
@Param("prepared") Integer prepared, @Param("amb") Integer amb);
/**
* 患者基本信息查询
*
* @param encounterId 就诊号
* @return 患者基本信息
*/
PrescriptionPatientInfoDto selectPrescriptionPatientInfo(@Param("encounterId") Long encounterId,
@Param("hospitalId") Long hospitalId);
@Param("prepared") Integer prepared);
/**
* 处方单查询
@@ -59,9 +49,8 @@ public interface IDeviceDispenseMapper {
* @param dispenseStatus 发药状态
* @return 处方单列表
*/
Page<PrescriptionDeviceInfoDto> selectPrescriptionDeviceInfoList(
@Param("page") Page<PrescriptionDeviceInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<PrescriptionDeviceInfoDto> queryWrapper,
Page<ItemDispenseOrderDto> selectDeviceDispenseOrderPage(@Param("page") Page<ItemDispenseOrderDto> page,
@Param(Constants.WRAPPER) QueryWrapper<ItemDispenseOrderDto> queryWrapper,
@Param("inProgress") Integer inProgress, @Param("completed") Integer completed,
@Param("preparation") Integer preparation, @Param("prepared") Integer prepared,
@Param("dispenseStatus") Integer dispenseStatus);

33
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/MedicationDetailsMapper.java
View File

@@ -11,7 +11,6 @@ import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.openhis.web.pharmacymanage.dto.MedDetailedAccountPageDto;
import com.openhis.web.pharmacymanage.dto.MedDetailsSearchParam;
import com.openhis.web.pharmacymanage.dto.MedRunningAccountPageDto;
@Repository
public interface MedicationDetailsMapper {
@@ -29,22 +28,22 @@ public interface MedicationDetailsMapper {
*/
Page<MedDetailedAccountPageDto> selectAmbPractitionerDetailPage(@Param("page") Page<MedDetailedAccountPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<MedDetailsSearchParam> queryWrapper, @Param("amb") Integer amb,
@Param("completed") Integer completed, @Param("refunded") Integer refunded,
@Param("dispenseEnum") Integer dispenseEnum);
@Param("completed") Integer completed, @Param("agree") Integer agree, @Param("refunded") Integer refunded,
@Param("dispenseEnum") Integer dispenseEnum, @Param("flg") Integer flg);
// /**
// * 门诊发药明细流水账
// *
// * @param page 分页
// * @param queryWrapper 查询条件
// * @param amb 发药类型：门诊
// * @param completed 发药状态：已发药
// * @param refunded 发药状态：已退药
// * @return 门诊发药明细流水账
// */
// Page<MedDetailedAccountPageDto> selectAmbMedicationDispenseDetailPage(
// @Param("page") Page<MedDetailedAccountPageDto> page,
// @Param(Constants.WRAPPER) QueryWrapper<MedDetailsSearchParam> queryWrapper, @Param("amb") Integer amb,
// @Param("completed") Integer completed, @Param("refunded") Integer refunded)
// /**
// * 门诊发药明细流水账
// *
// * @param page 分页
// * @param queryWrapper 查询条件
// * @param amb 发药类型：门诊
// * @param completed 发药状态：已发药
// * @param refunded 发药状态：已退药
// * @return 门诊发药明细流水账
// */
// Page<MedDetailedAccountPageDto> selectAmbMedicationDispenseDetailPage(
// @Param("page") Page<MedDetailedAccountPageDto> page,
// @Param(Constants.WRAPPER) QueryWrapper<MedDetailsSearchParam> queryWrapper, @Param("amb") Integer amb,
// @Param("completed") Integer completed, @Param("refunded") Integer refunded)
}

12
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/ReturnMedicineMapper.java
View File

@@ -24,8 +24,8 @@ public interface ReturnMedicineMapper {
* @param amb 就诊类型：门诊
* @return 退药患者分页列表
*/
Page<EncounterInfoPageDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoPageDto> queryWrapper, @Param("amb") Integer amb);
Page<EncounterInfoDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoDto> queryWrapper, @Param("amb") Integer amb);
/**
* 申请退药清单查询
@@ -46,14 +46,6 @@ public interface ReturnMedicineMapper {
@Param("refundStatus") Integer refundStatus, @Param("inRefund") Integer inRefund,
@Param("completed") Integer completed);
/**
* 患者基本信息查询
*
* @param encounterId 就诊ID
* @return 患者基本信息
*/
PrescriptionPatientInfoDto selectPrescriptionPatientInfo(@Param("encounterId") Long encounterId);
/**
* 库存信息查询
*

60
openhis-server-new/openhis-application/src/main/java/com/openhis/web/pharmacymanage/mapper/WesternMedicineDispenseMapper.java
View File

@@ -12,10 +12,9 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.openhis.administration.domain.Practitioner;
import com.openhis.web.pharmacymanage.dto.DispenseInventoryDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoPageDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionMedicineInfoDto;
import com.openhis.web.pharmacymanage.dto.PrescriptionPatientInfoDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoDto;
import com.openhis.web.pharmacymanage.dto.EncounterInfoSearchParam;
import com.openhis.web.pharmacymanage.dto.ItemDispenseOrderDto;
@Repository
public interface WesternMedicineDispenseMapper {
@@ -30,26 +29,16 @@ public interface WesternMedicineDispenseMapper {
* @param completed 发药状态:已发药
* @param preparation 发药状态:待配药
* @param prepared 发药状态:已配药
* @param amb 就诊类型：门诊
* @return 就诊病人列表
*/
Page<EncounterInfoPageDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoPageDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoPageDto> queryWrapper,
Page<EncounterInfoDto> selectEncounterInfoListPage(@Param("page") Page<EncounterInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<EncounterInfoSearchParam> queryWrapper,
@Param("statusEnum") Integer statusEnum, @Param("inProgress") Integer inProgress,
@Param("completed") Integer completed, @Param("preparation") Integer preparation,
@Param("prepared") Integer prepared, @Param("amb") Integer amb);
@Param("prepared") Integer prepared);
/**
* 患者基本信息查询
*
* @param encounterId 就诊号
* @return 患者基本信息
*/
PrescriptionPatientInfoDto selectPrescriptionPatientInfo(@Param("encounterId") Long encounterId,
@Param("hospitalId") Long hospitalId);
/**
* 处方单查询
* 发药单查询
*
* @param page 分页
* @param queryWrapper 查询条件
@@ -58,25 +47,14 @@ public interface WesternMedicineDispenseMapper {
* @param preparation 发药状态:待配药
* @param prepared 发药状态:已配药
* @param dispenseStatus 发药状态
* @return 处方单列表
* @return 发耗材单列表
*/
Page<PrescriptionMedicineInfoDto> selectPrescriptionMedicineInfoList(
@Param("page") Page<PrescriptionMedicineInfoDto> page,
@Param(Constants.WRAPPER) QueryWrapper<PrescriptionMedicineInfoDto> queryWrapper,
Page<ItemDispenseOrderDto> selectMedicineDispenseOrderPage(@Param("page") Page<ItemDispenseOrderDto> page,
@Param(Constants.WRAPPER) QueryWrapper<ItemDispenseOrderDto> queryWrapper,
@Param("inProgress") Integer inProgress, @Param("completed") Integer completed,
@Param("preparation") Integer preparation, @Param("prepared") Integer prepared,
@Param("dispenseStatus") Integer dispenseStatus);
/**
* 待发药和库存信息查询
*
* @param prescriptionNo 处方号
* @return 待发药信息
*/
List<DispenseInventoryDto> selectDispenseInventoryInfoByPrescriptionNo(
@Param("prescriptionNo") String prescriptionNo,
@Param("medMedicationDefinition") String medMedicationDefinition);
/**
* 获取配药人下拉选列表
*
@@ -84,22 +62,4 @@ public interface WesternMedicineDispenseMapper {
* @return 配药人下拉选列表
*/
List<Practitioner> getPreparerDoctorList(@Param("pharmacist") String pharmacist);
/**
* 处方单查询
*
* @param page 分页
* @param locationId 库房id
* @param startTime 开始时间
* @param endTime 结束时间
* @param completed 发药状态:已发药
* @param medicine 药品
* @param device 耗材
* @return 处方单列表
*/
Page<PrescriptionMedicineInfoDto> selectMonthlySettlementPatientInfoList(
@Param("page") Page<PrescriptionMedicineInfoDto> page,
@Param("locationId") Long locationId, @Param("startTime") String startTime,
@Param("endTime") String endTime, @Param("completed") Integer completed,
@Param("medicine") Integer medicine, @Param("device") Integer device);
}