jiangs/blood
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

血液品种合并，优化

Browse Source
This commit is contained in:
wuyy 2026-09-16 17:38:09 +08:00
parent f22d0b1382
commit 55c63173e2
6 changed files with 280 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
blood_bus_bloodbank/src/main/java/com/czblood/busBloodbank/service/impl/BloodOutServiceImpl.java
View File

@ -23,6 +23,7 @@ import com.czblood.busBloodbank.pojo.VO.BloodOutQueryVO;
import com.czblood.busBloodbank.service.BloodOutService;
import com.czblood.busBloodbank.utils.BloodOutUtil;
import com.czblood.busBloodbank.utils.MatchBloodUtil;
import com.czblood.busBloodbank.utils.MergeArrayUtil;
import com.czblood.common.core.domain.Result;
import com.czblood.common.core.domain.entity.SysUser;
import org.springframework.stereotype.Service;
@ -62,17 +63,16 @@ public class BloodOutServiceImpl implements BloodOutService {
ReportUtil reportUtil;
@Override
public Result queryOne(String applyNo,String moreSign) {
public Result queryOne(String applyNo, String moreSign) {
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(applyNo);
if(xkTransfuseApply == null) return new Result("-1","该申请单不存在，请检查！");
if (xkTransfuseApply == null) return new Result("-1", "该申请单不存在，请检查！");
String operationType = xkTransfuseApply.getOperation_type();
if(operationType.equals("Z")) return new Result("-1","该申请单为自体血申请单，无法在这操作！");
if(operationType.equals("S")) return new Result("-1","该申请单为输血治疗申请单，无法在这操作！");
if(!moreSign.equals("Y")){
if (operationType.equals("Z")) return new Result("-1", "该申请单为自体血申请单，无法在这操作！");
if (operationType.equals("S")) return new Result("-1", "该申请单为输血治疗申请单，无法在这操作！");
if (!moreSign.equals("Y")) {
Result result = checkBloodValid(xkTransfuseApply);
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
}
//返回数据
List<Map<String, Object>> mapList = bloodOutMapper.queryApplyInfo(applyNo);
@ -81,35 +81,36 @@ public class BloodOutServiceImpl implements BloodOutService {
BloodOutDTO bloodOutDTO = new BloodOutDTO();
bloodOutDTO.setApplyInfoList(mapList);
bloodOutDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
if(!moreSign.equals("Y")){
if (!moreSign.equals("Y")) {
bloodOutDTO.setStockInfoList(queryStockInfoList);
}
return new Result("0","操作成功",bloodOutDTO);
return new Result("0", "操作成功", bloodOutDTO);
}
@Override
public Result queryWaitInfo() {
List<Map<String, Object>> queryWaitInfoList = bloodOutMapper.queryWaitInfo();
return new Result("0","操作成功",queryWaitInfoList);
List<Map<String, Object>> finalList = MergeArrayUtil.mergeArray(queryWaitInfoList, "bill_no", "blood_breed");
return new Result("0", "操作成功", finalList);
}
@Override
public Result getBloodInfoOut(String bloodNo, String productNo,String applyNo) {
public Result getBloodInfoOut(String bloodNo, String productNo, String applyNo) {
Result result = matchBloodUtil.checkAboCheckAbnor(bloodNo, productNo);
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
XkBloodInfo xkBloodInfo = xkBloodInfoMapper.queryOne(bloodNo, productNo);
if(xkBloodInfo == null) return new Result("-1","该血液不存在，请检查！");
if (xkBloodInfo == null) return new Result("-1", "该血液不存在，请检查！");
Date validDate = xkBloodInfo.getValid_date();
Date currentTimeDate = bloodBankUtil.getCurrentTimeDate();
if(currentTimeDate.compareTo(validDate) > 0) return new Result("-1","该血液已过期！");
if (currentTimeDate.compareTo(validDate) > 0) return new Result("-1", "该血液已过期！");
String bloodSort = xkBloodInfo.getBlood_sort();
if(bloodSort.equals("Z")) return new Result("-1","该血液为自体血，不可在这操作！");
if (bloodSort.equals("Z")) return new Result("-1", "该血液为自体血，不可在这操作！");
String bloodStatus = xkBloodInfo.getBlood_status();
if(bloodStatus.equals("4")) return new Result("-1","该血液已发血！");
if(bloodStatus.equals("2")) return new Result("-1","该血液已作废！");
if (bloodStatus.equals("4")) return new Result("-1", "该血液已发血！");
if (bloodStatus.equals("2")) return new Result("-1", "该血液已作废！");
BloodOutInfoDTO bloodOutInfoDTO = new BloodOutInfoDTO();
result = checkMatcheBlood(xkBloodInfo, applyNo,bloodOutInfoDTO);
if(!result.getCode().equals("0")) return result;
result = checkMatcheBlood(xkBloodInfo, applyNo, bloodOutInfoDTO);
if (!result.getCode().equals("0")) return result;
// if(bloodStatus.equals("4") || bloodStatus.equals("2")) {
//// result = checkOnOut(bloodNo, productNo);
//// if(!result.getCode().equals("0")) return result;
@ -118,14 +119,14 @@ public class BloodOutServiceImpl implements BloodOutService {
//
// }
result = matchBloodUtil.checkBloodExistOut(bloodNo, productNo, applyNo);
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
List<XkInstorageDetail> xkInstorageDetailList = xkInstorageDetailMapper.queryByBloodNo(bloodNo, productNo);
if(!xkInstorageDetailList.isEmpty()){
if (!xkInstorageDetailList.isEmpty()) {
bloodOutInfoDTO.setPrice(xkInstorageDetailList.get(0).getPrice());
}
//返回数据
bloodOutInfoDTO.setXkBloodInfo(xkBloodInfo);
return new Result("0","操作成功",bloodOutInfoDTO);
return new Result("0", "操作成功", bloodOutInfoDTO);
}
@Override
@ -136,24 +137,24 @@ public class BloodOutServiceImpl implements BloodOutService {
String moreSign = bloodOutInfoVO.getMoreSign();
xkOutMain.setMore_sign(moreSign); //是否多次发血
List<XkOutDetail> xkOutDetailList = bloodOutInfoVO.getXkOutDetailList();
if(xkOutDetailList.isEmpty()) return new Result("-1","出库血液为空，请选择出库血液！");
if (xkOutDetailList.isEmpty()) return new Result("-1", "出库血液为空，请选择出库血液！");
boolean bModify = false;
if(!billNo.equals("")) bModify = true;
if (!billNo.equals("")) bModify = true;
String matchNo = "";
String checkNo = "";
//Date currentTimeDate = bloodBankUtil.getCurrentTimeDate();
XkMatchMain xkMatchMain = bloodOutMapper.queryXkMatchMain(applyNo);
if(xkMatchMain != null) {
if (xkMatchMain != null) {
matchNo = BloodBankUtil.isBank(xkMatchMain.getBill_no());
checkNo = BloodBankUtil.isBank(xkMatchMain.getCheck_no());
}
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(applyNo);
if(xkTransfuseApply == null) return new Result("-1","没有获取到申请单信息，请检查！");
if (xkTransfuseApply == null) return new Result("-1", "没有获取到申请单信息，请检查！");
String newBillNo = "";
if(!bModify){
if (!bModify) {
//新增
//如果上面没有取到，可能是不需要进行交叉配血的申请单，直接从血型复核当中取checkNo
if(checkNo.equals("")) checkNo = BloodBankUtil.isBank(bloodOutMapper.queryMaxCheckNo(applyNo));
if (checkNo.equals("")) checkNo = BloodBankUtil.isBank(bloodOutMapper.queryMaxCheckNo(applyNo));
xkOutMain.setMatch_no(matchNo);
xkOutMain.setCheck_no(checkNo);
//这一步应该放到审核里面去合理点
@ -170,23 +171,25 @@ public class BloodOutServiceImpl implements BloodOutService {
}
//只修改血型
XkTransfuseApply xkTransfuseApply1 = bloodOutInfoVO.getXkTransfuseApply();
XkTransfuseApply xkTransfuseApplyTemp = new XkTransfuseApply();
XkTransfuseApply xkTransfuseApplyTemp = new XkTransfuseApply();
xkTransfuseApplyTemp.setBill_no(xkTransfuseApply1.getBill_no());
xkTransfuseApplyTemp.setAbo_type(xkTransfuseApply1.getAbo_type());
xkTransfuseApplyTemp.setRh_type(xkTransfuseApply1.getRh_type());
bloodOutInfoVO.setXkTransfuseApply(xkTransfuseApplyTemp);
bloodOutUtil.saveBloodOutInfo(bloodOutInfoVO);
}else{
} else {
//修改
Result result = bloodBankUtil.checkOperatorModify("LCFX", billNo, bModify, bloodOutInfoVO.getUserId());
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
XkOutMain xkOutMainDB = xkOutMainMapper.queryOne(billNo);
String checkSign = xkOutMainDB.getCheck_sign();
if(checkSign.equals("Y")) return new Result("-1","该单据已经通过审核，不能作修改!");
if (checkSign.equals("Y")) return new Result("-1", "该单据已经通过审核，不能作修改!");
bloodOutUtil.updateBloodOutInfo(bloodOutInfoVO);
}
return new Result("0","保存成功！",newBillNo);
if(billNo.isEmpty()) billNo = newBillNo;
return new Result("0", "保存成功！", billNo);
}
@Override
@ -195,13 +198,13 @@ public class BloodOutServiceImpl implements BloodOutService {
String applyNo = bloodOutAuditVO.getApplyNo();
String userId = bloodOutAuditVO.getUserId();
Result result = bloodBankUtil.checkOperatorModify("LCFX", bloodOutAuditVO.getBillNo(), false, bloodOutAuditVO.getUserId());
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
XkOutMain xkOutMainDB = xkOutMainMapper.queryOne(billNo);
String checkSign = xkOutMainDB.getCheck_sign();
String beinhosId = xkOutMainDB.getBeinhos_id();
if(checkSign.equals("Y")) return new Result("-1","该单据已经通过审核，不能作修改!");
if (checkSign.equals("Y")) return new Result("-1", "该单据已经通过审核，不能作修改!");
Result result1 = checkSampleValid(applyNo);
if(!result1.getCode().equals("0")) return result1;
if (!result1.getCode().equals("0")) return result1;
List<XkBloodInfo> xkBloodInfoList = new ArrayList<>();
List<XkOutDetail> xkOutDetailList = xkOutDetailMapper.queryListByBillNo(billNo);
for (XkOutDetail xkOutDetail : xkOutDetailList) {
@ -209,15 +212,15 @@ public class BloodOutServiceImpl implements BloodOutService {
String productNo = xkOutDetail.getProduct_no();
XkBloodInfo xkBloodInfo = xkBloodInfoMapper.queryOne(bloodNo, productNo);
String bloodStatus = xkBloodInfo.getBlood_status();
switch (bloodStatus){
switch (bloodStatus) {
case "2":
return new Result("-1","血液:" + bloodNo + "已经报废,不能够出库");
return new Result("-1", "血液:" + bloodNo + "已经报废,不能够出库");
case "4":
return new Result("-1","血液:" + bloodNo + "已经发出血库,不能够出库");
return new Result("-1", "血液:" + bloodNo + "已经发出血库,不能够出库");
}
//修改血液状态
XkBloodInfo xkBloodInfoTemp = new XkBloodInfo();
XkBloodInfo xkBloodInfoTemp = new XkBloodInfo();
xkBloodInfoTemp.setBlood_status("4");
xkBloodInfoTemp.setBlood_no(bloodNo);
xkBloodInfoTemp.setProduct_no(productNo);
@ -239,7 +242,7 @@ public class BloodOutServiceImpl implements BloodOutService {
//交叉配血
XkMatchMain xkMatchMain = bloodOutMapper.queryXkMatchMain(applyNo);
XkMatchMain xkMatchMainTemp = null;
if(xkMatchMain != null){
if (xkMatchMain != null) {
xkMatchMainTemp = new XkMatchMain();
xkMatchMainTemp.setBill_no(xkMatchMain.getBill_no());
xkMatchMainTemp.setBill_status("B");
@ -248,7 +251,7 @@ public class BloodOutServiceImpl implements BloodOutService {
//血型复核
List<XkCheckBloodtype> xkCheckBloodtypeList = bloodOutMapper.queryCheckBloodtype(applyNo);
XkCheckBloodtype xkCheckBloodtypeTemp = null;
if(!xkCheckBloodtypeList.isEmpty()){
if (!xkCheckBloodtypeList.isEmpty()) {
xkCheckBloodtypeTemp = new XkCheckBloodtype();
xkCheckBloodtypeTemp.setBill_status("C");
xkCheckBloodtypeTemp.setBill_no(xkCheckBloodtypeList.get(0).getBill_no());
@ -259,7 +262,7 @@ public class BloodOutServiceImpl implements BloodOutService {
xkPatientInfoTemp.setTransfuse_history("Y");
xkPatientInfoTemp.setBeinhos_id(beinhosId);
bloodOutUtil.auditBloodOutInfo(xkBloodInfoList,xkTransfuseApplyTemp,xkOutMainTemp,xkCheckBloodtypeTemp,xkPatientInfoTemp,xkMatchMainTemp);
bloodOutUtil.auditBloodOutInfo(xkBloodInfoList, xkTransfuseApplyTemp, xkOutMainTemp, xkCheckBloodtypeTemp, xkPatientInfoTemp, xkMatchMainTemp);
//通知护士取血
notifyBloodOut(billNo);
@ -268,42 +271,42 @@ public class BloodOutServiceImpl implements BloodOutService {
BloodOutAuditRequest bloodOutAuditRequest = new BloodOutAuditRequest();
bloodOutAuditRequest.setBillNo(billNo);
Result result2 = BloodInterfaceUtil.invokeBloodInterface(bloodOutAuditRequest);
if(!result2.getCode().equals("0")) return result2;
return new Result("0","审核成功");
if (!result2.getCode().equals("0")) return result2;
return new Result("0", "审核成功");
}
@Override
public Result notifyMessage(String billNo) {
Result result = notifyBloodOut(billNo);
if(!result.getCode().equals("0")) return result;
return new Result("0","通知成功");
if (!result.getCode().equals("0")) return result;
return new Result("0", "通知成功");
}
@Override
public Result printReport(String billNo, String templateName) {
XkOutMain xkOutMain = xkOutMainMapper.queryOne(billNo);
if(xkOutMain == null) return new Result("-1","该单据不存在!");
if (xkOutMain == null) return new Result("-1", "该单据不存在!");
String checkSign = BloodBankUtil.isBank(xkOutMain.getCheck_sign());
if(!checkSign.equals("Y")) return new Result("-1","该单据没有审核，不能打印！");
if (!checkSign.equals("Y")) return new Result("-1", "该单据没有审核，不能打印！");
ReportParam reportParam = new ReportParam();
reportParam.setBillNo(billNo);
switch (templateName){
switch (templateName) {
case BloodPrintTypeConstants.BLOOD_OUT: //临床发血单
return reportUtil.printToPdf(BloodPrintTypeConstants.BLOOD_OUT, reportParam, true);
}
return new Result("-1","打印模板不存在！");
return new Result("-1", "打印模板不存在！");
}
@Override
public Result queryList(BloodOutQueryVO bloodOutQueryVO) {
List<Map<String,Object>> mapList = bloodOutMapper.queryList(bloodOutQueryVO);
return new Result("0","查询成功",mapList);
List<Map<String, Object>> mapList = bloodOutMapper.queryList(bloodOutQueryVO);
return new Result("0", "查询成功", mapList);
}
@Override
public Result queryInfo(String billNo) {
XkOutMain xkOutMain = xkOutMainMapper.queryOne(billNo);
if(xkOutMain == null) return new Result("-1","该单据不存在!");
if (xkOutMain == null) return new Result("-1", "该单据不存在!");
String applyNo = xkOutMain.getApply_no();
List<Map<String, Object>> applyInfoList = bloodOutMapper.queryApplyInfoOne(billNo);
BloodOutDTO bloodOutDTO = new BloodOutDTO();
@ -313,91 +316,92 @@ public class BloodOutServiceImpl implements BloodOutService {
bloodOutDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
List<Map<String, Object>> queryStockInfoList = bloodOutMapper.queryStockInfo(applyNo);
bloodOutDTO.setStockInfoList(queryStockInfoList);
return new Result("0","查询成功",bloodOutDTO);
return new Result("0", "查询成功", bloodOutDTO);
}
@Override
public Result queryMoreBloodOutList(BloodOutMoreQueryVO bloodOutMoreQueryVO) {
List<Map<String,Object>> mapList = bloodOutMapper.queryMoreBloodOutList(bloodOutMoreQueryVO);
return new Result("0","查询成功",mapList);
List<Map<String, Object>> mapList = bloodOutMapper.queryMoreBloodOutList(bloodOutMoreQueryVO);
return new Result("0", "查询成功", mapList);
}
public Result checkBloodValid(XkTransfuseApply xkTransfuseApply){
public Result checkBloodValid(XkTransfuseApply xkTransfuseApply) {
String billSort = xkTransfuseApply.getBill_sort();
String billStatus = xkTransfuseApply.getBill_stasus();
String billNo = xkTransfuseApply.getBill_no();
switch (billSort){
switch (billSort) {
case "N":
return new Result("-1","该申请单尚未审核，不能进行发血！");
return new Result("-1", "该申请单尚未审核，不能进行发血！");
case "A":
switch (billStatus){
switch (billStatus) {
case "B":
return new Result("-1","该申请单尚未复核血型，请先复核血型！");
return new Result("-1", "该申请单尚未复核血型，请先复核血型！");
case "N":
return new Result("-1","该申请单未通过审核，不能进行发血操作！");
return new Result("-1", "该申请单未通过审核，不能进行发血操作！");
case "D":
return new Result("-1","该申请单已经发血!");
return new Result("-1", "该申请单已经发血!");
case "Z":
return new Result("-1","该申请单已经作废!");
return new Result("-1", "该申请单已经作废!");
}
break;
case "C":
switch (billStatus){
switch (billStatus) {
case "Z":
return new Result("-1","该申请单已经作废!");
return new Result("-1", "该申请单已经作废!");
case "N":
return new Result("-1","该申请单未通过审核，不能进行发血操作！");
return new Result("-1", "该申请单未通过审核，不能进行发血操作！");
case "D":
return new Result("-1","该申请单已经发血!");
return new Result("-1", "该申请单已经发血!");
}
break;
case "B":
int i = bloodOutMapper.queryApplyBloodTypeCount(billNo);
if(i > 0) {
if(billStatus.equals("F") || billStatus.equals("SF") || billStatus.equals("B")){
return new Result("-1","该申请单有非红细胞类的血液尚未配血，不能发血！");
if (i > 0) {
if (billStatus.equals("F") || billStatus.equals("SF") || billStatus.equals("B")) {
return new Result("-1", "该申请单有非红细胞类的血液尚未配血，不能发血！");
}
}
switch (billStatus){
switch (billStatus) {
case "F":
return new Result("-1","该申请单尚未配血,请先配血！");
return new Result("-1", "该申请单尚未配血,请先配血！");
case "N":
return new Result("-1","该申请单未通过审核，不能进行发血操作！");
return new Result("-1", "该申请单未通过审核，不能进行发血操作！");
case "SF":
return new Result("-1","该申请单尚未配血,请先配血！");
return new Result("-1", "该申请单尚未配血,请先配血！");
case "B":
return new Result("-1","该申请单尚未复核血型，请先复核血型！");
return new Result("-1", "该申请单尚未复核血型，请先复核血型！");
case "D":
//这里还有个函数,Pb程序注释掉了！
break;
case "Z":
return new Result("-1","该申请单已经作废!");
return new Result("-1", "该申请单已经作废!");
case "BD":
return new Result("-1","该申请单为补单，若要按正常流程，请先复核血型、配血后再发血，否则按紧急流程！");
return new Result("-1", "该申请单为补单，若要按正常流程，请先复核血型、配血后再发血，否则按紧急流程！");
case "W":
return new Result("-1","该申请单已经补录，若要追加发血，请先复核血型、配血后再发血！");
return new Result("-1", "该申请单已经补录，若要追加发血，请先复核血型、配血后再发血！");
}
}
return new Result("0","操作成功");
return new Result("0", "操作成功");
}
/**
* 判断血液是否已经出库
*
* @return
*/
public Result checkOnOut(String bloodNo,String productNo){
public Result checkOnOut(String bloodNo, String productNo) {
List<XkBackoutDetail> xkBackoutDetailList = bloodOutMapper.queryBloodBackOutCount(bloodNo, productNo);
String msg = "";
if(xkBackoutDetailList.size()>0){
if (xkBackoutDetailList.size() > 0) {
String bloodNo1 = xkBackoutDetailList.get(0).getBlood_no();
String billNo = xkBackoutDetailList.get(0).getBill_no();
msg = "血液【" + bloodNo1 + "】，已经退回血站!~r~n退血单号为【" + billNo + "】，请检查!";
}
List<Map<String,Object>> bloodOutList = bloodOutMapper.queryBloodOutInfoCount(bloodNo, productNo);
if(!bloodOutList.isEmpty()){
List<Map<String, Object>> bloodOutList = bloodOutMapper.queryBloodOutInfoCount(bloodNo, productNo);
if (!bloodOutList.isEmpty()) {
msg = "血液【" + bloodNo + "】，已经发给【" + BloodBankUtil.isBank(bloodOutList.get(0).get("dept_name")) + "】的病患【"
+ BloodBankUtil.isBank(bloodOutList.get(0).get("patient_name")) + "】!~r~n血液出库单号为【"
+ BloodBankUtil.isBank(bloodOutList.get(0).get("bill_no"))
@ -405,62 +409,64 @@ public class BloodOutServiceImpl implements BloodOutService {
+ "】，请检查!";
}
List<XkDiscardMain> xkDiscardMainList = bloodOutMapper.queryDiscardCount(bloodNo, productNo);
if(!xkDiscardMainList.isEmpty()){
if (!xkDiscardMainList.isEmpty()) {
msg = "血液【" + bloodNo + "】，已经报废!~r~n报废单号为【" + xkDiscardMainList.get(0).getBill_no() + "】，请检查!";
}
if(!msg.isEmpty()){
return new Result("-1",msg);
}else{
return new Result("0","操作成功");
if (!msg.isEmpty()) {
return new Result("-1", msg);
} else {
return new Result("0", "操作成功");
}
}
public Result checkMatcheBlood(XkBloodInfo xkBloodInfo,String applyNo,BloodOutInfoDTO bloodOutInfoDTO){
public Result checkMatcheBlood(XkBloodInfo xkBloodInfo, String applyNo, BloodOutInfoDTO bloodOutInfoDTO) {
String bloodBreed = xkBloodInfo.getBlood_breed();
XkBloodBreed xkBloodBreed = xkBloodBreedMapper.queryOne(bloodBreed);
String isMatch = BloodBankUtil.isBank(xkBloodBreed.getIs_match());
if(isMatch.equals("Y")){
if (isMatch.equals("Y")) {
//所选择的血液需要进行配血
List<Map<String,Object>> matchBloodList = bloodOutMapper.queryMatchBloodInfo(xkBloodInfo.getBlood_no(), xkBloodInfo.getProduct_no(), applyNo);
if(matchBloodList.isEmpty()) return new Result("-1","该血液尚未配血，或者所配的血液不是给该病患，请检查！");
List<Map<String, Object>> matchBloodList = bloodOutMapper.queryMatchBloodInfo(xkBloodInfo.getBlood_no(), xkBloodInfo.getProduct_no(), applyNo);
if (matchBloodList.isEmpty()) return new Result("-1", "该血液尚未配血，或者所配的血液不是给该病患，请检查！");
String canSend = BloodBankUtil.isBank(matchBloodList.get(0).get("can_send"));
String result = BloodBankUtil.isBank(matchBloodList.get(0).get("result"));
if(canSend.equals("") || canSend.equals("N")) return new Result("-1","该血液的配血结果为:"+result+"，不能发血！");
if (canSend.equals("") || canSend.equals("N"))
return new Result("-1", "该血液的配血结果为:" + result + "，不能发血！");
bloodOutInfoDTO.setCheck_method(BloodBankUtil.isBank(matchBloodList.get(0).get("check_method")));
bloodOutInfoDTO.setMatch_method(BloodBankUtil.isBank(matchBloodList.get(0).get("match_method")));
bloodOutInfoDTO.setResult(result);
}else{
} else {
//所选择的血液不需要进行配血
bloodOutInfoDTO.setCheck_method("");
bloodOutInfoDTO.setMatch_method("");
bloodOutInfoDTO.setResult("");
}
return new Result("0","检验通过!");
return new Result("0", "检验通过!");
}
public Result checkSampleValid(String applyNo){
public Result checkSampleValid(String applyNo) {
Date maxPickDate = bloodOutMapper.querySampleMaxPickDate(applyNo);
//标本采集时间与发血的时间间隔,当标本采集时间与发血时间的间隔大于本参数时进行相应的操作,参数值为正数，天数
String overstepDay = bloodBankUtil.getParameterValue("overstep_day");
Date pickDate = DateUtil.offsetDay(maxPickDate, Integer.parseInt(overstepDay));
if(pickDate != null){
if (pickDate != null) {
Date currentTimeDate = bloodBankUtil.getCurrentTimeDate();
if(pickDate.compareTo(currentTimeDate) <= 0){
return new Result("-1","标本时间已经超过了设定的有效天数，不可以继续操作！");
if (pickDate.compareTo(currentTimeDate) <= 0) {
return new Result("-1", "标本时间已经超过了设定的有效天数，不可以继续操作！");
}
}
return new Result("0","操作成功");
return new Result("0", "操作成功");
}
/**
* 通知护士取血
*
* @param billNo
*/
public Result notifyBloodOut(String billNo){
public Result notifyBloodOut(String billNo) {
XkOutMain xkOutMain = xkOutMainMapper.queryOne(billNo);
if(xkOutMain == null) return new Result("-1","该出库单不存在！");
if (xkOutMain == null) return new Result("-1", "该出库单不存在！");
String checkSign = BloodBankUtil.isBank(xkOutMain.getCheck_sign());
if(!checkSign.equals("Y")) return new Result("-1","该单据没有审核，不能通知护士取血！");
if (!checkSign.equals("Y")) return new Result("-1", "该单据没有审核，不能通知护士取血！");
Date currentTimeDate = bloodBankUtil.getCurrentTimeDate();
@ -492,7 +498,7 @@ public class BloodOutServiceImpl implements BloodOutService {
xkMsgDetailTemp.setMsg_Body(msgBody);
xkMsgDetailTemp.setAccept_Dept(xkOutMain.getDept_id());
xkMsgDetailTemp.setSend_Dept("输血科");
int msgId = bloodOutUtil.updateNotifyTime(xkOutMainTemp,xkMsgMainTemp,xkMsgDetailTemp);
int msgId = bloodOutUtil.updateNotifyTime(xkOutMainTemp, xkMsgMainTemp, xkMsgDetailTemp);
//发送消息
//取血通知,传入的人，是取血人 ，但是我们需要通知这个取血人所对应的整个科室，比较合理
SysUser sysUserQuery = new SysUser();
@ -503,8 +509,8 @@ public class BloodOutServiceImpl implements BloodOutService {
WsMessage msg = new WsMessage();
ParamExtra paramExtra = new ParamExtra();
paramExtra.setMsgId(msgId);
WebSocketServer.sendMsg(userName,msg);
WebSocketServer.sendMsg(userName, msg);
}
return new Result("0","操作成功");
return new Result("0", "操作成功");
}
}

58
blood_bus_bloodbank/src/main/java/com/czblood/busBloodbank/service/impl/CheckBloodTypeServiceImpl.java
View File

@ -13,11 +13,14 @@ import com.czblood.busBloodbank.pojo.VO.HistoryQueryVO;
import com.czblood.busBloodbank.pojo.VO.XkCheckBloodtypeVO;
import com.czblood.busBloodbank.service.CheckBloodTypeService;
import com.czblood.busBloodbank.utils.CheckBloodTypeUtil;
import com.czblood.busBloodbank.utils.MergeArrayUtil;
import com.czblood.common.core.domain.Result;
import com.czblood.common.core.page.TableDataInfo;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@ -44,26 +47,29 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
int xxfh = 0;
//只复核标本接收之后的申请单
String bbjszhxxfh = bloodBankUtil.getParameterValue("BBJSZHXXFH");
if(bbjszhxxfh.equals("Y")) xxfh = 1;
if (bbjszhxxfh.equals("Y")) xxfh = 1;
List<Map<String, Object>> mapList = checkBloodTypeMapper.queryWaitInfo(xxfh);
return new Result("0","获取数据成功！",mapList);
//根据单据编号合并血液品种
List<Map<String, Object>> finalList = MergeArrayUtil.mergeArray(mapList, "bill_no", "blood_breed");
return new Result("0", "获取数据成功！", finalList);
}
@Override
public Result queryOne(String billNo) {
//校验单据是否有效
Result result = checkBloodTypeUtil.checkBillNoIsValid(billNo);
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
List<Map<String, Object>> mapList = checkBloodTypeMapper.queryOne(billNo);
List<XkTransfuseApplyBloodbreed> xkTransfuseApplyBloodbreedList = xkTransfuseApplyBloodbreedMapper.queryOne(billNo);
CheckBloodTypeDTO checkBloodTypeDTO = new CheckBloodTypeDTO();
checkBloodTypeDTO.setPatientInfoList(mapList);
checkBloodTypeDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
return new Result("0","查询数据成功！",checkBloodTypeDTO);
return new Result("0", "查询数据成功！", checkBloodTypeDTO);
}
/**
* 保存数据
*
* @param xkCheckBloodtypeVO
* @return
*/
@ -73,20 +79,20 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
String flag = xkCheckBloodtypeVO.getFlag();
String applyNo = xkCheckBloodtype.getApply_no();
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(applyNo);
if(xkTransfuseApply == null) return new Result("-1","若不是紧急情况，请先选择输血申请单！");
if (xkTransfuseApply == null) return new Result("-1", "若不是紧急情况，请先选择输血申请单！");
XkCheckBloodtype xkCheckBloodtypeQuery = new XkCheckBloodtype();
xkCheckBloodtypeQuery.setApply_no(applyNo);
List<XkCheckBloodtype> xkCheckBloodtypeList = xkCheckBloodtypeMapper.queryList(xkCheckBloodtypeQuery);
if(!xkCheckBloodtypeList.isEmpty()){
if (!xkCheckBloodtypeList.isEmpty()) {
String billStatus = xkCheckBloodtypeList.get(0).getBill_status();
if(billStatus.equals("B")) return new Result("0","该申请单的血型复核单已配血,不可修改!");
if(billStatus.equals("C")) return new Result("0","该申请单的血型复核单已发血，不可修改！");
if (billStatus.equals("B")) return new Result("0", "该申请单的血型复核单已配血,不可修改!");
if (billStatus.equals("C")) return new Result("0", "该申请单的血型复核单已发血，不可修改！");
}
String billSort = xkTransfuseApply.getBill_sort();
//是否需要配血
if(billSort.equals("B")){
if (billSort.equals("B")) {
xkCheckBloodtype.setNeed_match("Y");
}else{
} else {
xkCheckBloodtype.setNeed_match("N");
}
String newBillNo = bloodBankUtil.produceBillNo("XXFH");
@ -98,7 +104,7 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
//当血型复核的结果和申请单之前的结果不一致的时候，需要更新申请单的血型，以及病人基本信息的血型
XkPatientInfo xkPatientInfoTemp = null;
if(flag.equals("0")){
if (flag.equals("0")) {
xkTransfuseApplyTemp.setAbo_type(xkCheckBloodtype.getAffirm_abo());
xkTransfuseApplyTemp.setRh_type(xkCheckBloodtype.getCheck_rh());
xkTransfuseApplyTemp.setBloodcheck_abnor("N");
@ -111,24 +117,24 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
}
checkBloodTypeUtil.saveData(xkCheckBloodtype,xkTransfuseApplyTemp,xkPatientInfoTemp);
checkBloodTypeUtil.saveData(xkCheckBloodtype, xkTransfuseApplyTemp, xkPatientInfoTemp);
//调用外部接口
CheckBloodTypeRequest checkBloodTypeRequest = new CheckBloodTypeRequest();
Result result = BloodInterfaceUtil.invokeBloodInterface(checkBloodTypeRequest);
if(!result.getCode().equals("0")) return result;
return new Result("0","保存数据成功！",newBillNo);
if (!result.getCode().equals("0")) return result;
return new Result("0", "保存数据成功！", newBillNo);
}
@Override
public Result delCheckBloodTypeInfo(String billNo) {
XkCheckBloodtype xkCheckBloodtype = xkCheckBloodtypeMapper.queryOne(billNo);
if(xkCheckBloodtype == null) return new Result("-1","该血型复核单不存在！");
if (xkCheckBloodtype == null) return new Result("-1", "该血型复核单不存在！");
String billStatus = xkCheckBloodtype.getBill_status();
String applyNo = xkCheckBloodtype.getApply_no();
if(billStatus.equals("B")) return new Result("-1","该单据对应的申请单已经配血，不能删除！");
if(billStatus.equals("C")) return new Result("-1","该单据对应的申请单已经发血，不能删除！");
if (billStatus.equals("B")) return new Result("-1", "该单据对应的申请单已经配血，不能删除！");
if (billStatus.equals("C")) return new Result("-1", "该单据对应的申请单已经发血，不能删除！");
int i = checkBloodTypeMapper.checkMatchedBloodNotOut(billNo);
if(i > 0 ) return new Result("-1","该血型复核单对应的发血单已经登记发血，不能删除！");
if (i > 0) return new Result("-1", "该血型复核单对应的发血单已经登记发血，不能删除！");
//修改状态
XkTransfuseApply xkTransfuseApplyTemp = new XkTransfuseApply();
@ -140,32 +146,32 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
xkChargeMain.setSend_flag("N");
List<XkChargeMain> xkChargeMainList = xkChargeMainMapper.queryList(xkChargeMain);
String chargeBillNo = "";
if(!xkChargeMainList.isEmpty()){
if (!xkChargeMainList.isEmpty()) {
chargeBillNo = xkChargeMainList.get(0).getBill_no();
}
checkBloodTypeUtil.deleteData(xkTransfuseApplyTemp,chargeBillNo,billNo);
checkBloodTypeUtil.deleteData(xkTransfuseApplyTemp, chargeBillNo, billNo);
//调用外部接口
CancelCheckBloodTypeRequest cancelCheckBloodTypeRequest = new CancelCheckBloodTypeRequest();
cancelCheckBloodTypeRequest.setBillNo(billNo);
Result result = BloodInterfaceUtil.invokeBloodInterface(cancelCheckBloodTypeRequest);
if(!result.getCode().equals("0")) return result;
return new Result("0","删除成功！");
if (!result.getCode().equals("0")) return result;
return new Result("0", "删除成功！");
}
@Override
public List<Map<String,Object>> queryHistoryInfo(HistoryQueryVO historyQueryVO) {
public List<Map<String, Object>> queryHistoryInfo(HistoryQueryVO historyQueryVO) {
return checkBloodTypeMapper.queryHistoryInfo(historyQueryVO);
}
@Override
public Result queryList(CheckBloodTypeListQueryVO checkBloodTypeListQueryVO) {
List<XkCheckBloodtype> xkCheckBloodtypeList = checkBloodTypeMapper.queryList(checkBloodTypeListQueryVO);
return new Result("0","查询成功！",xkCheckBloodtypeList);
return new Result("0", "查询成功！", xkCheckBloodtypeList);
}
@Override
public Result queryOneInfo(String billNo,String applyNo) {
public Result queryOneInfo(String billNo, String applyNo) {
XkCheckBloodtype xkCheckBloodtype = xkCheckBloodtypeMapper.queryOne(billNo);
List<Map<String, Object>> mainList = checkBloodTypeMapper.queryOne(applyNo);
List<XkTransfuseApplyBloodbreed> xkTransfuseApplyBloodbreedList = xkTransfuseApplyBloodbreedMapper.queryOne(applyNo);
@ -173,6 +179,6 @@ public class CheckBloodTypeServiceImpl implements CheckBloodTypeService {
checkBloodTypeDTO.setPatientInfoList(mainList);
checkBloodTypeDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
checkBloodTypeDTO.setXkCheckBloodtype(xkCheckBloodtype);
return new Result("0","查询成功！",checkBloodTypeDTO);
return new Result("0", "查询成功！", checkBloodTypeDTO);
}
}

166
blood_bus_bloodbank/src/main/java/com/czblood/busBloodbank/service/impl/MatchBloodServiceImpl.java
View File

@ -16,6 +16,7 @@ import com.czblood.busBloodbank.pojo.VO.MatchBloodStockQueryVO;
import com.czblood.busBloodbank.pojo.VO.MatchBloodVO;
import com.czblood.busBloodbank.service.MatchBloodService;
import com.czblood.busBloodbank.utils.MatchBloodUtil;
import com.czblood.busBloodbank.utils.MergeArrayUtil;
import com.czblood.common.core.domain.Result;
import org.springframework.stereotype.Service;
@ -50,85 +51,88 @@ public class MatchBloodServiceImpl implements MatchBloodService {
@Override
public Result queryWaitInfo() {
List<Map<String, Object>> mapList = matchBloodMapper.queryWaitInfo();
return new Result("0","获取数据成功！",mapList);
List<Map<String, Object>> finalList = MergeArrayUtil.mergeArray(mapList, "bill_no", "blood_breed");
return new Result("0", "获取数据成功！", finalList);
}
@Override
public Result queryOne(String billNo) {
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(billNo);
if(xkTransfuseApply == null) return new Result("-1","没有获取到申请单数据！");
if(!xkTransfuseApply.getBill_sort().equals("B")) return new Result("-1","该申请单无需配血！");
if (xkTransfuseApply == null) return new Result("-1", "没有获取到申请单数据！");
if (!xkTransfuseApply.getBill_sort().equals("B")) return new Result("-1", "该申请单无需配血！");
String billStatus = xkTransfuseApply.getBill_stasus();
switch (billStatus){
switch (billStatus) {
case "C":
return new Result("-1","该申请单已配血！");
return new Result("-1", "该申请单已配血！");
case "Z":
return new Result("-1","该申请单已经作废！");
return new Result("-1", "该申请单已经作废！");
case "S":
return new Result("-1","该申请单已经追加配血，可直接在临床发血中发血！");
return new Result("-1", "该申请单已经追加配血，可直接在临床发血中发血！");
case "D":
if(matchBloodMapper.checkMatchBloodNotOut(billNo) > 0) return new Result("-1","检测到该申请单尚有配好的血液未出库,请先出库再进行配血！");
if (matchBloodMapper.checkMatchBloodNotOut(billNo) > 0)
return new Result("-1", "检测到该申请单尚有配好的血液未出库,请先出库再进行配血！");
case "BD":
return new Result("-1","该申请单为补单,若要配血，请先复核血型！");
return new Result("-1", "该申请单为补单,若要配血，请先复核血型！");
case "B":
if(matchBloodMapper.queryCheckBloodTypeCount(billNo) <= 0) return new Result("-1","该申请单尚未复核血型，请先复核血型！");
if (matchBloodMapper.queryCheckBloodTypeCount(billNo) <= 0)
return new Result("-1", "该申请单尚未复核血型，请先复核血型！");
case "A":
return new Result("-1","该申请单尚未审核，请先审核！");
return new Result("-1", "该申请单尚未审核，请先审核！");
}
String msg = "";
Result result = matchBloodUtil.checkSampleValid(billNo);
if(result.getCode().equals("-1")) return result;
if(result.getCode().equals("1")) msg = result.getMsg();
if (result.getCode().equals("-1")) return result;
if (result.getCode().equals("1")) msg = result.getMsg();
List<Map<String, Object>> matchMainInfoList = matchBloodMapper.queryMatchMainInfo(billNo);
if(matchMainInfoList.size() <= 0) return new Result("-1","没有找到该申请单信息，请检查！");
if (matchMainInfoList.size() <= 0) return new Result("-1", "没有找到该申请单信息，请检查！");
MatchBloodDTO matchBloodDTO = new MatchBloodDTO();
matchBloodDTO.setMatchMainInfoList(matchMainInfoList);
List<XkTransfuseApplyBloodbreed> xkTransfuseApplyBloodbreedList = xkTransfuseApplyBloodbreedMapper.queryOne(billNo);
matchBloodDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
if(msg.equals("")){
return new Result("0","获取数据成功！",matchBloodDTO);
}else{
return new Result("1",msg,matchBloodDTO);
if (msg.equals("")) {
return new Result("0", "获取数据成功！", matchBloodDTO);
} else {
return new Result("1", msg, matchBloodDTO);
}
}
@Override
public Result getBloodInfoMatch(String bloodNo, String productNo) {
if(bloodNo.length() < 8) return new Result("1","血液流水号长度不能低于8位！");
if (bloodNo.length() < 8) return new Result("1", "血液流水号长度不能低于8位！");
XkBloodInfo xkBloodInfo = bloodBankUtil.queryBloodInfoOne(bloodNo, productNo);
if(xkBloodInfo == null) return new Result("-1","该血液信息不存在！");
Result result = matchBloodUtil.checkBloodExistOut("",bloodNo,productNo);
if(!result.getCode().equals("0")) return result;
if (xkBloodInfo == null) return new Result("-1", "该血液信息不存在！");
Result result = matchBloodUtil.checkBloodExistOut("", bloodNo, productNo);
if (!result.getCode().equals("0")) return result;
Date validDate = xkBloodInfo.getValid_date();
Date currentTimeDate = bloodBankUtil.getCurrentTimeDate();
if(currentTimeDate.compareTo(validDate) > 0) return new Result("-1","该血液已过期！");
if (currentTimeDate.compareTo(validDate) > 0) return new Result("-1", "该血液已过期！");
String bloodSort = xkBloodInfo.getBlood_sort();
if(bloodSort.equals("Z")) return new Result("-1","该血液为自体血，不可在这操作！");
if (bloodSort.equals("Z")) return new Result("-1", "该血液为自体血，不可在这操作！");
Result result1 = matchBloodUtil.checkAboCheckAbnor(bloodNo, productNo);
if(!result1.getCode().equals("0")) return result1;
if (!result1.getCode().equals("0")) return result1;
Result result2 = matchBloodUtil.checkBloodNeedMatch(bloodNo, productNo);
if(!result2.getCode().equals("0")) return result2;
if (!result2.getCode().equals("0")) return result2;
String bloodStatus = xkBloodInfo.getBlood_status();
switch (bloodStatus){
switch (bloodStatus) {
case "2":
return new Result("-1","该血液已经报废！");
return new Result("-1", "该血液已经报废！");
case "3":
return new Result("-1","该血液正在制备或者配血！");
return new Result("-1", "该血液正在制备或者配血！");
case "4":
return new Result("-1","该血液已经出库！");
return new Result("-1", "该血液已经出库！");
}
BloodMatchDTO bloodMatchDTO = new BloodMatchDTO();
bloodMatchDTO.setXkBloodInfo(xkBloodInfo);
bloodMatchDTO.setXkBloodBreed(xkBloodBreedMapper.queryOne(xkBloodInfo.getBlood_breed()));
return new Result("0","获取数据成功！",bloodMatchDTO);
return new Result("0", "获取数据成功！", bloodMatchDTO);
}
@Override
public Result cancelBloodInfoMatch(String bloodNo, String productNo) {
int i = matchBloodMapper.queryOutCountThree(bloodNo, productNo);
if(i > 0) return new Result("-1","该血液已经登记出库信息，请检查！");
return new Result("0","取消配配血成功！");
if (i > 0) return new Result("-1", "该血液已经登记出库信息，请检查！");
return new Result("0", "取消配配血成功！");
}
@Override
@ -136,62 +140,62 @@ public class MatchBloodServiceImpl implements MatchBloodService {
XkMatchMain xkMatchMain = matchBloodVO.getXkMatchMain();
String billNo = BloodBankUtil.isBank(xkMatchMain.getBill_no());
boolean bModify = false;
if(!billNo.equals("")) bModify = true;
if (!billNo.equals("")) bModify = true;
Result result = bloodBankUtil.checkOperatorModify("JCPX", billNo, bModify, matchBloodVO.getUserId());
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
String billStatus = xkMatchMain.getBill_status();
String applyNo = xkMatchMain.getApply_no();
if(bModify && billStatus.equals("B")) return new Result("-1","该配血单已发血,不可修改!");
if (bModify && billStatus.equals("B")) return new Result("-1", "该配血单已发血,不可修改!");
List<XkMatchDetail> xkMatchDetailList = matchBloodVO.getXkMatchDetailList();
if(xkMatchDetailList.isEmpty()) return new Result("-1","配血血液不可为空，请先添加配血血液！");
if (xkMatchDetailList.isEmpty()) return new Result("-1", "配血血液不可为空，请先添加配血血液！");
String newBillNo = "";
if(!bModify){
if (!bModify) {
//新增数据
newBillNo = bloodBankUtil.produceBillNo("PXD");
xkMatchMain.setBill_no(newBillNo);
xkMatchMain.setBill_status("A");
xkMatchMain.setMatch_sign("N");
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(applyNo);
if(xkTransfuseApply == null) return new Result("-1","该申请单不存在！");
if (xkTransfuseApply == null) return new Result("-1", "该申请单不存在！");
String billStasus = xkTransfuseApply.getBill_stasus();
String checkNo = "";
String billStatusTemp = "";
XkCheckBloodtype xkCheckBloodtypeTemp = null;
if(billStasus.equals("F") || billStasus.equals("SF")){
XkCheckBloodtype xkCheckBloodtypeQuery = new XkCheckBloodtype();
if (billStasus.equals("F") || billStasus.equals("SF")) {
XkCheckBloodtype xkCheckBloodtypeQuery = new XkCheckBloodtype();
xkCheckBloodtypeQuery.setApply_no(applyNo);
xkCheckBloodtypeQuery.setBill_status("A");
List<XkCheckBloodtype> xkCheckBloodtypeList = xkCheckBloodtypeMapper.queryList(xkCheckBloodtypeQuery);
if(!xkCheckBloodtypeList.isEmpty()){
if (!xkCheckBloodtypeList.isEmpty()) {
checkNo = xkCheckBloodtypeList.get(0).getBill_no();
xkCheckBloodtypeTemp = new XkCheckBloodtype();
xkCheckBloodtypeTemp.setBill_no(checkNo);
xkCheckBloodtypeTemp.setBill_status("B");
}
}else{
XkCheckBloodtype xkCheckBloodtypeQuery = new XkCheckBloodtype();
} else {
XkCheckBloodtype xkCheckBloodtypeQuery = new XkCheckBloodtype();
xkCheckBloodtypeQuery.setApply_no(applyNo);
xkCheckBloodtypeQuery.setBill_status("C");
List<XkCheckBloodtype> xkCheckBloodtypeList = xkCheckBloodtypeMapper.queryList(xkCheckBloodtypeQuery);
if(xkCheckBloodtypeList.isEmpty()){
if (xkCheckBloodtypeList.isEmpty()) {
billStasus = "F";
}
}
XkCheckBloodtype xkCheckBloodtypeQuery1 = new XkCheckBloodtype();
XkCheckBloodtype xkCheckBloodtypeQuery1 = new XkCheckBloodtype();
xkCheckBloodtypeQuery1.setApply_no(applyNo);
List<XkCheckBloodtype> xkCheckBloodtypeList = xkCheckBloodtypeMapper.queryList(xkCheckBloodtypeQuery1);
if(xkCheckBloodtypeList.isEmpty()){
if (xkCheckBloodtypeList.isEmpty()) {
billStasus = "F";
}
xkMatchMain.setCheck_no(checkNo);
xkMatchMain.setLast_modified(bloodBankUtil.getCurrentTimeDate());
if(billStasus.equals("F")){
if (billStasus.equals("F")) {
billStatusTemp = "C";
}else if(billStasus.equals("SF") || billStasus.equals("D")){
} else if (billStasus.equals("SF") || billStasus.equals("D")) {
billStatusTemp = "S";
}
XkTransfuseApply xkTransfuseApplyTemp = new XkTransfuseApply();
XkTransfuseApply xkTransfuseApplyTemp = new XkTransfuseApply();
xkTransfuseApplyTemp.setBill_no(applyNo);
xkTransfuseApplyTemp.setBill_stasus(billStatusTemp);
xkTransfuseApplyTemp.setNotify_sign("Y");
@ -200,33 +204,33 @@ public class MatchBloodServiceImpl implements MatchBloodService {
xkMatchDetail.setBill_no(newBillNo);
}
matchBloodUtil.saveData(matchBloodVO,xkCheckBloodtypeTemp,xkTransfuseApplyTemp);
}else{
matchBloodUtil.saveData(matchBloodVO, xkCheckBloodtypeTemp, xkTransfuseApplyTemp);
} else {
//修改数据
matchBloodUtil.updateData(matchBloodVO);
}
//调用外部接口
if(billNo.equals("")) billNo = newBillNo;
if (billNo.equals("")) billNo = newBillNo;
MatchBloodTypeRequest matchBloodTypeRequest = new MatchBloodTypeRequest();
matchBloodTypeRequest.setBillNo(billNo);
Result result1 = BloodInterfaceUtil.invokeBloodInterface(matchBloodTypeRequest);
if(!result1.getCode().equals("0")) return result1;
if (!result1.getCode().equals("0")) return result1;
return new Result("0","保存成功！");
return new Result("0", "保存成功！", billNo);
}
@Override
public Result deleteBloodInfoMatch(String billNo) {
XkMatchMain xkMatchMain = xkMatchMainMapper.queryOne(billNo);
if(xkMatchMain == null) return new Result("-1","该配血单不存在！");
if (xkMatchMain == null) return new Result("-1", "该配血单不存在！");
String billStatus = BloodBankUtil.isBank(xkMatchMain.getBill_status());
if(billStatus.equals("B")) return new Result("-1","该配血单已发血,不可作废！");
if(billStatus.equals("ZF")) return new Result("-1","该配血单已作废,不可作废！");
if (billStatus.equals("B")) return new Result("-1", "该配血单已发血,不可作废！");
if (billStatus.equals("ZF")) return new Result("-1", "该配血单已作废,不可作废！");
String chargeMainBillNo = BloodBankUtil.isBank(matchBloodMapper.queryChargeMainBillNo(billNo));
String checkNo = BloodBankUtil.isBank(xkMatchMain.getCheck_no());
XkCheckBloodtype xkCheckBloodtypeTemp = null;
if(!checkNo.equals("")){
if (!checkNo.equals("")) {
//修改血型复核数据
xkCheckBloodtypeTemp = new XkCheckBloodtype();
xkCheckBloodtypeTemp.setBill_no(checkNo);
@ -234,10 +238,10 @@ public class MatchBloodServiceImpl implements MatchBloodService {
}
String applyNo = xkMatchMain.getApply_no();
XkTransfuseApply xkTransfuseApply = xkTransfuseApplyMapper.queryOne(applyNo);
if(xkTransfuseApply == null) return new Result("-1","该申请单不存在！");
if (xkTransfuseApply == null) return new Result("-1", "该申请单不存在！");
String billStasus = xkTransfuseApply.getBill_stasus();
String newBillStatus = "";
switch (billStasus){
switch (billStasus) {
case "C":
newBillStatus = "F";
break;
@ -252,73 +256,73 @@ public class MatchBloodServiceImpl implements MatchBloodService {
xkTransfuseApplyTemp.setBill_no(applyNo);
xkTransfuseApplyTemp.setBill_stasus(newBillStatus);
XkMatchMain xkMatchMainTemp = new XkMatchMain();
XkMatchMain xkMatchMainTemp = new XkMatchMain();
xkMatchMainTemp.setBill_no(billNo);
xkMatchMainTemp.setBill_status("ZF");
matchBloodUtil.deleteBloodInfoMatch(chargeMainBillNo,xkMatchMainTemp,xkCheckBloodtypeTemp,xkTransfuseApplyTemp);
matchBloodUtil.deleteBloodInfoMatch(chargeMainBillNo, xkMatchMainTemp, xkCheckBloodtypeTemp, xkTransfuseApplyTemp);
//调用外部接口
CancelMatchBloodTypeRequest cancelMatchBloodTypeRequest = new CancelMatchBloodTypeRequest();
cancelMatchBloodTypeRequest.setBillNo(billNo);
Result result = BloodInterfaceUtil.invokeBloodInterface(cancelMatchBloodTypeRequest);
if(!result.getCode().equals("0")) return result;
if (!result.getCode().equals("0")) return result;
return new Result("0","作废成功！");
return new Result("0", "作废成功！");
}
@Override
public Result queryBloodStock(MatchBloodStockQueryVO matchBloodStockQueryVO) {
List<Map<String,Object>> xkBloodInfoList = matchBloodMapper.queryBloodStock(matchBloodStockQueryVO);
List<Map<String, Object>> xkBloodInfoList = matchBloodMapper.queryBloodStock(matchBloodStockQueryVO);
//配血超过多少天后，在交叉配血，库存浏览中用特殊颜色进行显示
String pxcgts = bloodBankUtil.getParameterValue("PXCGTS");
//标记交叉配血
List<Map<String,Object>> xkMatchDetailList = matchBloodMapper.querySearchBloodLastMatchDate();
List<Map<String, Object>> xkMatchDetailList = matchBloodMapper.querySearchBloodLastMatchDate();
for (Map<String, Object> stringObjectMap : xkMatchDetailList) {
String matchDate = BloodBankUtil.isBank(stringObjectMap.get("match_date"));
String bloodNo = BloodBankUtil.isBank(stringObjectMap.get("blood_no"));
String productNo = BloodBankUtil.isBank(stringObjectMap.get("product_no"));
DateTime matchDateDelay = DateUtil.offsetDay(DateUtil.parse(matchDate, "yyyy-MM-dd"), Integer.parseInt(pxcgts));
//match_delay 配血超过预定天数未出库
if(matchDateDelay.compareTo(bloodBankUtil.getCurrentTimeDate()) > 0){
if (matchDateDelay.compareTo(bloodBankUtil.getCurrentTimeDate()) > 0) {
xkBloodInfoList.stream().filter(mapParam ->
BloodBankUtil.isBank(mapParam.get("blood_no")).equals(bloodNo) && BloodBankUtil.isBank(mapParam.get("product_no")).equals(productNo))
.forEach(mapParam -> mapParam.put("match_delay","Y"));
.forEach(mapParam -> mapParam.put("match_delay", "Y"));
}
}
return new Result("0","查询成功！",xkBloodInfoList);
return new Result("0", "查询成功！", xkBloodInfoList);
}
@Override
public Result queryLisResult(String billNo) {
List<XkTransfuseApplyTestitem> xkTransfuseApplyTestitemList = xkTransfuseApplyTestitemMapper.queryList(billNo);
return new Result("0","查询成功！",xkTransfuseApplyTestitemList);
return new Result("0", "查询成功！", xkTransfuseApplyTestitemList);
}
@Override
public Result queryMatchBloodList(MatchBloodListQueryVO matchBloodListQueryVO) {
List<Map<String, Object>> mapList = matchBloodMapper.queryMatchBloodList(matchBloodListQueryVO);
return new Result("0","查询成功！",mapList);
return new Result("0", "查询成功！", mapList);
}
@Override
public Result checkBloodMatched(String bloodNo, String productNo, String billNo) {
List<Map<String, Object>> mapList = matchBloodMapper.queryBloodMatchOthers(bloodNo, productNo, billNo);
if(!mapList.isEmpty()){
if (!mapList.isEmpty()) {
String msg = "检测到该血液存在以下配血记录：\r\n";
for (Map<String, Object> stringObjectMap : mapList) {
String temp = "科室："+stringObjectMap.get("dept_id")+"患者姓名:"+stringObjectMap.get("patient_name")
+"申请单:"+stringObjectMap.get("apply_no")
+"配血日期:"+stringObjectMap.get("test_date");
msg += temp+"\n";
String temp = "科室：" + stringObjectMap.get("dept_id") + "患者姓名:" + stringObjectMap.get("patient_name")
+ "申请单:" + stringObjectMap.get("apply_no")
+ "配血日期:" + stringObjectMap.get("test_date");
msg += temp + "\n";
}
return new Result("2",msg);
return new Result("2", msg);
}
return new Result("0","校验通过！");
return new Result("0", "校验通过！");
}
@Override
public Result queryApplyInfo(String billNo,String applyNo) {
public Result queryApplyInfo(String billNo, String applyNo) {
List<Map<String, Object>> matchMainInfoList = matchBloodMapper.queryMatchMainInfo(applyNo);
List<Map<String, Object>> matchDetailInfoList = matchBloodMapper.queryMatchDetailInfo(billNo);
List<XkTransfuseApplyBloodbreed> xkTransfuseApplyBloodbreedList = xkTransfuseApplyBloodbreedMapper.queryOne(applyNo);
@ -326,6 +330,6 @@ public class MatchBloodServiceImpl implements MatchBloodService {
matchBloodDTO.setMatchMainInfoList(matchMainInfoList);
matchBloodDTO.setMatchDetailInfoList(matchDetailInfoList);
matchBloodDTO.setXkTransfuseApplyBloodbreedList(xkTransfuseApplyBloodbreedList);
return new Result("0","查询成功！",matchBloodDTO);
return new Result("0", "查询成功！", matchBloodDTO);
}
}

38
blood_bus_bloodbank/src/main/java/com/czblood/busBloodbank/utils/MergeArrayUtil.java Normal file
View File

@ -0,0 +1,38 @@
package com.czblood.busBloodbank.utils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/*
* 根据字段去重合并数据
* @param list 数据源
* @param field 去重字段
* @param mergeField 合并字段
* */
public class MergeArrayUtil {
public static List<Map<String, Object>> mergeArray(List<Map<String, Object>> list, String field, String mergeField) {
Map<String, Map<String, Object>> resultMap = new HashMap<>();
for (Map<String, Object> item : list) {
String billNo = (String) item.get(field);
// 如果该数据还不存在，直接存入
if (!resultMap.containsKey(billNo)) {
List<String> breedList = new ArrayList<>();
breedList.add((String) item.get(mergeField));
item.put(mergeField, breedList);
resultMap.put(billNo, new HashMap<>(item));
} else {
// 已经存在，取出旧对象
Map<String, Object> existMap = resultMap.get(billNo);
@SuppressWarnings("unchecked")
List<String> breedList = (List<String>) existMap.get(mergeField);
breedList.add((String) item.get(mergeField));
existMap.put(mergeField, breedList);
}
}
return new ArrayList<>(resultMap.values());
}
}

2
blood_bus_doctor/src/main/resources/mapper/TransfuseApplyMapper.xml
View File

@ -9,7 +9,7 @@
xk_transfuse_apply.apply_date,
xk_transfuse_apply.apply_medic,
xk_transfuse_apply.bill_stasus,
xk_transfuse_apply.beinhos_id ,
xk_transfuse_apply.beinhos_id,
xk_transfuse_apply.abo_type,
xk_transfuse_apply.rh_type,
xk_transfuse_apply.is_large_use,

20
blood_start/src/test/java/com/czblood/start/SpringBootAllTest.java
View File

@ -1,7 +1,7 @@
package com.czblood.start;
import com.czblood.bus.mapper.XKHosInfoMapper;
import com.czblood.bus.pojo.XkHosInfo;
//import com.czblood.bus.mapper.XKHosInfoMapper;
//import com.czblood.bus.pojo.XkHosInfo;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
@ -11,13 +11,13 @@ import java.util.List;
@SpringBootTest
public class SpringBootAllTest {
@Resource
XKHosInfoMapper xkHosInfoMapper;
// @Resource
// XKHosInfoMapper xkHosInfoMapper;
@Test
public void test1(){
XkHosInfo xkHosInfo = new XkHosInfo();
List<XkHosInfo> xkHosInfoList = xkHosInfoMapper.query(xkHosInfo);
System.out.println(xkHosInfoList);
}
// @Test
// public void test1(){
// XkHosInfo xkHosInfo = new XkHosInfo();
// List<XkHosInfo> xkHosInfoList = xkHosInfoMapper.query(xkHosInfo);
// System.out.println(xkHosInfoList);
// }
}