package com.kidgrow.oprationcenter.service.impl;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.kidgrow.common.constant.ConsumptionConstant;
|
import com.kidgrow.common.constant.PayConstants;
|
import com.kidgrow.common.model.PageResult;
|
import com.kidgrow.common.model.ResultBody;
|
import com.kidgrow.common.service.impl.SuperServiceImpl;
|
import com.kidgrow.common.utils.DateUtils;
|
import com.kidgrow.common.utils.StringUtils;
|
import com.kidgrow.oprationcenter.mapper.ConsumptionRecordMapper;
|
import com.kidgrow.oprationcenter.model.ConsumptionRecord;
|
import com.kidgrow.oprationcenter.model.PayManager;
|
import com.kidgrow.oprationcenter.model.ProductOrderDetail;
|
import com.kidgrow.oprationcenter.model.SaasClientPay;
|
import com.kidgrow.oprationcenter.service.IConsumptionRecordService;
|
import com.kidgrow.oprationcenter.service.IPayManagerService;
|
import com.kidgrow.oprationcenter.service.IProductOrderDetailService;
|
import com.kidgrow.oprationcenter.service.ISaasClientPayService;
|
import com.kidgrow.oprationcenter.vo.ConsumptionRequest;
|
import com.kidgrow.oprationcenter.vo.ConsumptionVo;
|
import com.kidgrow.oprationcenter.vo.ProductOrderJoinDetail;
|
import com.kidgrow.oprationcenter.vo.UserProductDetail;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.collections4.MapUtils;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.amqp.rabbit.core.RabbitTemplate;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
//import org.springframework.amqp.rabbit.annotation.RabbitListener;
|
//import org.springframework.amqp.rabbit.core.RabbitTemplate;
|
|
/**
|
* 石家庄喜高科技有限责任公司 版权所有 © Copyright 2020<br>
|
*
|
* @version 1.0
|
* @Description: <br>
|
* @Project: 运营中心<br>
|
* @CreateDate: Created in 2020-06-23 15:07:14 <br>
|
* @Author: <a href="411269194@kidgrow.com">houruijun</a>
|
*/
|
@Slf4j
|
@Service
|
public class ConsumptionRecordServiceImpl extends SuperServiceImpl<ConsumptionRecordMapper, ConsumptionRecord> implements IConsumptionRecordService {
|
@Autowired
|
private IProductOrderDetailService productOrderDetailService;
|
@Autowired
|
private IPayManagerService payManagerService;
|
@Autowired
|
private ISaasClientPayService saasClientPayService;
|
@Autowired
|
private RabbitTemplate rabbitTemplate;
|
|
private static final Logger logger = LoggerFactory.getLogger(ConsumptionRecordServiceImpl.class);
|
@Value("${spring.profiles.active}")
|
private String envName;
|
|
/**
|
* 列表
|
*
|
* @param params
|
* @return
|
*/
|
@Override
|
public PageResult<ConsumptionRecord> findList(Map<String, Object> params) {
|
Page<ConsumptionRecord> page = new Page<>(MapUtils.getInteger(params, "page"), MapUtils.getInteger(params, "limit"));
|
List<ConsumptionRecord> list = baseMapper.findList(page, params);
|
return PageResult.<ConsumptionRecord>builder().data(list).code(0).count(page.getTotal()).build();
|
}
|
|
/**
|
* 列表
|
*
|
* @param params
|
* @return
|
*/
|
@Override
|
public List<ConsumptionRecord> findAllList(Map<String, Object> params) {
|
return baseMapper.findList(params);
|
}
|
|
/**
|
* 根据ConsumptionRecord对象当做查询条件进行查询
|
*
|
* @param consumptionRecord
|
* @return ConsumptionRecord
|
*/
|
@Override
|
public ConsumptionRecord findByObject(ConsumptionRecord consumptionRecord) {
|
return baseMapper.findByObject(consumptionRecord);
|
}
|
|
/**
|
* 要让AI读片-调用
|
*
|
* @param consumptionRequest 请求的数据实体
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public ResultBody consumptionAIStart(ConsumptionRequest consumptionRequest) {
|
//默认的业务返回码
|
int bcode = -1;
|
//记录类型
|
int recordType = ConsumptionConstant.BEFORE_DEDUCTION;
|
//业务执行结果
|
boolean isSuccess = true;
|
//业务执行结果信息
|
String reMsg = "";
|
if (VateParams(consumptionRequest)) {
|
//是否开通单次支付
|
if (departmentIsPay(consumptionRequest)) {
|
//是否支付成功
|
if (departmentPayStatus(consumptionRequest)) {
|
//预扣费成功
|
reMsg = "单次支付模拟预扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
|
} else {
|
reMsg = "单次支付未成功，不允许预扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
isSuccess = false;
|
}
|
} else {
|
//先获取这个业务关联的扣费记录
|
List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
|
//1.先检查是否已经扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
|
//2.没有扣费，检查是否已经预扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
|
//3.没有预扣，查询余额
|
Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
|
if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
|
//4.余额充足 获取要扣的套餐 写预扣费记录
|
if (beforeConsumption(consumptionRequest)) {
|
//预扣费成功
|
reMsg = "预扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
|
} else {
|
//预扣费执行失败
|
isSuccess = false;
|
reMsg = "预扣费执行失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
|
}
|
} else {
|
//余额不足 或获取异常
|
isSuccess = false;
|
reMsg = vateMap.get("vateMsg").toString();
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
}
|
} else {
|
//已经预扣费
|
reMsg = "该业务已经预扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION;
|
}
|
} else {
|
//已经扣费
|
reMsg = "该业务已经扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
}
|
}
|
} else {
|
isSuccess = false;
|
reMsg = "传入参数有误！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
|
}
|
return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
|
}
|
|
/**
|
* AI返回结果-调用
|
*
|
* @param consumptionRequest 请求的数据实体
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public ResultBody consumptionAIReturn(ConsumptionRequest consumptionRequest) {
|
//默认的业务返回码
|
int bcode = -1;
|
//记录类型
|
int recordType = ConsumptionConstant.DEDUCTION;
|
//业务执行结果
|
boolean isSuccess = true;
|
//业务执行结果信息
|
String reMsg = "";
|
if (VateParams(consumptionRequest)) {
|
//是否开通单次支付
|
if (departmentIsPay(consumptionRequest)) {
|
//是否支付成功
|
if (departmentPayStatus(consumptionRequest)) {
|
//预扣费成功
|
reMsg = "单次支付模拟扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
//消息队列通知
|
MessageToBI(consumptionRequest);
|
} else {
|
reMsg = "单次支付未成功，不允许扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
isSuccess=false;
|
}
|
} else {
|
//先获取这个业务关联的扣费记录
|
List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
|
Long hospitalId = consumptionRequest.getHospitalId();
|
|
//1.先检查是否已经扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
|
//2.没有扣费，检查是否已经预扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
|
//2.1.没有预扣，查询余额
|
Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), hospitalId, consumptionRequest.getDepartmentId());
|
if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
|
//2.2.余额充足 获取要扣的套餐 写预扣费记录
|
if (beforeConsumption(consumptionRequest)) {
|
//预扣费成功
|
logger.info("医院id:【{}】AI返回结果应该不走预扣，目前确已经预扣！", hospitalId);
|
} else {
|
//预扣费执行失败
|
isSuccess = false;
|
reMsg = "预扣费执行失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
|
return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
|
}
|
} else {
|
//余额不足
|
isSuccess = false;
|
reMsg = vateMap.get("vateMsg").toString();
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
|
}
|
}
|
if (consumptionBusiess(consumptionRequest, consumptionRecordList)) {
|
reMsg = "该业务扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
} else {
|
isSuccess = false;
|
reMsg = "该业务扣费失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
}
|
} else {
|
//已经扣费
|
reMsg = "该业务已经扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
}
|
}
|
} else {
|
isSuccess = false;
|
reMsg = "传入参数有误！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
|
}
|
return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
|
}
|
|
/**
|
* AI拒读/失败通知-调用
|
*
|
* @param consumptionRequest 请求的数据实体
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public ResultBody consumptionAIFail(ConsumptionRequest consumptionRequest) {
|
//默认的业务返回码
|
int bcode = -1;
|
//记录类型
|
int recordType = ConsumptionConstant.RETURN_BEFORE_DEDUCTION;
|
//业务执行结果
|
boolean isSuccess = false;
|
//业务执行结果信息
|
String reMsg = "";
|
if (VateParams(consumptionRequest)) {
|
//是否开通单次支付
|
if (departmentIsPay(consumptionRequest)) {
|
//是否支付成功
|
if (departmentPayStatus(consumptionRequest)) {
|
//预扣费成功
|
reMsg = "单次支付模拟退还扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION;
|
isSuccess=true;
|
} else {
|
reMsg = "单次支付未成功，不允许退扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
}
|
} else {
|
//先获取这个业务关联的扣费记录
|
List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
|
//1.先检查是否已经扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
|
//2.没有扣费，检查是否已经预扣费
|
if (isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
|
//2.1.有预扣费
|
ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.BEFORE_DEDUCTION && f.getProOrderDetailId() > 0).collect(Collectors.toList()).get(0);
|
//把占用的套餐id还回去
|
Long tempProOrderDetailId = consumptionRecord.getProOrderDetailId();
|
consumptionRecord.setProOrderDetailId(0L);
|
consumptionRecord.setUpdateTime(new Date());
|
if (SaveConsumptionRecord(consumptionRecord)) {
|
//退预扣记录
|
ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
|
consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_RETURN_BEFORE_DEDUCTION);
|
consumptionRecordNew.setBusinessId(consumptionRequest.getBusinessId());
|
consumptionRecordNew.setConsumptionCount(0 - consumptionRequest.getConsumptionCount());
|
consumptionRecordNew.setRecordType(ConsumptionConstant.RETURN_BEFORE_DEDUCTION);
|
consumptionRecordNew.setProOrderDetailId(tempProOrderDetailId);
|
consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
|
consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
|
if (SaveConsumptionRecord(consumptionRecordNew)) {
|
isSuccess = true;
|
reMsg = "有预扣，写退还预扣成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_BEFORE_DEDUCTION;
|
} else {
|
reMsg = "写退还预扣失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
|
}
|
} else {
|
reMsg = "更新预扣费记录失败！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
} else {
|
reMsg = "没有相关预扣记录！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
|
}
|
} else {
|
recordType = ConsumptionConstant.RETURN_DEDUCTION;
|
//3.有扣费记录 这种情况的流程，实际业务中不会出现，但理论上应该这样处理
|
//3.1 退还账户
|
//获取预扣的时候占住的套餐id
|
ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.DEDUCTION).collect(Collectors.toList()).get(0);
|
if (consumptionRecord != null) {
|
ProductOrderDetail productOrderDetail = productOrderDetailService.getById(consumptionRecord.getProOrderDetailId());
|
if (productOrderDetail != null) {
|
//退还金额
|
productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() + consumptionRecord.getConsumptionCount());
|
productOrderDetail.setUpdateTime(new Date());
|
//退费
|
boolean consumptionRe = productOrderDetailService.saveOrUpdate(productOrderDetail);
|
if (consumptionRe) {
|
//更新扣费记录 还回占用套餐
|
consumptionRecord.setProOrderDetailId(0L);
|
consumptionRecord.setUpdateTime(new Date());
|
if (SaveConsumptionRecord(consumptionRecord)) {
|
//退费成功
|
//3.2 写退费记录
|
ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
|
consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION);
|
consumptionRecordNew.setBusinessId(consumptionRecord.getBusinessId());
|
consumptionRecordNew.setConsumptionCount(0 - consumptionRecord.getConsumptionCount());
|
consumptionRecordNew.setRecordType(ConsumptionConstant.RETURN_DEDUCTION);
|
consumptionRecordNew.setProOrderDetailId(productOrderDetail.getId());
|
consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
|
consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
|
if (SaveConsumptionRecord(consumptionRecordNew)) {
|
//写退费记录成功
|
isSuccess = true;
|
reMsg = "退还扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_RETURN_DEDUCTION;
|
} else {
|
reMsg = "退还扣费失败！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
} else {
|
//更新扣费失败
|
reMsg = "更新扣费失败！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
} else {
|
//退费失败
|
reMsg = "退还扣费失败！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
} else {
|
reMsg = "无相关套餐数据！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
} else {
|
reMsg = "无相关扣费数据！";
|
bcode = ConsumptionConstant.BUSINESS_RUN_FAIL;
|
}
|
}
|
}
|
} else {
|
reMsg = "传入参数有误！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
|
}
|
return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
|
}
|
|
/**
|
* 发起人工读片-调用
|
*
|
* @param consumptionRequest 请求的数据实体
|
* @return
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public ResultBody consumptionArtificial(ConsumptionRequest consumptionRequest) {
|
//默认的业务返回码
|
int bcode = -1;
|
//记录类型
|
int recordType = ConsumptionConstant.DEDUCTION;
|
//业务执行结果
|
boolean isSuccess = false;
|
//业务执行结果信息
|
String reMsg = "";
|
if (VateParams(consumptionRequest)) {
|
//是否开通单次支付
|
if (departmentIsPay(consumptionRequest))
|
{
|
//是否支付成功
|
if (departmentPayStatus(consumptionRequest)) {
|
//预扣费成功
|
reMsg = "单次支付模拟已经扣费成功！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
isSuccess = true;
|
//消息队列通知
|
MessageToBI(consumptionRequest);
|
} else {
|
reMsg = "单次支付未成功，不允许业务进行！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
}
|
}
|
else {
|
//先获取这个业务关联的扣费记录
|
List<ConsumptionRecord> consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
|
//1.先检查是否已经扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.DEDUCTION)) {
|
//2.没有扣费，检查是否已经预扣费
|
if (!isBeforeDeduction(consumptionRecordList, ConsumptionConstant.BEFORE_DEDUCTION)) {
|
//3.没有预扣，查询余额
|
Map<String, Object> vateMap = VateUserNowProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
|
if (Boolean.parseBoolean(vateMap.get("vateRe").toString())) {
|
//4.余额充足 获取要扣的套餐 写预扣费记录
|
if (!beforeConsumption(consumptionRequest)) {
|
//预扣费执行失败
|
reMsg = "预扣费执行失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_ERROR;
|
return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
|
} else {
|
//发起了一个新的预扣，需要更新扣费业务数据列表
|
consumptionRecordList = GetBusinessConsumptionList(consumptionRequest.getBusinessId());
|
}
|
} else {
|
//余额不足
|
reMsg = vateMap.get("vateMsg").toString();
|
bcode = ConsumptionConstant.BUSINESS_CODE_FAIL;
|
return ResultReturn(consumptionRequest, bcode, ConsumptionConstant.BEFORE_DEDUCTION, reMsg, isSuccess);
|
}
|
}
|
//扣费业务
|
isSuccess = consumptionBusiess(consumptionRequest, consumptionRecordList);
|
if (isSuccess) {
|
reMsg = "该业务已经扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
} else {
|
reMsg = "该业务扣费失败！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
|
}
|
} else {
|
isSuccess = true;
|
//已经扣费
|
reMsg = "该业务已经扣费！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION;
|
}
|
}
|
} else {
|
reMsg = "传入参数有误！";
|
bcode = ConsumptionConstant.BUSINESS_CODE_PARAMS_ERROR;
|
}
|
return ResultReturn(consumptionRequest, bcode, recordType, reMsg, isSuccess);
|
}
|
|
/**
|
* 扣费业务(扣费 更新预扣 写扣费记录)
|
*
|
* @param consumptionRequest 请求参数
|
* @param consumptionRecordList 扣费业务数据
|
* @return
|
*/
|
private boolean consumptionBusiess(ConsumptionRequest consumptionRequest, List<ConsumptionRecord> consumptionRecordList) {
|
//3.已经预扣费 则扣费 写扣费记录 更新预扣状态
|
ConsumptionRecord consumptionRecord = consumptionRecordList.stream().filter(f -> f.getRecordType() == ConsumptionConstant.BEFORE_DEDUCTION).collect(Collectors.toList()).get(0);
|
Long detailId = consumptionRecord.getProOrderDetailId();
|
//获取预扣的时候占住的套餐id
|
ProductOrderDetail productOrderDetail = productOrderDetailService.getById(detailId);
|
if (productOrderDetail.getAilightCount() >= consumptionRequest.getConsumptionCount()) {
|
//扣掉
|
productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() - consumptionRequest.getConsumptionCount());
|
} else {
|
//要是被别人已经用了，就要重新找套餐
|
productOrderDetail = deductionDepartmentProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
|
if (productOrderDetail == null) {
|
logger.info("业务编号:【{}】无可用套餐！", consumptionRequest.getBusinessId());
|
return false;
|
} else {
|
//新套餐扣费
|
productOrderDetail = productOrderDetailService.getById(detailId);
|
productOrderDetail.setAilightCount(productOrderDetail.getAilightCount() - consumptionRequest.getConsumptionCount());
|
}
|
}
|
//3.1扣费！
|
boolean consumptionRe = productOrderDetailService.saveOrUpdate(productOrderDetail);
|
if (consumptionRe) {
|
//3.2扣费成功，写扣费记录
|
ConsumptionRecord consumptionRecordNew = new ConsumptionRecord();
|
consumptionRecordNew.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_IS_DEDUCTION);
|
consumptionRecordNew.setBusinessId(consumptionRequest.getBusinessId());
|
consumptionRecordNew.setConsumptionCount(consumptionRequest.getConsumptionCount());
|
consumptionRecordNew.setRecordType(ConsumptionConstant.DEDUCTION);
|
consumptionRecordNew.setProOrderDetailId(productOrderDetail.getId());
|
consumptionRecordNew.setLastRecordId(consumptionRecord.getId());
|
consumptionRecordNew.setDiaId(consumptionRequest.getDiaId());
|
consumptionRecordNew.setCreateTime(new Date());
|
|
if (SaveConsumptionRecord(consumptionRecordNew)) {
|
//3.3 扣费成功 如果套餐id变化，则更新预扣费的套餐id
|
if (!consumptionRecordNew.getProOrderDetailId().equals(consumptionRecord.getProOrderDetailId())) {
|
consumptionRecord.setProOrderDetailId(productOrderDetail.getId());
|
consumptionRecord.setUpdateTime(new Date());
|
if (!SaveConsumptionRecord(consumptionRecord)) {
|
logger.info("业务编号:【{}】更新预扣费的套餐id！", consumptionRequest.getBusinessId());
|
}
|
}
|
//消息队列通知
|
MessageToBI(consumptionRequest);
|
//已经扣费
|
logger.info("业务编号:【{}】该业务已经扣费！", consumptionRequest.getBusinessId());
|
return true;
|
} else {
|
logger.info("业务编号:【{}】预扣费执行失败！", consumptionRequest.getBusinessId());
|
}
|
} else {
|
logger.info("业务编号:【{}】扣除套餐失败！", consumptionRequest.getBusinessId());
|
}
|
return false;
|
}
|
|
/**
|
* 返回结果包装
|
*
|
* @param consumptionRequest 请求参数
|
* @param bcode 返回码
|
* @param reMsg 返回信息
|
* @param isSuccess 业务执行是否成功
|
* @return
|
*/
|
private ResultBody ResultReturn(ConsumptionRequest consumptionRequest, int bcode, int recordType, String reMsg, boolean isSuccess) {
|
//返回的数据实体
|
ConsumptionVo consumptionVo = new ConsumptionVo();
|
consumptionVo.setConsumptionCount(consumptionRequest.getConsumptionCount());
|
consumptionVo.setBusinessId(consumptionRequest.getBusinessId());
|
consumptionVo.setBcode(bcode);
|
consumptionVo.setRecordType(recordType);
|
logger.info("扣费业务返回参数实体："+consumptionRequest.toString());
|
logger.info("扣费业务返回其他参数：bcode:{},recordType:{},reMsg:{},isSuccess:{}",bcode,recordType,reMsg,isSuccess);
|
if (isSuccess) {
|
return ResultBody.ok().data(consumptionVo).msg(reMsg);
|
} else {
|
return ResultBody.failed(reMsg).data(consumptionVo);
|
}
|
}
|
|
/**
|
* 预扣费业务
|
*
|
* @param consumptionRequest 请求参数
|
* @return
|
*/
|
private Boolean beforeConsumption(ConsumptionRequest consumptionRequest) {
|
ProductOrderDetail productOrderDetail = deductionDepartmentProduct(consumptionRequest.getConsumptionCount(), consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
|
if (productOrderDetail != null) {
|
ConsumptionRecord consumptionRecord = new ConsumptionRecord();
|
consumptionRecord.setBusinessCode(ConsumptionConstant.BUSINESS_CODE_IS_BEFORE_DEDUCTION);
|
consumptionRecord.setBusinessId(consumptionRequest.getBusinessId());
|
consumptionRecord.setConsumptionCount(consumptionRequest.getConsumptionCount());
|
consumptionRecord.setRecordType(ConsumptionConstant.BEFORE_DEDUCTION);
|
consumptionRecord.setProOrderDetailId(productOrderDetail.getId());
|
consumptionRecord.setDiaId(consumptionRequest.getDiaId());
|
if (SaveConsumptionRecord(consumptionRecord)) {
|
return true;
|
} else {
|
logger.info("医院id:【{}】预扣费执行失败！", consumptionRequest.getHospitalId());
|
}
|
} else {
|
logger.info("医院id:【{}】套餐获取失败！", consumptionRequest.getHospitalId());
|
}
|
return false;
|
}
|
|
/**
|
* 参数验证
|
*/
|
private Boolean VateParams(ConsumptionRequest consumptionRequest) {
|
logger.info("收到扣费请求的参数："+consumptionRequest.toString());
|
if (consumptionRequest != null) {
|
//从请求头获取医院和科室id
|
String hosId = consumptionRequest.getHospitalId().toString();
|
String depId = consumptionRequest.getDepartmentId().toString();
|
String doctorId = consumptionRequest.getDoctorId().toString();
|
String diaId = consumptionRequest.getDiaId();
|
if (StringUtils.isNotBlank(consumptionRequest.getBusinessId())
|
&& consumptionRequest.getConsumptionCount() > 0
|
&& StringUtils.isNotBlank(hosId)
|
&& StringUtils.isNotBlank(depId)
|
&& StringUtils.isNotBlank(doctorId)
|
&& StringUtils.isNotBlank(diaId)) {
|
return true;
|
} else {
|
logger.info("扣费请求参数不完整！");
|
}
|
} else {
|
logger.info("扣费请求参数为空！");
|
}
|
return false;
|
}
|
|
/**
|
* 检查余额够不够
|
*
|
* @param consumptionCount 要扣的数量
|
* @return
|
*/
|
private Map<String, Object> VateUserNowProduct(int consumptionCount, Long hospitalId, Long departmentId) {
|
Map<String, Object> returnMap = new HashMap<>();
|
ResultBody biUserPro = productOrderDetailService.biUserNowProduct(hospitalId, departmentId);
|
if (biUserPro.getCode() == 0) {
|
if (StringUtils.isNotBlank(biUserPro.getData().toString())) {
|
//余额
|
int userAICount = Integer.parseInt(biUserPro.getData().toString());
|
if (userAICount >= consumptionCount) {
|
returnMap.put("vateRe", true);
|
returnMap.put("vateMsg", "余额足够!");
|
} else {
|
returnMap.put("vateRe", false);
|
returnMap.put("vateMsg", "余额不足!");
|
logger.info("医院id:【{}】余额不足！", hospitalId);
|
}
|
} else {
|
returnMap.put("vateRe", false);
|
returnMap.put("vateMsg", "余额获取异常,data为空!");
|
logger.info("医院id:【{}】余额获取异常！", hospitalId);
|
}
|
} else {
|
returnMap.put("vateRe", false);
|
returnMap.put("vateMsg", "余额获取异常,Code非0!");
|
logger.info("医院id:【{}】余额获取异常,返回非0！", hospitalId);
|
}
|
return returnMap;
|
}
|
|
/**
|
* 获取要使用的套餐实体
|
*
|
* @param consumCount 要使用的数量
|
* @return
|
*/
|
private ProductOrderDetail deductionDepartmentProduct(int consumCount, Long hospitalId, Long departmentId) {
|
UserProductDetail userProductDetail = productOrderDetailService.getUserProductDetail(hospitalId, departmentId);
|
//合并集合
|
userProductDetail.getProductOrderJoinDetailListShare()
|
.addAll(userProductDetail.getProductOrderJoinDetailsListDep());
|
List<ProductOrderJoinDetail> productOrderJoinDetailList = userProductDetail.getProductOrderJoinDetailListShare();
|
if (productOrderJoinDetailList.size() > 0) {
|
//合并后按id排序并筛除已用完的套餐
|
List<ProductOrderJoinDetail> productOrderJoinDetailsNewList = productOrderJoinDetailList
|
.stream().filter(f -> f.getAilightCount() >= consumCount).collect(Collectors.toList());
|
//要使用的套餐信息
|
Long firstId=productOrderJoinDetailsNewList.get(0).getId();
|
logger.info("扣费要使用的套餐ID是id:【{}】", firstId);
|
ProductOrderDetail productOrderDetail = productOrderDetailService.getById(firstId);
|
return productOrderDetail;
|
}
|
return null;
|
}
|
|
/**
|
* 写/更新记录数据
|
*
|
* @param consumptionRecord
|
* @return
|
*/
|
private Boolean SaveConsumptionRecord(ConsumptionRecord consumptionRecord) {
|
if (consumptionRecord != null) {
|
if (consumptionRecord.getCreateTime() == null) {
|
consumptionRecord.setCreateTime(new Date());
|
}
|
return this.saveOrUpdate(consumptionRecord);
|
} else {
|
logger.info("扣费数据写入参数为空！");
|
}
|
return false;
|
}
|
|
/**
|
* 检查该业务是否存在该业务类型
|
*
|
* @param consumptionRecordList 该业务下的扣费列表
|
* @param recordType 记录类型编码 参考ConsumptionConstant里面
|
* @return
|
*/
|
private boolean isBeforeDeduction(List<ConsumptionRecord> consumptionRecordList, int recordType) {
|
if (consumptionRecordList != null) {
|
if (consumptionRecordList.size() > 0) {
|
//过滤预扣费的记录
|
return consumptionRecordList.stream().filter(f -> f.getRecordType() == recordType && f.getProOrderDetailId() > 0).collect(Collectors.toList()).size() == 1;
|
}
|
}
|
return false;
|
}
|
|
/**
|
* 获取一个业务关联的扣费记录
|
* @param businessId 光片的名称/编号
|
* @return
|
*/
|
private List<ConsumptionRecord> GetBusinessConsumptionList(String businessId) {
|
if (StringUtils.isNotBlank(businessId)) {
|
Map<String, Object> params = new HashMap<>();
|
params.put("businessId", businessId);
|
List<ConsumptionRecord> consumptionRecordList = this.findAllList(params);
|
return consumptionRecordList;
|
}
|
return null;
|
}
|
|
/**
|
* 获取一个扣费记录
|
*
|
* @param recordId 扣费记录id
|
* @return
|
*/
|
private ConsumptionRecord GetBusinessConsumptionList(Long recordId) {
|
if (recordId > 0) {
|
return baseMapper.selectById(recordId);
|
}
|
return null;
|
}
|
|
/**
|
* 发消息到消息队列
|
*
|
* @return
|
*/
|
//@RabbitListener(queues = "BoneAgeEvaluationData")
|
private void MessageToBI(ConsumptionRequest consumptionRequest) {
|
//发消息到队列
|
String context = "{\"hospitalId\":\"" + consumptionRequest.getHospitalId() +
|
"\",\"departmentId\":\"" + consumptionRequest.getDepartmentId() +
|
"\",\"doctorId\":\"" + consumptionRequest.getDoctorId() +
|
"\",\"date\":\"" + DateUtils.formatDate(new Date(), "yyyy-MM-dd") + "\"}";
|
rabbitTemplate.convertAndSend(ConsumptionConstant.EXCHANGE_DATA, ConsumptionConstant.ROUTINGKEY_DATA + envName, context);
|
|
log.info("骨龄评价扣费消息已发送：" + context);
|
}
|
|
/**
|
* 查看当前科室是否开通了单次支付
|
*
|
* @param consumptionRequest
|
* @return
|
*/
|
private Boolean departmentIsPay(ConsumptionRequest consumptionRequest) {
|
log.info("查看当前科室是否开通了单次支付请求参数："+consumptionRequest.toString());
|
PayManager payManager = payManagerService.findByObject(consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId());
|
log.info("查看当前科室是否开通了单次支付请求查询后数据："+payManager.toString());
|
if (payManager == null) {
|
return false;
|
} else {
|
return payManager.getId()!=null;
|
}
|
}
|
|
/**
|
* 查看当前科室当前诊断id的支付状态是否成功
|
*
|
* @param consumptionRequest
|
* @return
|
*/
|
private Boolean departmentPayStatus(ConsumptionRequest consumptionRequest) {
|
log.info("查看当前科室当前诊断id的支付状态是否成功请求参数："+consumptionRequest.toString());
|
SaasClientPay saasClientPay = saasClientPayService.findModelByObject(consumptionRequest.getHospitalId(), consumptionRequest.getDepartmentId(), consumptionRequest.getDiaId());
|
log.info("查看当前科室当前诊断id的支付状态是否成功查询后数据："+saasClientPay.toString());
|
if (saasClientPay == null) {
|
return false;
|
} else {
|
if (saasClientPay.getPayStatus().equals(PayConstants.ORDER_PAY_SUCEESS)) {
|
return true;
|
}
|
}
|
return false;
|
}
|
}
|
