package com.hx.phip.service.order.impl;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.hx.common.service.CommonService;
|
import com.hx.exception.TipsException;
|
import com.hx.mybatisTool.SqlSentence;
|
import com.hx.phiappt.common.*;
|
import com.hx.phiappt.constants.tool.PerformanceInfoTool;
|
import com.hx.phiappt.constants.tool.RefundToolUtil;
|
import com.hx.phiappt.model.*;
|
import com.hx.phiappt.model.activity.ActivityAction;
|
import com.hx.phiappt.model.activity.ActivityRule;
|
import com.hx.phiappt.model.coupon.CouponOrderDiscountLog;
|
import com.hx.phiappt.model.order.*;
|
import com.hx.phiappt.model.performance.PerformanceInfo;
|
import com.hx.phiappt.model.refund.*;
|
import com.hx.phiappt.model.user.UserCard;
|
import com.hx.phiappt.model.user.UserProjectItem;
|
import com.hx.phiappt.model.userMoney.UserMoneyUnclaimed;
|
import com.hx.phip.config.CustomParameter;
|
import com.hx.phip.dao.mapper.*;
|
import com.hx.phip.service.CreateNoService;
|
import com.hx.phip.service.PaymentMethodService;
|
import com.hx.phip.service.order.OrderRefundService;
|
import com.hx.phip.service.refund.RefundRecordItemService;
|
import com.hx.phip.service.refund.RefundRecordMethodService;
|
import com.hx.phip.service.refund.RefundRecordService;
|
import com.hx.phip.tool.CreateNo;
|
import com.hx.phip.tool.refund.OrderRefundCancelTool;
|
import com.hx.phip.tool.refund.PartialRefundUtil;
|
import com.hx.phip.tool.refund.PaymentCountTool;
|
import com.hx.phip.util.api.*;
|
import com.hx.phip.vo.order.payment.PayMethodVo;
|
import com.hx.phip.vo.order.refund.DistributionRedundMethodVo;
|
import com.hx.phip.vo.order.refund.DistributionRedundVo;
|
import com.hx.resultTool.Result;
|
import com.hx.util.StringUtils;
|
import com.hz.crm.dto.OrderStatusDto;
|
import com.hz.crm.dto.order.refund.RefundAmountModelDto;
|
import com.hz.crm.dto.order.refund.RefundDto;
|
import com.hz.crm.dto.order.refund.RefundReturnDto;
|
import com.hz.crm.feign.FOderService;
|
import com.hz.his.dto.aduit.AduitDto;
|
import com.hz.his.dto.marketing.OrderPartRefundDto;
|
import com.hz.his.dto.marketing.PartRefundPayDto;
|
import com.hz.his.dto.marketing.RefundProjectDto;
|
import com.hz.his.dto.order.*;
|
import com.hz.his.feign.service.marketing.MOrderService;
|
import com.hz.his.vo.order.refund.RefundCancelVo;
|
import com.platform.entity.ThirtApplication;
|
import com.platform.exception.PlatTipsException;
|
import com.platform.resultTool.PlatformCode;
|
import com.platform.resultTool.PlatformResult;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author CJH
|
* 重构与2023-03-20
|
*/
|
@Transactional
|
@Service
|
public class OrderRefundServiceImpl implements OrderRefundService {
|
|
/**log4j日志*/
|
private static final Logger logger = LoggerFactory.getLogger(OrderRefundServiceImpl.class.getName());
|
@Resource
|
private OrdersTotalMapper ordersTotalMapper;
|
@Resource
|
private OrderItemMapper orderItemMapper;
|
@Resource
|
private RefundRecordMapper refundRecordMapper;
|
@Resource
|
private OrderItemSonMapper orderItemSonMapper;
|
@Resource
|
private RefundNoteMapper refundNoteMapper;
|
@Resource
|
private RefundNoteItemsMapper refundNoteItemsMapper;
|
|
@Resource
|
private CommonService commonService;
|
|
@Resource
|
private FOderService fOderService;
|
|
@Resource
|
private SystemParameterMapper systemParameterMapper;
|
@Resource
|
private RefundRecordService refundRecordService;
|
@Resource
|
private PaymentMethodService paymentMethodService;
|
@Resource
|
private RefundRecordMethodService refundRecordMethodService;
|
@Resource
|
private RefundRecordItemService refundRecordItemService;
|
@Resource
|
private RefundRecordItemSourceMapper refundRecordItemSourceMapper;
|
@Resource
|
private CustomParameter customParameter;
|
@Resource
|
private MOrderService mOrderService;
|
|
@Resource
|
private CouponOrderDiscountLogMapper couponOrderDiscountLogMapper;
|
@Resource
|
private RefundRecordCouponMapper refundRecordCouponMapper;
|
@Resource
|
private CardEquityMapper cardEquityMapper;
|
@Resource
|
private RefundMethodTransformationMapper refundMethodTransformationMapper;
|
@Resource
|
private RefundRecordItemMethodMapper refundRecordItemMethodMapper;
|
@Resource
|
private RefundMapper refundMapper;
|
@Resource
|
private CreateNoService createNoService;
|
|
/**
|
* 获取退款页面详情
|
* @param ordersTotal 订单
|
* @return 可退款数量详情
|
*/
|
@Override
|
public List<Map<String, Object>> refundDetails(OrdersTotal ordersTotal) {
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlMap = new HashMap<>();
|
sqlSentence.setM(sqlMap);
|
|
sqlMap.put("isDel", BaseEntity.NO);
|
sqlMap.put("orderId", ordersTotal.getId());
|
//一级子订单
|
sqlSentence.sqlSentence("SELECT * FROM order_item WHERE orderId = #{m.orderId} AND isDel = #{m.isDel}",sqlMap);
|
List<OrderItem> orderItemList = orderItemMapper.selectList(sqlSentence);
|
|
List<Map<String, Object>> orderItems = new ArrayList<>();
|
|
for (OrderItem orderItem : orderItemList) {
|
//判断这个项目能不能显示处理
|
switch (orderItem.getType()) {
|
case OrderItemConstants.TYPE_PROJECT:
|
handleOrderItemIsProject(orderItems,orderItem);
|
break;
|
case OrderItemConstants.TYPE_RETAIL:
|
handleOrderItemIsRetail(orderItems,orderItem);
|
break;
|
case OrderItemConstants.TYPE_DRUG:
|
handleOrderItemIsRetail(orderItems, orderItem);
|
break;
|
case OrderItemConstants.TYPE_CARD:
|
handleOrderItemIsCard(orderItems, orderItem);
|
break;
|
case OrderItemConstants.TYPE_PROMOTION:
|
handleOrderItemIsPromotion(orderItems, orderItem);
|
break;
|
case OrderItemConstants.CARD_BAG:
|
handleOrderItemIsCardBag(orderItems, orderItem);
|
break;
|
default:
|
break;
|
}
|
}
|
return orderItems;
|
}
|
/**
|
* 处理一级是项目的
|
*/
|
public void handleOrderItemIsProject(List<Map<String, Object>> orderItems, OrderItem orderItem) {
|
//获取用户项目
|
UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);
|
if(userProjectItem == null){
|
throw new TipsException("用户项目获取失败！");
|
}
|
|
orderItems.add(itemRefandDataPackage(orderItem,null,userProjectItem,null));
|
}
|
|
/**订单子项退款信息封装*/
|
public Map<String,Object> itemRefandDataPackage(OrderItem orderItem,OrderItemSon orderItemSon,UserProjectItem userProjectItem,List<UserCard> userCardList){
|
|
Map<String,Object> itemData = new HashMap<>();
|
if(orderItemSon != null){
|
itemData.put("id",orderItemSon.getId());
|
itemData.put("type",orderItemSon.getType());
|
itemData.put("goodsName",orderItemSon.getGoodsName());
|
itemData.put("curPrice",orderItemSon.getCurPrice());
|
itemData.put("specs",orderItemSon.getSpecs());
|
itemData.put("buyNum",orderItemSon.getBuyNum());
|
itemData.put("hasReNum",orderItemSon.getHasReNum());
|
itemData.put("notUsedNum",orderItemSon.getBuyNum()-orderItemSon.getHasReNum());
|
}else{
|
itemData.put("id",orderItem.getId());
|
itemData.put("type",orderItem.getType());
|
itemData.put("goodsName",orderItem.getGoodsName());
|
itemData.put("curPrice",orderItem.getCurPrice());
|
itemData.put("specs",orderItem.getSpecs());
|
itemData.put("buyNum",orderItem.getBuyNum());
|
itemData.put("hasReNum",orderItem.getHasReNum());
|
itemData.put("notUsedNum",orderItem.getBuyNum()-orderItem.getHasReNum());
|
}
|
|
if(userProjectItem != null){
|
itemData.put("notUsedNum",userProjectItem.getNotUsedNum());
|
}
|
if(userCardList != null){
|
itemData.put("notUsedNum",userCardList.size());
|
}
|
return itemData;
|
}
|
|
/**
|
* 处理一级是商品的
|
*/
|
public void handleOrderItemIsRetail(List<Map<String, Object>> orderItems, OrderItem orderItem) {
|
orderItems.add(itemRefandDataPackage(orderItem,null,null,null));
|
}
|
|
/**
|
* 处理一级是卡项的
|
*/
|
public void handleOrderItemIsCard(List<Map<String, Object>> orderItems,OrderItem orderItem) {
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> sqlMap = new HashMap<>();
|
|
//获取用户卡项
|
List<UserCard> userCardList = PartialRefundUtil.getRefundCard(orderItem.getId(),UserProjectConstants.EFF_STATUS_YES,commonService);
|
|
//信息封装
|
Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,userCardList);
|
|
//获取卡项的详细条目
|
sqlMap.put("commonId",orderItem.getCommonId());
|
sqlSentence.sqlSentence(" SELECT groupName,shareMoney FROM card_equity WHERE cardItemId = #{m.commonId} ",sqlMap);
|
List<Map<String, Object>> cardEquitys = cardEquityMapper.selectListMap(sqlSentence);
|
|
itemData.put("list", cardEquitys);
|
orderItems.add(itemData);
|
|
}
|
|
/**
|
* 处理一级是促销的
|
*/
|
public void handleOrderItemIsPromotion(List<Map<String, Object>> orderItems, OrderItem orderItem) {
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> sqlMap = new HashMap<>();
|
|
//封装参数
|
Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,null);
|
|
//获取二级子订单
|
sqlMap.put("orderItemId", orderItem.getId());
|
sqlSentence.sqlSentence("SELECT * FROM order_item_source WHERE orderItemId = #{m.orderItemId} AND isDel = 0 ",sqlMap);
|
List<OrderItemSon> orderItemSonList = orderItemSonMapper.selectList(sqlSentence);
|
System.out.println("orderItemSonList:"+JSON.toJSONString(orderItemSonList));
|
if (orderItemSonList == null) {
|
return;
|
}
|
|
List<Map<String, Object>> promotionList = new ArrayList<>();
|
|
for (OrderItemSon orderItemSon : orderItemSonList) {
|
//判断这个项目能不能显示处理
|
switch (orderItemSon.getType()) {
|
case OrderGoodsConstants.TYPE_PROJECT:
|
handleOrderItemSonIsProject(promotionList, orderItemSon);
|
break;
|
case OrderItemConstants.TYPE_RETAIL:
|
handleOrderItemSonIsRetail(promotionList, orderItemSon);
|
break;
|
default:
|
break;
|
}
|
}
|
|
itemData.put("list", promotionList);
|
orderItems.add(itemData);
|
}
|
/**
|
* 处理一级是卡包
|
*/
|
public void handleOrderItemIsCardBag(List<Map<String, Object>> orderItems, OrderItem orderItem) {
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> sqlMap = new HashMap<>();
|
|
Map<String,Object> itemData = itemRefandDataPackage(orderItem,null,null,null);
|
|
//二级子订单
|
sqlMap.put("orderItemId", orderItem.getId());
|
sqlSentence.sqlSentence("SELECT * FROM order_item_source WHERE orderItemId= #{m.orderItemId} and isDel = 0 ",sqlMap);
|
List<OrderItemSon> orderItemSonList = orderItemSonMapper.selectList(sqlSentence);
|
if (orderItemSonList == null) {
|
return;
|
}
|
List<Map<String, Object>> promotionList = new ArrayList<>();
|
|
for (OrderItemSon orderItemSon : orderItemSonList) {
|
//判断这个项目能不能显示处理
|
switch (orderItemSon.getType()) {
|
case OrderGoodsConstants.TYPE_PROJECT:
|
handleOrderItemSonIsProject(promotionList, orderItemSon);
|
break;
|
case OrderItemConstants.TYPE_RETAIL:
|
handleOrderItemSonIsRetail(promotionList, orderItemSon);
|
break;
|
default:
|
break;
|
}
|
}
|
|
itemData.put("list", promotionList);
|
orderItems.add(itemData);
|
}
|
|
/**
|
* 处理二级是项目的
|
*/
|
public void handleOrderItemSonIsProject(List<Map<String, Object>> promotionList, OrderItemSon orderItemSon) {
|
|
//获取用户项目
|
UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);
|
if(userProjectItem == null){
|
throw new TipsException("用户项目获取失败[24]！");
|
}
|
Map<String,Object> itemData = itemRefandDataPackage(null,orderItemSon,userProjectItem,null);
|
|
promotionList.add(itemData);
|
}
|
|
|
/**
|
* 处理二级是商品的
|
*/
|
public void handleOrderItemSonIsRetail(List<Map<String, Object>> promotionList, OrderItemSon orderItemSon) {
|
promotionList.add(itemRefandDataPackage(null,orderItemSon,null,null));
|
}
|
|
/**
|
* 退款选择退款数量组装金额信息，退款里面这个非常重要
|
* @param orderRefundDto 退款数量信息
|
* @return 退款金额信息
|
*/
|
@Override
|
public OrderRefundDto nextStep(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto) {
|
logger.info("退款选择退款数量组装金额信息入参：{}", JSON.toJSONString(orderRefundDto));
|
|
//子单退款
|
List<OrderItemRefundDto> refundList = orderRefundDto.getRefundList();
|
//支付方式退款数据整合
|
List<OrderPayMethodDto> refundPayMethods = new ArrayList<>();
|
//退款总金额
|
BigDecimal totalAmount = BigDecimal.ZERO;
|
|
if (OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())) {
|
///////充值订单退款
|
refundPayMethods = rechargeRefundWay(ordersTotal);
|
for (OrderPayMethodDto orderPayMethodDto : refundPayMethods) {
|
totalAmount = totalAmount.add(orderPayMethodDto.getPayTotal()).setScale(2,RoundingMode.HALF_UP);
|
}
|
}else{
|
//////其他订单类型
|
//整合支付方式退款金额
|
Map<String,OrderPayMethodDto> orderPayMethodDtoMap = new HashMap<>();
|
OrderPayMethodDto orderPayMethodDto;
|
|
DistributionRedundVo distributionRedundVo;
|
OrderItem orderItem;
|
//计算每个条目需要退多少钱
|
for (OrderItemRefundDto orderItemRefundDto : refundList) {
|
if(StringUtils.isEmpty(orderItemRefundDto.getOrderItemId())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识必填");
|
}
|
orderItem = orderItemMapper.selectOneByKey(orderItemRefundDto.getOrderItemId());
|
if (orderItem == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识错误");
|
}
|
if(!orderItem.getOrderId().equals(ordersTotal.getId())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款项[012]");
|
}
|
|
//判断这个项目能不能显示处理
|
switch (orderItem.getType()) {
|
case OrderItemConstants.TYPE_PROJECT:
|
distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
|
break;
|
case OrderItemConstants.TYPE_RETAIL:
|
distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
|
break;
|
case OrderItemConstants.TYPE_DRUG:
|
distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
|
break;
|
case OrderItemConstants.TYPE_CARD:
|
distributionRedundVo = itemOneRefund(orderItem,orderItemRefundDto);
|
break;
|
case OrderItemConstants.TYPE_PROMOTION:
|
distributionRedundVo = nextStepIsPromotion(orderItem,orderItemRefundDto);
|
break;
|
case OrderItemConstants.CARD_BAG:
|
distributionRedundVo = nextStepIsPromotion(orderItem,orderItemRefundDto);
|
break;
|
default:
|
throw new TipsException("未知商品类型[008]！");
|
}
|
|
//数据填充
|
orderItemRefundDto.setApproveRefundTotal(distributionRedundVo.getRefundTotal());
|
orderItemRefundDto.setType(distributionRedundVo.getGoodsType());
|
orderItemRefundDto.setGoodsName(distributionRedundVo.getGoodsName());
|
|
//可总退款金额计算
|
totalAmount = totalAmount.add(distributionRedundVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP);
|
|
//整合可退款方式金额
|
for(DistributionRedundMethodVo refundPaymentMethodVo:distributionRedundVo.getDistributionRedundMethodVoList()){
|
orderPayMethodDto = orderPayMethodDtoMap.computeIfAbsent(refundPaymentMethodVo.getNumberNo(),
|
k->new OrderPayMethodDto(refundPaymentMethodVo.getNumberNo(),refundPaymentMethodVo.getName(),BigDecimal.ZERO,refundPaymentMethodVo.getIsMoneyPay(),refundPaymentMethodVo.getIsExecute()));
|
orderPayMethodDto.setPayTotal(orderPayMethodDto.getPayTotal().add(refundPaymentMethodVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
|
}
|
}
|
|
for(Map.Entry<String, OrderPayMethodDto> entry : orderPayMethodDtoMap.entrySet()) {
|
refundPayMethods.add(entry.getValue());
|
}
|
}
|
|
//支付方式
|
orderRefundDto.setPayMethodList(refundPayMethods);
|
//可退总金额
|
orderRefundDto.setTotalAmount(totalAmount);
|
//优惠券
|
List<OrderCouponRefunDto> couponList = nextStepIsCoupon(ordersTotal.getId());
|
orderRefundDto.setPayCouponList(couponList);
|
|
return orderRefundDto;
|
}
|
|
/**获取充值单的退款方式金额*/
|
public List<OrderPayMethodDto> rechargeRefundWay(OrdersTotal ordersTotal){
|
|
//获取总支付方式
|
List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayGroupByNumberNo(ordersTotal.getId());
|
|
List<OrderPayMethodDto> consumeList = new ArrayList<>();
|
OrderPayMethodDto orderPayMethodDto;
|
//充值订单只能全退
|
for (PayMethodVo payMethodVo:payMethodVoList) {
|
//支付方式可退金额
|
orderPayMethodDto=new OrderPayMethodDto();
|
orderPayMethodDto.setPayMethodNo(payMethodVo.getNumberNo());
|
orderPayMethodDto.setPayMethodName(payMethodVo.getName());
|
orderPayMethodDto.setRefundNumberNo(payMethodVo.getNumberNo());
|
orderPayMethodDto.setRefundNumberName(payMethodVo.getName());
|
orderPayMethodDto.setPayTotal(payMethodVo.getSurplusTotal());
|
orderPayMethodDto.setMoney(orderPayMethodDto.getPayTotal());
|
consumeList.add(orderPayMethodDto);
|
}
|
return consumeList;
|
}
|
|
/**
|
* 判断是否有使用优惠卷
|
*/
|
public List<OrderCouponRefunDto> nextStepIsCoupon(String orderId) {
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlMap = new HashMap<>();
|
|
sqlMap.put("isDel", BaseEntity.NO);
|
sqlMap.put("orderId", orderId);
|
sqlMap.put("status", BaseEntity.NO);
|
sqlSentence.sqlSentence("SELECT id,title FROM coupon_order_discount_log WHERE orderId=#{m.orderId} AND status = #{m.status} AND isDel= #{m.isDel} ",sqlMap);
|
List<CouponOrderDiscountLog> couponOrderDiscountLogs = couponOrderDiscountLogMapper.selectList(sqlSentence);
|
//拼接返回参数
|
List<OrderCouponRefunDto> consumeList=new ArrayList<>();
|
OrderCouponRefunDto orderCouponRefunDto;
|
for (CouponOrderDiscountLog couponOrderDiscountLog : couponOrderDiscountLogs) {
|
orderCouponRefunDto=new OrderCouponRefunDto();
|
orderCouponRefunDto.setOrderCouponId(couponOrderDiscountLog.getId());
|
orderCouponRefunDto.setOrderCouponTitle(couponOrderDiscountLog.getTitle());
|
consumeList.add(orderCouponRefunDto);
|
}
|
|
return consumeList;
|
}
|
|
/**
|
* 一级子单计算可退款金额
|
* @param orderItemRefundDto 封装的方法
|
* @return 退款金额
|
*/
|
public DistributionRedundVo itemOneRefund(OrderItem orderItem,OrderItemRefundDto orderItemRefundDto) {
|
|
if(orderItemRefundDto.getRefundNum() == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款数量！");
|
}
|
if(orderItemRefundDto.getRefundNum() < 1) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
|
}
|
|
////算数量，退款用
|
//总数量
|
Integer buyNum;
|
//剩余数量
|
Integer surplusNum;
|
|
//获取用户项目
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlMap = new HashMap<>();
|
|
if(OrderItemConstants.TYPE_PROJECT.equals(orderItem.getType())){
|
//////项目
|
UserProjectItem userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);
|
if(userProjectItem == null){
|
//buyNum = orderItem.getUsedTotal();
|
//surplusNum = orderItem.getUsedTotal() - orderItem.getHasReNum();
|
throw new TipsException("用户项目获取失败！");
|
}
|
buyNum = userProjectItem.getUsedTotal();
|
surplusNum = userProjectItem.getNotUsedNum();
|
if(orderItemRefundDto.getRefundNum() > surplusNum){
|
throw new TipsException("退款数量与可退数量不符！");
|
}
|
//替换成子单的剩余数量
|
surplusNum = orderItem.getUsedTotal() - orderItem.getHasReNum();
|
}else if(OrderItemConstants.TYPE_CARD.equals(orderItem.getType())){
|
///////卡项
|
//获取可退款的卡项次数
|
List<UserCard> userCardList = PartialRefundUtil.getRefundCard(orderItem.getId(),UserProjectConstants.EFF_STATUS_YES,commonService);
|
buyNum = orderItem.getBuyNum();
|
surplusNum = userCardList.size();
|
if(orderItemRefundDto.getRefundNum() > surplusNum){
|
throw new TipsException("退款数量与可退数量不符！");
|
}
|
//替换成子单的剩余数量
|
surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
|
}else{
|
buyNum = orderItem.getBuyNum();
|
//替换成子单的剩余数量
|
surplusNum = orderItem.getBuyNum() - orderItem.getHasReNum();
|
}
|
if(orderItemRefundDto.getRefundNum() > surplusNum){
|
throw new TipsException("退款数量与可退数量不符！");
|
}
|
|
//获取该子单的支付方式，相同的支付方式求和返回
|
List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayOneGroupByNumberNo(orderItem.getId());
|
|
//获取已退款的金额
|
sqlMap.clear();
|
sqlMap.put("refundStatus",RefundStatus.STATUS_SUCC_REFUND);
|
sqlMap.put("orderItemId",orderItem.getId());
|
sqlSentence.sqlSentence("SELECT ROUND(SUM(rri.occupyRefundTotal),2) AS occupyRefundTotal FROM refund_record_item rri" +
|
" JOIN refund_record rr ON rr.id = rri.refundRecordId AND rr.isDel = 0 AND rr.refundStatus = #{m.refundStatus}" +
|
" WHERE rri.isDel = 0 AND rri.orderItemId = #{m.orderItemId}",sqlMap);
|
RefundRecordItem refundRecordItem = commonService.selectOne(RefundRecordItemMapper.class,sqlSentence);
|
|
//计算退款方式金额
|
DistributionRedundVo distributionRedundVo = PaymentCountTool.countMakeWay(orderItem.getId(),orderItem.getActualTotal(),refundRecordItem==null?BigDecimal.ZERO:refundRecordItem.getOccupyRefundTotal()
|
,buyNum,surplusNum,null,orderItemRefundDto.getRefundNum(),payMethodVoList,commonService);
|
|
distributionRedundVo.setGoodsType(orderItem.getType());
|
distributionRedundVo.setGoodsName(orderItem.getGoodsName());
|
|
return distributionRedundVo;
|
}
|
|
/**
|
* 二级子单计算可退款金额
|
* @param orderItemSourceRefundDto 封装的方法
|
* @param goodsType 子单的商品类型
|
* @return 退款金额
|
*/
|
public DistributionRedundVo itemTwoRefund(OrderItemSon orderItemSon,OrderItemSourceRefundDto orderItemSourceRefundDto,String goodsType) {
|
|
if(orderItemSourceRefundDto.getRefundNum() == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款数量！");
|
}
|
if(orderItemSourceRefundDto.getRefundNum() < 1) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
|
}
|
|
////算数量
|
//总数量
|
Integer buyNum;
|
//剩余数量
|
Integer surplusNum;
|
|
//获取用户项目
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlMap = new HashMap<>();
|
|
UserProjectItem userProjectItem = null;
|
if(OrderItemConstants.TYPE_PROJECT.equals(goodsType)){
|
//获取用户项目
|
userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);
|
if(userProjectItem == null){
|
throw new TipsException("用户项目获取失败！");
|
}
|
buyNum = userProjectItem.getUsedTotal();
|
surplusNum = userProjectItem.getNotUsedNum();
|
if(orderItemSourceRefundDto.getRefundNum() > surplusNum){
|
throw new TipsException("退款数量与可退数量不符！");
|
}
|
//替换成子单
|
surplusNum = orderItemSon.getUsedTotal() - orderItemSon.getHasReNum();
|
}else{
|
buyNum = orderItemSon.getBuyNum();
|
surplusNum = orderItemSon.getBuyNum() - orderItemSon.getHasReNum();
|
}
|
|
if(orderItemSourceRefundDto.getRefundNum() > surplusNum){
|
throw new TipsException("退款数量与可退数量不符！");
|
}
|
|
//获取该子单的支付方式，相同的支付方式算和返回
|
List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayTwoGroupByNumberNo(orderItemSon.getId());
|
|
//获取已退款的金额
|
sqlMap.clear();
|
sqlMap.put("refundStatus",RefundStatus.STATUS_SUCC_REFUND);
|
sqlMap.put("orderItemSonId",orderItemSon.getId());
|
sqlSentence.sqlSentence("SELECT ROUND(SUM(rris.occupyRefundTotal),2) AS occupyRefundTotal FROM refund_record_item_source rris" +
|
" JOIN refund_record rr ON rr.id = rris.refundRecordId AND rr.isDel = 0 AND rr.refundStatus = #{m.refundStatus}" +
|
" WHERE rris.isDel = 0 AND rris.orderItemSonId = #{m.orderItemSonId}",sqlMap);
|
RefundRecordItemSource refundRecordItemSource = commonService.selectOne(RefundRecordItemSourceMapper.class,sqlSentence);
|
//计算退款方式金额
|
DistributionRedundVo distributionRedundVo = PaymentCountTool.countMakeWay(orderItemSon.getId(),orderItemSon.getActualTotal(),refundRecordItemSource==null?BigDecimal.ZERO:refundRecordItemSource.getOccupyRefundTotal()
|
,buyNum,surplusNum,null,orderItemSourceRefundDto.getRefundNum(),payMethodVoList,commonService);
|
distributionRedundVo.setGoodsType(orderItemSon.getType());
|
distributionRedundVo.setGoodsName(orderItemSon.getGoodsName());
|
return distributionRedundVo;
|
}
|
|
/**
|
* 一级是促销
|
*/
|
public DistributionRedundVo nextStepIsPromotion(OrderItem orderItem,OrderItemRefundDto orderItemRefundDto) {
|
|
List<OrderItemSourceRefundDto> orderItemSourceRefundDtos = orderItemRefundDto.getOrderItemSourceRefundDtos();
|
if (orderItemSourceRefundDtos == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款数量不能小于1");
|
}
|
|
//2022-12-29 荣爷说因为优惠卷超过了金额，数据库是负数，所以退款取0
|
if(orderItem.getActualTotal().compareTo(BigDecimal.ZERO)<1){
|
orderItem.setActualTotal(BigDecimal.ZERO);
|
}
|
|
//返回结构
|
DistributionRedundVo distributionRedundVo = new DistributionRedundVo();
|
|
//整合当前一级子单的退款金额数据，key值：支付方式编号
|
Map<String,DistributionRedundMethodVo> refundPaymentMethodVoMap = new HashMap<>();
|
DistributionRedundMethodVo refundPaymentMethodVo;
|
|
DistributionRedundVo distributionRedundVoSon;
|
for (OrderItemSourceRefundDto orderItemSourceRefundDto : orderItemSourceRefundDtos) {
|
if(StringUtils.isEmpty(orderItemSourceRefundDto.getOrderItemSonId())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识必填[54]");
|
}
|
|
OrderItemSon orderItemSon = orderItemSonMapper.selectOneByKey(orderItemSourceRefundDto.getOrderItemSonId());
|
if (orderItemSon == null) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款项标识错误[54]");
|
}
|
|
if (!orderItemSon.getOrderItemId().equals(orderItem.getId())) {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款项[54]");
|
}
|
|
switch (orderItemSon.getType()) {
|
case OrderGoodsConstants.TYPE_PROJECT:
|
distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
|
break;
|
case OrderItemConstants.TYPE_RETAIL:
|
distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
|
break;
|
case OrderItemConstants.TYPE_DRUG:
|
distributionRedundVoSon = itemTwoRefund(orderItemSon,orderItemSourceRefundDto,orderItemSourceRefundDto.getType());
|
break;
|
default:
|
throw new TipsException("未知商品类型[098]！");
|
}
|
|
//数据填充
|
orderItemSourceRefundDto.setType(distributionRedundVoSon.getGoodsType());
|
orderItemSourceRefundDto.setGoodsName(distributionRedundVoSon.getGoodsName());
|
orderItemSourceRefundDto.setApproveRefundTotal(distributionRedundVoSon.getRefundTotal());
|
|
//返回结构金额填充
|
distributionRedundVo.setRefundTotal(distributionRedundVo.getRefundTotal().add(distributionRedundVoSon.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
|
distributionRedundVo.setRefundCash(distributionRedundVo.getRefundCash().add(distributionRedundVoSon.getRefundCash()).setScale(2,RoundingMode.HALF_UP));
|
distributionRedundVo.setRefundExecute(distributionRedundVo.getRefundExecute().add(distributionRedundVoSon.getRefundExecute()).setScale(2,RoundingMode.HALF_UP));
|
|
//整合退款金额
|
for(DistributionRedundMethodVo paymentMethodVo:distributionRedundVoSon.getDistributionRedundMethodVoList()){
|
//整合金额，上级用到
|
refundPaymentMethodVo = refundPaymentMethodVoMap.computeIfAbsent(paymentMethodVo.getNumberNo()
|
,k-> new DistributionRedundMethodVo(paymentMethodVo.getNumberNo(),paymentMethodVo.getName(),BigDecimal.ZERO,paymentMethodVo.getIsMoneyPay(),paymentMethodVo.getIsExecute()));
|
refundPaymentMethodVo.setRefundTotal(refundPaymentMethodVo.getRefundTotal().add(paymentMethodVo.getRefundTotal()).setScale(2,RoundingMode.HALF_UP));
|
}
|
|
}
|
|
//返回结构数据填充
|
distributionRedundVo.setGoodsName(orderItem.getGoodsName());
|
distributionRedundVo.setGoodsType(orderItem.getType());
|
|
//整合退款金额的数据
|
List<DistributionRedundMethodVo> distributionPayList = new ArrayList<>();
|
for(Map.Entry<String,DistributionRedundMethodVo> entry : refundPaymentMethodVoMap.entrySet()){
|
distributionPayList.add(entry.getValue());
|
}
|
distributionRedundVo.setDistributionRedundMethodVoList(distributionPayList);
|
|
return distributionRedundVo;
|
}
|
|
/**
|
* 确认退款处理退款逻辑
|
* @param orderRefundDto
|
* @return
|
*/
|
@Override
|
public PlatformResult partRefund(OrdersTotal ordersTotal, OrderRefundDto orderRefundDto, ThirtApplication thirtApplication) {
|
logger.info("退款打印参数：{}", JSON.toJSONString(orderRefundDto));
|
|
if(OrderTotalConstants.PAY_STATUS_SUC != ordersTotal.getPayStatus()){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单未支付!");
|
}
|
if(OrderTotalConstants.STATUS_PAY != ordersTotal.getStatus()
|
&& OrderTotalConstants.STATUS_WAIT_RECEIVE != ordersTotal.getStatus()
|
&& OrderTotalConstants.STATUS_DONE != ordersTotal.getStatus()){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单不是已支付状态!");
|
}
|
|
if(OrderTotalConstants.STATUS_REFUND_NONE != ordersTotal.getRefundStatus() &&
|
OrderTotalConstants.STATUS_REFUND_PART != ordersTotal.getRefundStatus()){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单退款状态不正确!");
|
}
|
|
//先优先改成申请退款中
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
|
map.put("refundStatus",OrderTotalConstants.STATUS_REFUND_APPLY);
|
map.put("isSyncOrder", BaseEntity.NO);
|
map.put("id",ordersTotal.getId());
|
sqlSentence.sqlSentence(" refundStatus=#{m.refundStatus},isSyncOrder=#{m.isSyncOrder} WHERE id=#{m.id} AND refundStatus IN('"+OrderTotalConstants.STATUS_REFUND_NONE+"','"+OrderTotalConstants.STATUS_REFUND_PART+"') ",map);
|
if(ordersTotalMapper.updateWhere(sqlSentence) != 1){
|
throw new TipsException("操作失败，当前订单退款状态不能再次发起退款!");
|
}
|
|
//校验参数和获取系统参数，非常重要
|
orderRefundDto = parameterVerification(ordersTotal,orderRefundDto);
|
|
return handlePartRefund(ordersTotal,orderRefundDto,thirtApplication);
|
}
|
|
/**
|
* 校验参数，拼接参数
|
*/
|
public OrderRefundDto parameterVerification(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){
|
|
if(orderRefundDto.getRefundPayMethod() == null){
|
throw new TipsException("退款方式结构不能空");
|
}
|
|
//怕被获取到项目信息收到被改了项目价格，重新去获取一下项目价格
|
orderRefundDto = nextStep(ordersTotal,orderRefundDto);
|
|
//可退款支付格式，key值：支付编号
|
Map<String,OrderPayMethodDto> orderPayMethodDtoMap = new HashMap<>();
|
for (OrderPayMethodDto orderPayMethodDto : orderRefundDto.getPayMethodList()) {
|
orderPayMethodDtoMap.put(orderPayMethodDto.getPayMethodNo(),orderPayMethodDto);
|
}
|
|
//填写退款的总金额
|
BigDecimal refundTotal = BigDecimal.ZERO;
|
|
//校验金额
|
OrderPayMethodDto payMethodDto;
|
//遍历系统获取到的可退款方式
|
OrderPayMethodDto orderPayMethodDto;
|
for (int i = orderRefundDto.getRefundPayMethod().size()-1; i>=0 ;i--) {
|
orderPayMethodDto = orderRefundDto.getRefundPayMethod().get(i);
|
//获取是传值过来的金额数据
|
payMethodDto = orderPayMethodDtoMap.get(orderPayMethodDto.getPayMethodNo());
|
if(payMethodDto == null){
|
throw new TipsException("未找到["+orderPayMethodDto.getPayMethodName()+"]支付方式!");
|
}
|
//判断退款方式
|
PaymentMethod refundMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getRefundNumberNo());
|
if(refundMethod==null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该转换方式:"+orderPayMethodDto.getRefundNumberName()+"["+orderPayMethodDto.getRefundNumberNo()+"]");
|
}
|
if(orderPayMethodDto.getMoney() == null){
|
throw new TipsException("["+orderPayMethodDto.getPayMethodName()+"]退款金额必填!");
|
}
|
if(orderPayMethodDto.getMoney().compareTo(BigDecimal.ZERO) < 0){
|
throw new TipsException("["+orderPayMethodDto.getPayMethodName()+"]退款金额错误!");
|
}
|
if (orderPayMethodDto.getMoney().compareTo(payMethodDto.getPayTotal()) > 0){
|
throw new TipsException("当前退款方式["+orderPayMethodDto.getPayMethodName()+"]金额超出可退金额!");
|
}
|
//退款金额是0元，去掉退款方式
|
if(orderPayMethodDto.getMoney().compareTo(BigDecimal.ZERO) == 0){
|
orderRefundDto.getRefundPayMethod().remove(i);
|
}
|
orderPayMethodDto.setPayMethodName(payMethodDto.getPayMethodName());
|
orderPayMethodDto.setPayMethodNo(payMethodDto.getPayMethodNo());
|
orderPayMethodDto.setPayTotal(payMethodDto.getPayTotal());
|
|
refundTotal = refundTotal.add(orderPayMethodDto.getMoney()).setScale(2,RoundingMode.HALF_UP);
|
|
}
|
orderRefundDto.setRefundTotal(refundTotal);
|
|
if(orderRefundDto.getRefundTotal().compareTo(orderRefundDto.getTotalAmount()) > 0){
|
throw new TipsException("退款金额不能大于可退金额[004]！");
|
}
|
|
return orderRefundDto;
|
}
|
|
/**
|
* 处理退款详情
|
*/
|
public PlatformResult handlePartRefund(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto,ThirtApplication thirtApplication){
|
|
//订单节点日志
|
OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
|
StringBuilder orderNodeBuilder = new StringBuilder();
|
|
orderNodeBuilder.append("开始退款");
|
orderNodeBuilder.append("-本次退款项目总金额："+orderRefundDto.getTotalAmount()+",客户选的退款方式总金额："+orderRefundDto.getRefundTotal());
|
|
Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundDto.getOperatorId());//获取操作人信息
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
//退款总记录
|
orderNodeBuilder.append("-处理退款总记录");
|
|
//保存退款信息，不是真正的退款，提前扣减用户资金
|
RefundRecord refundRecord = insertRefundInfo(orderRefundDto,ordersTotal,orderNodeBuilder,thirtApplication);
|
|
//判断已支付订单是否需要营销助手审批
|
//记录取消日志
|
CancelOrder cancelOrder = handleCancelOrder(ordersTotal,orderRefundDto);
|
|
if (orderRefundDto.getIsApproval().equals(BaseEntity.YES)){
|
|
//调用审批成功
|
//判断是否是充值订单，是的话先冻结储值金，就是扣掉，审批通过就不处理储值金了，不通过还原资金
|
if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
|
//判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
|
if(ordersTotal.getTotal().compareTo(BigDecimal.ZERO)!=0){
|
String operationId=operator.get("operatorId");
|
String operatorName=operator.get("operatorName");
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),"充值单："+ordersTotal.getOrderNo()+"申请退款，预扣除金额："+ordersTotal.getTotal(),operationId,refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),new BigDecimal(String.valueOf(ordersTotal.getTotal())).negate(), UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND, OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.NO);
|
OrderLog orderLog = RefundToolUtil.setOrderLog(refundRecord, operationId, operatorName, "充值单："+ordersTotal.getOrderNo()+"申请退款，预扣除金额："+ordersTotal.getTotal(), 0, OrderLogConstants.LOG_TYPE_REFUND);
|
commonService.insert(OrderLogMapper.class,orderLog);
|
//活动规则退款处理
|
map.put("orderId", ordersTotal.getId());
|
sqlSentence.sqlSentence("select * from orders_info where isDel=0 and orderId=#{m.orderId}",map);
|
OrderInfo orderInfo=commonService.selectOne(OrderInfoMapper.class,sqlSentence);
|
handActivityRule(commonService, operationId, operatorName, sqlSentence, map, refundRecord,ordersTotal,orderInfo,0);
|
}
|
}
|
|
return handleApproval(ordersNodeLog,orderNodeBuilder,ordersTotal,cancelOrder,refundRecord);
|
}
|
|
//这里开始真正的退款到用户账户的
|
Map<String, Object> refund = handleRefundOrder(operator,refundRecord,ordersTotal,ordersNodeLog,orderNodeBuilder,cancelOrder);
|
return PlatformResult.success(refund);
|
}
|
|
/**保存退款信息
|
* 保存退款信息，并没有真正退款
|
*/
|
public RefundRecord insertRefundInfo(OrderRefundDto orderRefundDto,OrdersTotal ordersTotal
|
,StringBuilder orderNodeBuilder, ThirtApplication thirtApplication){
|
|
//操作人
|
Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
|
if(employee == null){
|
throw new TipsException("操作人标识错误！");
|
}
|
|
///////退款总表数据填充
|
//生成退款编号
|
String totalCode = createNoService.createNo("R",System.currentTimeMillis()+"",8);
|
RefundRecord refundRecord=new RefundRecord(totalCode,ordersTotal.getShopId(),ordersTotal.getShopName(),orderRefundDto.getRefundTotal()
|
, RefundStatus.STATUS_APPLY_REFUND,0, RefundSoruceConstants.TYPE_SOURCE_ORDER,orderRefundDto.getRemarks(),ordersTotal.getId(),ordersTotal.getUserId());
|
//操作人信息
|
refundRecord.setOperatorType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
|
refundRecord.setOperatorId(employee.getId());
|
refundRecord.setOperatorNo(employee.getEmployeeNo());
|
refundRecord.setOperatorName(employee.getCnName());
|
|
refundRecord.setRefundOperationType(orderRefundDto.getRefundOperationType());
|
/////退款的备注
|
refundRecord.setRemarks(orderRefundDto.getRemarks());
|
refundRecord.setRefundReason(orderRefundDto.getRefundReason());
|
refundRecord.setOperatorAppId(thirtApplication.getAppId());
|
refundRecord.setOperatorAppCode(thirtApplication.getAppIdCode());
|
refundRecord.setOperatorAppName(thirtApplication.getName());
|
refundRecordService.insert(refundRecord);
|
|
//退款方式处理
|
if(orderRefundDto.getRefundPayMethod() !=null && orderRefundDto.getRefundPayMethod().size() > 0){
|
handleRefundPayMethod(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord);
|
}
|
|
//退款的子项处理
|
if(orderRefundDto.getRefundList()!=null && orderRefundDto.getRefundList().size()>0){
|
insertRefundRecordItem(orderRefundDto,orderNodeBuilder,refundRecord);
|
}
|
//回退的优惠卷处理
|
if(orderRefundDto.getCouponList() != null && orderRefundDto.getCouponList().size()>0){
|
handleOrderCouponRefunDto(orderRefundDto.getCouponList(),orderNodeBuilder,ordersTotal,refundRecord);
|
}
|
|
//*******扣减赠送的账户资金，如果订单有老带新的赠送规则，那么如果申请退款，就优先把老带新的退回来*****
|
//获取老带新记录
|
oldBlingNewRefund(refundRecord,orderNodeBuilder,commonService);
|
|
return refundRecord;
|
}
|
|
/**老带新的订单退款，佣金处理*/
|
public void oldBlingNewRefund(RefundRecord refundRecord,StringBuilder orderNodeBuilder,CommonService commonService){
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> values = new HashMap<>();
|
|
//查找老带新记录，未删除且有效的，没有退回的
|
values.put("operationReason",OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT);
|
values.put("orderId",refundRecord.getOrderId());
|
sqlSentence.sqlSentence("SELECT * FROM user_money_unclaimed mu WHERE mu.isDel = 0 AND mu.isValid = 1 AND mu.operationReason = #{m.operationReason}" +
|
" AND mu.orderId = #{m.orderId} AND NOT EXISTS(SELECT * FROM refund_user_assets rua WHERE rua.isDel = 0 AND rua.status = 1" +
|
" AND rua.amountStatus IN (1,3) AND rua.userMoneyUnclaimedId = mu.id)",values);
|
List<UserMoneyUnclaimed> userMoneyUnclaimedList = commonService.selectList(UserMoneyUnclaimedMapper.class,sqlSentence);
|
RefundUserAssets refundUserAssets;
|
UserMoney userMoney;
|
User user;
|
BigDecimal amount;
|
for (UserMoneyUnclaimed userMoneyUnclaimed:userMoneyUnclaimedList){
|
amount = BigDecimal.ZERO;
|
//生成记录
|
refundUserAssets = new RefundUserAssets();
|
refundUserAssets.setType(userMoneyUnclaimed.getOperationReason());
|
refundUserAssets.setStatus(RefundUserAssets.STATUS_NORMAL);
|
refundUserAssets.setAmountType(userMoneyUnclaimed.getFundType());
|
refundUserAssets.setAmount(userMoneyUnclaimed.getOpNumber().negate());
|
refundUserAssets.setOperatorId(refundRecord.getOperatorId());
|
refundUserAssets.setOperatorNo(refundRecord.getOperatorNo());
|
refundUserAssets.setOperatorName(refundRecord.getOperatorName());
|
refundUserAssets.setOrderId(refundRecord.getOrderId());
|
refundUserAssets.setRefundRecordId(refundRecord.getId());
|
refundUserAssets.setUserMoneyUnclaimedId(userMoneyUnclaimed.getId());
|
refundUserAssets.setUserId(userMoneyUnclaimed.getUserId());
|
|
user = commonService.selectOneByKey(UserMapper.class,refundUserAssets.getUserId());
|
orderNodeBuilder.append("-退款处理老带新，扣减用户：").append(user.getName()).append("，CIQ：").append(user.getCIQ()).append(",");
|
orderNodeBuilder.append(RefundUserAssets.amountTypeName(refundUserAssets.getAmountType())).append(refundUserAssets.getAmount());
|
if(userMoneyUnclaimed.getStatus() == UserMoneyUnclaimed.STATUS_WAI){
|
refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE);
|
//用户未领取，那么直接作废，作废是逻辑删除
|
values.put("id",userMoneyUnclaimed.getId());
|
values.put("status",UserMoneyUnclaimed.STATUS_WAI);
|
sqlSentence.sqlUpdate("isDel = 1,isValid = 0 WHERE id = #{m.id} AND isDel = 0 AND isValid = 1 AND status = #{m.status}",values);
|
if(commonService.updateWhere(UserMoneyUnclaimedMapper.class,sqlSentence) != 1){
|
throw new TipsException("老带新资产记录状态已变化！");
|
}
|
|
orderNodeBuilder.append("，用户未领取，作废领取记录");
|
}else if(userMoneyUnclaimed.getStatus() == UserMoneyUnclaimed.STATUS_SUCCEED){
|
//用户已经领取了，那么要扣掉，但是，要先判断用户是否够，如果不够，那么也生成记录，显示未操作资金
|
values.clear();
|
values.put("userId",userMoneyUnclaimed.getUserId());
|
sqlSentence.sqlSentence("SELECT * FROM user_money WHERE isDel = 0 AND userId = #{m.userId}",values);
|
userMoney = commonService.selectOne(UserMoneyMapper.class,sqlSentence);
|
if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND){
|
//储值金
|
if(userMoney.getStoredValueFund() != null){
|
amount = new BigDecimal(userMoney.getStoredValueFund());
|
}
|
}else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND){
|
//增值金
|
if(userMoney.getValueAddedFund() != null){
|
amount = new BigDecimal(userMoney.getValueAddedFund());
|
}
|
}else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_INTEGRAL){
|
//预定金
|
if(userMoney.getDeposit() != null){
|
amount = new BigDecimal(userMoney.getDeposit());
|
}
|
}else if(userMoneyUnclaimed.getFundType() == UserMoneyUnclaimed.FUND_TYPE_DEPOSIT){
|
//积分
|
if(userMoney.getIntegral() != null){
|
amount = new BigDecimal(userMoney.getIntegral());
|
}
|
}else{
|
throw new TipsException("老带新资产记录金额类型未知！");
|
}
|
if(amount.compareTo(refundUserAssets.getAmount()) >= 0){
|
//用户资产够减
|
orderNodeBuilder.append("，扣减成功");
|
refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NORMAL);
|
}else {
|
orderNodeBuilder.append("，余额不足，扣减失败");
|
//用户资产不够减
|
refundUserAssets.setAmountStatus(RefundUserAssets.AMOUNT_STATUS_NOT);
|
}
|
}else{
|
throw new TipsException("老带新资产记录状态错误！");
|
}
|
|
if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL
|
|| refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE ){
|
//保存记录，正常扣减和未领取才去保存这个记录
|
commonService.insert(RefundUserAssetsMapper.class,refundUserAssets);
|
}
|
|
//用户资金操作
|
if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL){
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundUserAssets.getUserId(),refundRecord.getRemarks(),"退款:老带新资金回退",refundUserAssets.getOperatorId()
|
,refundRecord.getOrderId(),refundRecord.getOperatorAppCode(),refundUserAssets.getId(),refundUserAssets.getAmount(),refundUserAssets.getAmountType()
|
,OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT_RETRUN,commonService,UserMoneyUnclaimed.YES);
|
}
|
|
}
|
|
}
|
|
/**老带新的订单退款不通过或者作废，佣金处理*/
|
public void oldBlingNewRefundFail(RefundRecord refundRecord,StringBuilder orderNodeBuilder,CommonService commonService) {
|
|
////订单退款状态是没有退款才退回
|
//获取回退记录
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> values = new HashMap<>();
|
values.put("orderId",refundRecord.getOrderId());
|
sqlSentence.sqlSentence("SELECT * FROM refund_user_assets rua WHERE rua.isDel = 0 AND rua.status = 1 AND rua.amountStatus IN(1,3) AND rua.orderId = #{m.orderId}",values);
|
List<RefundUserAssets> refundUserAssetsList = commonService.selectList(RefundUserAssetsMapper.class,sqlSentence);
|
|
User user;
|
for(RefundUserAssets refundUserAssets:refundUserAssetsList){
|
|
user = commonService.selectOneByKey(UserMapper.class,refundUserAssets.getUserId());
|
orderNodeBuilder.append("-退款处理老带新，回退资金到用户：").append(user.getName()).append("，CIQ：").append(user.getCIQ()).append(",");
|
orderNodeBuilder.append(RefundUserAssets.amountTypeName(refundUserAssets.getAmountType())).append(refundUserAssets.getAmount());
|
|
//是否有扣减用户资产
|
if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NORMAL){
|
orderNodeBuilder.append("，增加成功");
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundUserAssets.getUserId(),refundRecord.getRemarks(),"退款作废:老带新资金回退作废",refundUserAssets.getOperatorId()
|
,refundRecord.getOrderId(),refundRecord.getOperatorAppCode(),refundUserAssets.getId(),refundUserAssets.getAmount().negate(),refundUserAssets.getAmountType()
|
,OperationReasonConstants.OP_REASON_BRING_NEW_USER_GIFT_RETRU_CANCEL,commonService,UserMoneyUnclaimed.YES);
|
}else if(refundUserAssets.getAmountStatus() == RefundUserAssets.AMOUNT_STATUS_NOT_RECEIVE){
|
//用户未领取记录，还原
|
orderNodeBuilder.append("，用户未领取，作废的领取记录还原");
|
values.clear();
|
values.put("id",refundUserAssets.getUserMoneyUnclaimedId());
|
values.put("status",UserMoneyUnclaimed.STATUS_WAI);
|
sqlSentence.sqlUpdate("isDel = 0,isValid = 1 WHERE id = #{m.id} AND isDel = 1 AND isValid = 0 AND status = #{m.status}",values);
|
if(commonService.updateWhere(UserMoneyUnclaimedMapper.class,sqlSentence) != 1){
|
throw new TipsException("老带新资产记录状态已变化[作废]！");
|
}
|
}
|
|
//记录作废
|
values.clear();
|
values.put("id",refundUserAssets.getId());
|
values.put("status",RefundUserAssets.STATUS_CANCEL);
|
values.put("oldStatus",RefundUserAssets.STATUS_NORMAL);
|
sqlSentence.sqlSentence("status = #{m.status} WHERE id = #{m.id} AND status = #{m.oldStatus}",values);
|
if(commonService.updateWhere(RefundUserAssetsMapper.class,sqlSentence) != 1){
|
throw new TipsException("老带新资产退款记录状态已变化[作废]！");
|
}
|
}
|
|
}
|
|
/**
|
* 退款-处理活动规则增值金和积分
|
* @param commonService 映射对象
|
* @param operationId 操作人标识
|
* @param operationNme 操作人名称
|
* @param sqlSentence 映射对象
|
* @param map 映射对象
|
* @param refundRecord 退款记录
|
* @param ordersTotal 订单
|
* @param optType 操作："0"减 1加
|
*/
|
private static void handActivityRule(CommonService commonService, String operationId, String operationNme, SqlSentence sqlSentence,
|
Map<String, Object> map, RefundRecord refundRecord, OrdersTotal ordersTotal, OrderInfo orderInfo,int optType) {
|
if(orderInfo!=null && StringUtils.noNull(orderInfo.getActivityId())){
|
ActivityRule activityRule=commonService.selectOneByKeyBlob(ActivityRuleMapper.class,orderInfo.getActivityId());
|
if(activityRule!=null){
|
map.put("activityRuleId",activityRule.getId());
|
map.put("type", ActivityAction.TYPE_INTEGRAL);
|
map.put("type1",ActivityAction.TYPE_VALUEADDEDFUND);
|
map.put("type2",ActivityAction.TYPE_COUPON);
|
sqlSentence.sqlSentence("select * from activity_action where activityRuleId=#{m.activityRuleId} and (type=#{m.type} or type=#{m.type1} or type=#{m.type2}) and isDel=0",map);
|
List<ActivityAction> activityActions = commonService.selectList(ActivityActionMapper.class, sqlSentence);
|
if(activityActions!=null && activityActions.size()>0){
|
for (ActivityAction activityAction : activityActions) {
|
if(ActivityAction.TYPE_INTEGRAL.equals(activityAction.getType())){
|
//判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
|
if(new BigDecimal(activityAction.getWorth()).negate().compareTo(BigDecimal.ZERO)!=0){
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),optType==0?"充值单："+ordersTotal.getOrderNo()+" 申请退款，预扣除活动规则赠送储值金金额："+activityAction.getWorth():"充值单："+ordersTotal.getOrderNo()+" 申请退款，拒绝审批，返还赠送储值金预扣除金额："+activityAction.getWorth(),operationId,refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),optType==0?new BigDecimal(activityAction.getWorth()).negate():new BigDecimal(activityAction.getWorth()), UserMoneyUnclaimed.FUND_TYPE_INTEGRAL,OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.YES);
|
}
|
}else if(ActivityAction.TYPE_VALUEADDEDFUND.equals(activityAction.getType())){
|
//判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
|
if(new BigDecimal(activityAction.getWorth()).negate().compareTo(BigDecimal.ZERO)!=0){
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),optType==0?"充值单："+ordersTotal.getOrderNo()+" 申请退款，预扣除活动规则赠送增值金金额："+activityAction.getWorth():"充值单："+ordersTotal.getOrderNo()+" 申请退款，拒绝审批，返还赠送增值金预扣除金额："+activityAction.getWorth(),operationId,refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),optType==0?new BigDecimal(activityAction.getWorth()).negate():new BigDecimal(activityAction.getWorth()), UserMoneyUnclaimed.FUND_TYPE_VALUE_ADDED_FUND,OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.YES);
|
}
|
}else if(ActivityAction.TYPE_COUPON.equals(activityAction.getType())){
|
map.put("oldValidState",optType==0?BaseEntity.YES:BaseEntity.NO);
|
map.put("newValidState",optType==0?BaseEntity.NO:BaseEntity.YES);
|
map.put("couponId",activityAction.getCrmCouponId());
|
map.put("commonId",ordersTotal.getId());
|
sqlSentence.sqlSentence(" validState=#{m.newValidState} where couponId=#{m.couponId} and commonId=#{m.commonId} and validState=#{m.oldValidState} ",map);
|
commonService.updateWhere(CouponNumberMapper.class,sqlSentence);
|
}
|
}
|
}
|
}
|
}
|
|
}
|
|
/**
|
* 对接审批
|
*/
|
public PlatformResult handleApproval(OrdersNodeLog ordersNodeLog,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,CancelOrder cancelOrder,RefundRecord refundRecord){
|
orderNodeBuilder.append("-退款需要审批，开始对接营销中心");
|
|
|
OrderPartRefundDto orderPartRefundDto=new OrderPartRefundDto();
|
OrdersTotalDto ordersTotalDto=new OrdersTotalDto();
|
BeanUtils.copyProperties(ordersTotal, ordersTotalDto);
|
|
orderPartRefundDto.setOrdersTotalDto(ordersTotalDto);//填充主订单信息
|
|
|
//填充操作人，用户的基本信息
|
orderPartRefundDto.setOrdersTotalDto(ordersTotalDto);
|
orderPartRefundDto.setOperatorId(cancelOrder.getOperatorId());
|
orderPartRefundDto.setOpName(cancelOrder.getOperatorName());
|
orderPartRefundDto.setShopId(cancelOrder.getShopId());
|
orderPartRefundDto.setShopName(cancelOrder.getShopName());
|
orderPartRefundDto.setRoleId(cancelOrder.getRoleId());
|
orderPartRefundDto.setRoleUniqueStr(cancelOrder.getRoleStr());
|
if(StringUtils.noNull(refundRecord.getRemarks())){
|
orderPartRefundDto.setRemark(refundRecord.getRemarks());
|
}else{
|
orderPartRefundDto.setRemark(cancelOrder.getOperatorName()+"退款，订单号："+ordersTotal.getOrderNo());
|
}
|
|
orderPartRefundDto.setUserId(ordersTotal.getUserId());
|
|
//本次退款金额
|
orderPartRefundDto.setRefundTotal(refundRecord.getRefundTotal());
|
|
/**本次退款支付方式*/
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
|
map.put("refundRecordId", refundRecord.getId());
|
sqlSentence.sqlSentence("SELECT refundNumberNo AS payMethodNo,refundName AS payMethodName,actualTotal as refundMoney,refundRecordId as payMethodId FROM refund_record_method " +
|
" WHERE refundRecordId=#{m.refundRecordId} ",map);
|
List<Map<String, Object>> refundMethodList = commonService.selectListMap(RefundRecordMethodMapper.class,sqlSentence);
|
if(refundMethodList!=null && refundMethodList.size()!=0){
|
JSONArray refundMethodArray=new JSONArray();
|
refundMethodArray.addAll(refundMethodList);
|
List<PartRefundPayDto> partRefundPayDtoList=refundMethodArray.toJavaList(PartRefundPayDto.class);
|
orderPartRefundDto.setPartRefundPayDtoList(partRefundPayDtoList);
|
}
|
/**本次退款项目*/
|
//退款一级项目
|
sqlSentence.sqlSentence("SELECT type AS projectType, commonId AS projectId, goodsNo AS projectNo, goodsName AS projectName, refundNum AS refundNum " +
|
" FROM refund_record_item WHERE refundRecordId=#{m.refundRecordId} AND refundNum>0",map);
|
List<Map<String, Object>> refundRecordItemList = commonService.selectListMap(RefundRecordItemMapper.class,sqlSentence);
|
JSONArray refundProjectDtoArray=new JSONArray();
|
if(refundRecordItemList!=null && refundRecordItemList.size()!=0){
|
refundProjectDtoArray.addAll(refundRecordItemList);
|
}
|
//退款二级项目
|
sqlSentence.sqlSentence("SELECT type AS projectType, commonId AS projectId, goodsNo AS projectNo, goodsName AS projectName, refundNum AS refundNum " +
|
" FROM refund_record_item_source WHERE refundRecordId=#{m.refundRecordId} AND refundNum>0",map);
|
List<Map<String, Object>> refundRecordItemSourceList = commonService.selectListMap(RefundRecordItemSourceMapper.class,sqlSentence);
|
if(refundRecordItemSourceList!=null && refundRecordItemSourceList.size()!=0){
|
refundProjectDtoArray.addAll(refundRecordItemSourceList);
|
}
|
if(refundProjectDtoArray.size()>0){
|
List<RefundProjectDto> refundProjectDtoList=refundProjectDtoArray.toJavaList(RefundProjectDto.class);
|
orderPartRefundDto.setRefundProjectDtoList(refundProjectDtoList);
|
}
|
|
|
logger.info("调用营销中心审批退款入参：{}",JSONObject.toJSONString(orderPartRefundDto));
|
Result result= mOrderService.applyPartRefund(orderPartRefundDto);
|
// Result result= JSONObject.parseObject("{\"code\":\"100\",\"msg\":\"SUCCESS\",\"data\":{\"applyId\":\"6204eb10753511ed90ed525400b8510a\"}}",Result.class);
|
logger.info("调用营销中心审批退款返回：{}",JSONObject.toJSONString(result));
|
if (result != null) {
|
result.checkTips();
|
JSONObject object = JSONObject.parseObject(JSONObject.toJSONString(result.getData()));
|
if(!object.isEmpty()){
|
String applyId = object.getString("applyId");
|
cancelOrder.setApplyId(applyId);
|
cancelOrder.setRefundRecordId(refundRecord.getId());
|
commonService.updateAll(CancelOrderMapper.class,cancelOrder);
|
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_APPLY);
|
commonService.updateAll(OrdersTotalMapper.class,ordersTotal);
|
|
// logger.info("调用营销中心成功，订单开始审核");
|
orderNodeBuilder.append("-调用营销中心成功，订单开始审核");
|
ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
|
ordersNodeLog.setContent(orderNodeBuilder.toString());
|
ordersNodeLog.setOrderId(ordersTotal.getId());
|
commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);
|
|
orderNodeBuilder.append("-调用营销中心成功，订单开始审核");
|
|
return PlatformResult.success("订单正在审核中");
|
}else{
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求营销助手审批接口报错,data返回为空!");
|
}
|
} else {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求营销助手审批接口报错,返回为空!");
|
}
|
}
|
|
/**
|
* 记录退款订单记录日志
|
*/
|
public CancelOrder handleCancelOrder(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){
|
//记录取消日志
|
CancelOrder cancelOrder=new CancelOrder();
|
cancelOrder.setOrderId(ordersTotal.getId());
|
if(StringUtils.noNull(orderRefundDto.getOperatorId())){
|
Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
|
if(employee==null){
|
throw new TipsException("操作人标识错误！");
|
}
|
cancelOrder.setOperatorId(employee.getId());
|
cancelOrder.setOperatorName(employee.getCnName());
|
}
|
|
if(StringUtils.noNull(orderRefundDto.getRoleId())){
|
EmployeeRole employeeRole=commonService.selectOneByKey(EmployeeRoleMapper.class,orderRefundDto.getRoleId());
|
if(employeeRole==null){
|
throw new TipsException("操作角色标识错误！");
|
}
|
cancelOrder.setRoleId(employeeRole.getRoleTypeId());
|
cancelOrder.setRoleStr(employeeRole.getRoleUniqueStr());
|
Shop shop=commonService.selectOneByKey(ShopMapper.class,employeeRole.getShopId());
|
if(shop==null){
|
cancelOrder.setShopId(employeeRole.getShopId());
|
cancelOrder.setShopName("找不到对应的门店");
|
}else {
|
cancelOrder.setShopId(shop.getId());
|
cancelOrder.setShopName(shop.getName());
|
}
|
}
|
|
cancelOrder.setIsApproval(orderRefundDto.getIsApproval());
|
cancelOrder.setIsRefund(orderRefundDto.getIsRefund());
|
cancelOrder.setPlatformSource(orderRefundDto.getPlatformSource());
|
commonService.insert(CancelOrderMapper.class,cancelOrder);
|
|
return cancelOrder;
|
}
|
|
/**
|
* 处理退款方式记录表
|
*/
|
public List<RefundRecordMethod> handleRefundPayMethod(OrderRefundDto orderRefundDto,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,RefundRecord refundRecord){
|
orderNodeBuilder.append("-记录退款方式：");
|
|
//获取订单可退款方式，就是支付方式总表的信息，已经支付编号求和
|
List<PayMethodVo> payMethodVoList = refundMapper.getConsumePayGroupByNumberNo(ordersTotal.getId());
|
|
//用map装载，后面根据支付编号直接获取便可
|
Map<String, PayMethodVo> payMethodVoMap = payMethodVoList.stream().collect(Collectors.toMap(PayMethodVo::getNumberNo,(a) -> a));
|
|
List<RefundRecordMethod> refundRecordMethodList = new ArrayList<>();
|
|
PayMethodVo payMethodVo;
|
RefundRecordMethod refundRecordMethod;
|
for (OrderPayMethodDto orderPayMethodDto : orderRefundDto.getRefundPayMethod()) {
|
|
payMethodVo = payMethodVoMap.get(orderPayMethodDto.getPayMethodNo());
|
//判断是不是在支付方式里面的
|
if (payMethodVo == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"可退支付方式未找到:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
|
}
|
//判断支付方式
|
PaymentMethod payMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getPayMethodNo());
|
if(payMethod == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到对应的支付:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
|
}
|
//判断退款方式
|
PaymentMethod refundMethod = paymentMethodService.selectNumberNoUncheckUp(orderPayMethodDto.getRefundNumberNo());
|
if(refundMethod==null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到退款方式:"+orderPayMethodDto.getRefundNumberName()+"["+orderPayMethodDto.getRefundNumberNo()+"]");
|
}
|
if(orderPayMethodDto.getMoney() == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请填写退款方式["+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]"+"]金额");
|
}
|
//判断金额
|
if(payMethodVo.getSurplusTotal().compareTo(orderPayMethodDto.getMoney()) < 0){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"退款金额错误:"+orderPayMethodDto.getPayMethodName()+"["+orderPayMethodDto.getPayMethodNo()+"]");
|
}
|
|
////退款方式数据填充
|
refundRecordMethod = new RefundRecordMethod();
|
refundRecordMethod.setType(refundRecord.getSourceType());
|
refundRecordMethod.setActualTotal(orderPayMethodDto.getMoney());
|
//支付方式信息
|
refundRecordMethod.setNumberNo(payMethod.getNumberNo());
|
refundRecordMethod.setPaymentMethodId(payMethod.getId());
|
refundRecordMethod.setName(payMethod.getName());
|
refundRecordMethod.setIsMoneyPay(payMethodVo.getIsMoneyPay());
|
refundRecordMethod.setIsExecute(payMethodVo.getIsExecute());
|
//退款方式信息
|
refundRecordMethod.setRefundNumberNo(refundMethod.getNumberNo());
|
refundRecordMethod.setRefundName(refundMethod.getName());
|
refundRecordMethod.setRefundMethodId(refundMethod.getId());
|
|
refundRecordMethod.setIsMoneyPayRefund(refundMethod.getIsMoneyPay());
|
refundRecordMethod.setIsExecuteRefund(refundMethod.getIsExecute());
|
refundRecordMethod.setRefundRecordId(refundRecord.getId());
|
refundRecordMethod.setOrderId(ordersTotal.getId());
|
refundRecordMethod.setRemarks(orderPayMethodDto.getRemarks());
|
|
refundRecordMethodService.insert(refundRecordMethod);
|
refundRecordMethodList.add(refundRecordMethod);
|
}
|
return refundRecordMethodList;
|
}
|
|
/**
|
* 退款记录子项
|
*/
|
public void insertRefundRecordItem(OrderRefundDto orderRefundDto,StringBuilder orderNodeBuilder,RefundRecord refundRecord){
|
|
orderNodeBuilder.append("-记录退款详情");
|
|
//计算金额占比，客户选择退款总金额和可退总金额占比
|
BigDecimal percentage;
|
if(orderRefundDto.getTotalAmount().compareTo(BigDecimal.ZERO) < 1){
|
percentage = BigDecimal.ZERO;
|
}else {
|
percentage = orderRefundDto.getRefundTotal().divide(orderRefundDto.getTotalAmount(),15,RoundingMode.HALF_UP);
|
}
|
|
//总退款金额，用于后面计算分摊金额
|
BigDecimal refundTotal = refundRecord.getRefundTotal();
|
|
//后面设计分配金额问题，要进行升序排序，避免到最后不够
|
List<OrderItemRefundDto> refundList = orderRefundDto.getRefundList();
|
refundList = refundList.stream().sorted(Comparator.comparing(OrderItemRefundDto::getApproveRefundTotal)).collect(Collectors.toList());
|
|
/////引用参数
|
RefundRecordItem refundRecordItem;
|
OrderItemRefundDto orderItemRefundDto;
|
OrderItem orderItem;
|
for(int i = 0;i < refundList.size();i++){
|
orderItemRefundDto = refundList.get(i);
|
|
orderItem = orderItemMapper.selectOneByKey(orderItemRefundDto.getOrderItemId());
|
if(orderItem == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"子订单标识错误！");
|
}
|
|
//////数据填充
|
refundRecordItem = new RefundRecordItem();
|
refundRecordItem.setType(orderItem.getType());
|
refundRecordItem.setGoodsNo(orderItem.getGoodsNo());
|
refundRecordItem.setGoodsName(orderItem.getGoodsName());
|
refundRecordItem.setSpecs(orderItem.getSpecs());
|
refundRecordItem.setCommonId(orderItem.getCommonId());
|
if(PartialRefundUtil.CONTAIN_SON_TYPE_SET.contains(orderItem.getType())){
|
refundRecordItem.setRefundNum(0);
|
}else{
|
refundRecordItem.setRefundNum(orderItemRefundDto.getRefundNum());
|
}
|
refundRecordItem.setRefundRecordId(refundRecord.getId());
|
refundRecordItem.setOrderItemId(orderItem.getId());
|
refundRecordItem.setOccupyRefundTotal(orderItemRefundDto.getApproveRefundTotal());
|
////退款备注
|
if(StringUtils.isEmpty(orderItemRefundDto.getRemarks())){
|
orderItemRefundDto.setRemarks(refundRecord.getRemarks());
|
}
|
if(StringUtils.isEmpty(orderItemRefundDto.getRefundReason())){
|
orderItemRefundDto.setRefundReason(orderItemRefundDto.getRefundReason());
|
}
|
refundRecordItem.setRemarks(orderItemRefundDto.getRemarks());
|
refundRecordItem.setRefundReason(orderItemRefundDto.getRefundReason());
|
|
//////////分配退款金额
|
if(i == refundList.size()-1){
|
refundRecordItem.setRefundMoney(refundTotal);
|
}else{
|
refundRecordItem.setRefundMoney(orderItemRefundDto.getApproveRefundTotal().multiply(percentage).setScale(2,RoundingMode.UP));
|
}
|
if(refundRecordItem.getRefundMoney().compareTo(orderItemRefundDto.getApproveRefundTotal()) > 0){
|
refundRecordItem.setRefundMoney(orderItemRefundDto.getApproveRefundTotal());
|
}
|
//判断与未分配剩余金额
|
if(refundRecordItem.getRefundMoney().compareTo(refundTotal) > 0){
|
refundRecordItem.setRefundMoney(refundTotal);
|
}
|
|
refundRecordItem.setRealRefundNum(refundRecordItem.getRefundNum());
|
refundRecordItem.setRealRefundTotal(refundRecordItem.getRealRefundTotal());
|
|
refundRecordItemService.insert(refundRecordItem);
|
//减去已经分配的退款金额
|
refundTotal = refundTotal.subtract(refundRecordItem.getRefundMoney()).setScale(2,RoundingMode.HALF_UP);
|
if(PartialRefundUtil.CONTAIN_SON_TYPE_SET.contains(orderItem.getType())){
|
//子单子项处理
|
insertRefundRecordItemTwo(refundRecordItem,refundRecord,orderItemRefundDto.getOrderItemSourceRefundDtos());
|
}
|
}
|
|
if(refundTotal.compareTo(BigDecimal.ZERO) > 0){
|
throw new TipsException("退款金额分配错误[01]！");
|
}
|
|
}
|
|
/**二级子单处理*/
|
public void insertRefundRecordItemTwo(RefundRecordItem recordItem,RefundRecord refundRecord,List<OrderItemSourceRefundDto> orderItemSourceRefundDtos){
|
if(orderItemSourceRefundDtos == null || orderItemSourceRefundDtos.size() == 0){
|
return;
|
}
|
|
//计算占比
|
BigDecimal percentage;
|
if(recordItem.getOccupyRefundTotal().compareTo(BigDecimal.ZERO) > 0){
|
percentage = recordItem.getRefundMoney().divide(recordItem.getOccupyRefundTotal(),15,RoundingMode.HALF_UP);
|
}else{
|
percentage = BigDecimal.ZERO;
|
}
|
|
//进行升序排序，避免后面不够
|
orderItemSourceRefundDtos = orderItemSourceRefundDtos.stream().sorted(Comparator.comparing(OrderItemSourceRefundDto::getApproveRefundTotal)).collect(Collectors.toList());
|
|
//退款总金额
|
BigDecimal refundTotal = recordItem.getRefundMoney();
|
|
OrderItemSon orderItemSon;
|
OrderItemSourceRefundDto orderItemSourceRefundDto;
|
RefundRecordItemSource refundRecordItemSource;
|
|
for(int i = 0;i<orderItemSourceRefundDtos.size();i++){
|
orderItemSourceRefundDto = orderItemSourceRefundDtos.get(i);
|
|
orderItemSon = orderItemSonMapper.selectOneByKey(orderItemSourceRefundDto.getOrderItemSonId());
|
if(orderItemSon == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"子订单标识错误[024]！");
|
}
|
|
//////数据填充
|
refundRecordItemSource = new RefundRecordItemSource();
|
refundRecordItemSource.setType(orderItemSon.getType());
|
refundRecordItemSource.setGoodsNo(orderItemSon.getGoodsNo());
|
refundRecordItemSource.setGoodsName(orderItemSon.getGoodsName());
|
refundRecordItemSource.setSpecs(orderItemSon.getSpecs());
|
refundRecordItemSource.setCommonId(orderItemSon.getGoodsId());
|
refundRecordItemSource.setRefundNum(orderItemSourceRefundDto.getRefundNum());
|
refundRecordItemSource.setRefundRecordId(refundRecord.getId());
|
refundRecordItemSource.setOrderItemSonId(orderItemSon.getId());
|
refundRecordItemSource.setOccupyRefundTotal(orderItemSourceRefundDto.getApproveRefundTotal());
|
refundRecordItemSource.setRefundRecordItemId(recordItem.getId());
|
////退款备注
|
if(StringUtils.isEmpty(orderItemSourceRefundDto.getRemarks())){
|
orderItemSourceRefundDto.setRemarks(refundRecord.getRemarks());
|
}
|
if(StringUtils.isEmpty(orderItemSourceRefundDto.getRefundReason())){
|
orderItemSourceRefundDto.setRefundReason(refundRecord.getRefundReason());
|
}
|
refundRecordItemSource.setRemarks(orderItemSourceRefundDto.getRemarks());
|
refundRecordItemSource.setRefundReason(orderItemSourceRefundDto.getRefundReason());
|
|
//计算退款金额
|
if(i == orderItemSourceRefundDtos.size()-1){
|
refundRecordItemSource.setRefundMoney(refundTotal);
|
}else{
|
refundRecordItemSource.setRefundMoney(orderItemSourceRefundDto.getApproveRefundTotal().multiply(percentage).setScale(2,RoundingMode.UP));
|
}
|
if(refundRecordItemSource.getRefundMoney().compareTo(orderItemSourceRefundDto.getApproveRefundTotal()) > 0){
|
refundRecordItemSource.setRefundMoney(orderItemSourceRefundDto.getApproveRefundTotal());
|
}
|
if(refundRecordItemSource.getRefundMoney().compareTo(refundTotal) > 0){
|
refundRecordItemSource.setRefundMoney(refundTotal);
|
}
|
|
refundRecordItemSource.setRealRefundNum(refundRecordItemSource.getRefundNum());
|
refundRecordItemSource.setRealRefundTotal(refundRecordItemSource.getRefundMoney());
|
|
refundRecordItemSourceMapper.insert(refundRecordItemSource);
|
//减去已经分配退款金额
|
refundTotal = refundTotal.subtract(refundRecordItemSource.getRefundMoney()).setScale(2,RoundingMode.HALF_UP);
|
System.out.println("refundRecordItemSource.getRefundMoney():"+refundRecordItemSource.getRefundMoney());
|
}
|
System.out.println("refundTotal:"+refundTotal);
|
if(refundTotal.compareTo(BigDecimal.ZERO) > 0){
|
throw new TipsException("退款金额分配错误[02]！");
|
}
|
|
}
|
|
/**
|
* 记录退款记录优惠卷
|
*/
|
public void handleOrderCouponRefunDto(List<OrderCouponRefunDto> couponList,StringBuilder orderNodeBuilder,OrdersTotal ordersTotal,RefundRecord refundRecord){
|
CouponOrderDiscountLog couponOrderDiscountLog;
|
RefundRecordCoupon refundRecordCoupon;
|
orderNodeBuilder.append("-处理退款优惠卷");
|
for (OrderCouponRefunDto orderCouponRefunDto : couponList) {
|
couponOrderDiscountLog=couponOrderDiscountLogMapper.selectOneByKey(orderCouponRefunDto.getOrderCouponId());
|
if( couponOrderDiscountLog == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"订单优惠卷标识不正确");
|
}
|
refundRecordCoupon=new RefundRecordCoupon(ordersTotal.getId(),refundRecord.getId(),ordersTotal.getUserId(),1,1,couponOrderDiscountLog.getId(),
|
couponOrderDiscountLog.getCouponId(),couponOrderDiscountLog.getTitle(),couponOrderDiscountLog.getCouponNumberId());
|
refundRecordCouponMapper.insert(refundRecordCoupon);
|
}
|
}
|
|
|
|
/**真正退款，是对钱和状态的回退到账开始操作
|
* 进行退款操作，退款用户项目，商品，促销，卡项，卡包
|
*/
|
public Map<String,Object> handleRefundOrder(Map<String, String> operator,RefundRecord refundRecord,OrdersTotal ordersTotal
|
,OrdersNodeLog ordersNodeLog,StringBuilder orderNodeBuilder,CancelOrder cancelOrder ){
|
|
String operationId=operator.get("operatorId");
|
String operatorName=operator.get("operatorName");
|
|
orderNodeBuilder.append("-处理退款支付方式，用户待执行项目");
|
//处理主业务
|
ordersTotal = PartialRefundUtil.refundProcess(commonService, operationId, operatorName, refundRecord.getId());
|
|
//返回数据
|
Map<String,Object> data=new HashMap<>();
|
data.put("refundRecordId",refundRecord.getId());
|
data.put("refundRecordCode",refundRecord.getCode());
|
|
//处理次业务，报错不影响主业务
|
refundRecord = refundRecordService.selectOneByKey(refundRecord.getId());
|
|
/**
|
* 用户升降级(调用航爷) 金额=用户支付的实付现金金额(不包含储值金)
|
*/
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
//退款成功
|
map.put("refundRecordId", refundRecord.getId());
|
sqlSentence.sqlSentence("SELECT CAST(COALESCE(sum(rrm.realRefundTotal),0) as DECIMAL(11,2)) as total FROM refund_record_method rrm LEFT JOIN payment_method pm ON pm.numberNo=rrm.refundNumberNo " +
|
"WHERE rrm.refundRecordId=#{m.refundRecordId} and pm.isMoneyPay=1",map);
|
Map<String,Object> totalMap =commonService.selectOneMap(RefundRecordMethodMapper.class,sqlSentence);
|
BigDecimal total=new BigDecimal(String.valueOf(totalMap.get("total"))) ;
|
if(BigDecimal.ZERO.compareTo(total) < 0){
|
try {
|
orderNodeBuilder.append("-开始处理用户升降级，金额:").append(total.negate());
|
UserLevelUtil.refund(ordersTotal.getUserId(),ordersTotal.getId(),total.negate(),ordersTotal.getAppIdCode());
|
orderNodeBuilder.append("-处理用户升降级成功");
|
}catch (Exception e){
|
String snapshot="处理用户升降级失败";
|
orderNodeBuilder.append("-处理用户升降级失败,异常原因:").append(e.getMessage());
|
logger.error("处理用户升降级失败：" + e.getMessage());
|
//发送企业微信通知给工作人员
|
SendNoticeUtil.failOrderSendNotice(ordersTotal,e.getMessage(),snapshot,commonService,customParameter);
|
}
|
}
|
try{
|
orderNodeBuilder.append("-开始记录收入确认表");
|
PerformanceInfoTool.handRefundPerformanceInfo(commonService,refundRecord);
|
orderNodeBuilder.append("-记录收入确认表成功");
|
}catch (Exception e){
|
orderNodeBuilder.append("-记录收入确认表失败");
|
logger.info("记录收入确认表,异常:{}",e.getMessage(),e);
|
// 添加错误日志
|
PerformanceInfoTool.addErrorLog(commonService, refundRecord.getId(), PerformanceInfo.ASSOCIATION_TYPE_GOODS_REFUND, e.getMessage());
|
}
|
|
if(CancelOrderDto.HIS_ASSISTANT.equals(cancelOrder.getPlatformSource())){
|
//如果是his自动处理退款单原路退回
|
//CRM的操作也在这里
|
hisAssistantNoteList(ordersTotal,refundRecord,operationId,orderNodeBuilder);
|
}
|
|
//记录操作日志
|
orderNodeBuilder.append("-记录操作日志");
|
StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",进行退款");
|
OrderLog orderLog=new OrderLog(ordersTotal.getId(), OrderLogConstants.LOG_TYPE_REFUND,stringBuffer.toString()
|
,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
|
commonService.insert(OrderLogMapper.class,orderLog);
|
|
orderNodeBuilder.append("-结束处理退款");
|
ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
|
ordersNodeLog.setContent(orderNodeBuilder.toString());
|
ordersNodeLog.setOrderId(ordersTotal.getId());
|
commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);
|
|
return data;
|
}
|
/**
|
* his助手原路退回退款单
|
*/
|
public void hisAssistantNoteList(OrdersTotal ordersTotal,RefundRecord refundRecord,String operationId,StringBuilder orderNodeBuilder){
|
OrderRefundNoteListDto orderRefundNoteListDto=new OrderRefundNoteListDto();
|
orderRefundNoteListDto.setOperationId(operationId);
|
orderRefundNoteListDto.setOrderId(ordersTotal.getId());
|
|
// 没有现金支付， 如果是crm的订单则调用crm取消订单的方法
|
if("crm".equals(ordersTotal.getAppIdCode()) && OrderTotalConstants.STATUS_CANCEL == ordersTotal.getStatus()){
|
//通知crm
|
if(OrderTotalConstants.STATUS_REFUND_FINSH==ordersTotal.getRefundStatus()){
|
//全部退款完成
|
//通知crm订单取消成功了
|
Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundNoteListDto.getOperationId());//获取操作人信息
|
String operatorId= operator.get("operatorId");
|
String operatorName= operator.get("operatorName");
|
OrderStatusDto orderStatusDto=new OrderStatusDto();
|
orderStatusDto.setId(ordersTotal.getId());
|
orderStatusDto.setOpName(operatorName);
|
orderStatusDto.setOpId(operatorId);
|
orderStatusDto.setCancelInfo("phis取消退款");
|
orderStatusDto.setOpDetail("phis取消退款");
|
try {
|
logger.info("通知CRM订单号:{}退款成功请求参数：{}",ordersTotal.getOrderNo(),JSONObject.toJSONString(orderStatusDto));
|
Result result= fOderService.cancelOrder(orderStatusDto);
|
logger.info("通知CRM订单号:{}退款成功返回参数：{}",ordersTotal.getOrderNo(),JSONObject.toJSONString(result));
|
orderNodeBuilder.append("通知crm退款状态返回成功");
|
}catch (Exception e){
|
logger.info("通知crm订单号:{}退款成功错误:{}",ordersTotal.getOrderNo(),e.getMessage());
|
orderNodeBuilder.append("通知crm退款状态返回失败");
|
}
|
|
}
|
}
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
map.put("orderId",ordersTotal.getId());
|
map.put("refundRecordId",refundRecord.getId());
|
sqlSentence.sqlSentence("SELECT * FROM refund_note WHERE orderId=#{m.orderId} and refundRecordId=#{m.refundRecordId} and isDel=0 ",map);
|
List<RefundNote> refundNotes=refundNoteMapper.selectList(sqlSentence);
|
if(refundNotes==null || refundNotes.size()==0){
|
return;
|
}
|
|
List<OrderRefundNoteDto> orderRefundNoteDtos=new ArrayList<>();
|
OrderRefundNoteDto orderRefundNoteDto;
|
for (RefundNote refundNote : refundNotes) {
|
orderRefundNoteDto=new OrderRefundNoteDto();
|
BeanUtils.copyProperties(refundNote,orderRefundNoteDto);
|
orderRefundNoteDto.setRefundroute(1);
|
orderRefundNoteDto.setRefundNumberNo(refundNote.getPaymentNumberNo());
|
orderRefundNoteDto.setRefundName(refundNote.getPaymentName());
|
orderRefundNoteDtos.add(orderRefundNoteDto);
|
}
|
orderRefundNoteListDto.setOrderRefundNoteDtos(orderRefundNoteDtos);
|
|
noteConfirm(orderRefundNoteListDto, ordersTotal,refundRecord,orderNodeBuilder);
|
}
|
|
public PlatformResult noteConfirm(OrderRefundNoteListDto orderRefundNoteListDto,OrdersTotal ordersTotal,RefundRecord refundRecord
|
,StringBuilder orderNodeBuilder) {
|
logger.info("退款单确认打印参数CRM：{}",JSON.toJSONString(orderRefundNoteListDto));
|
Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundNoteListDto.getOperationId());//获取操作人信息
|
String operatorId= operator.get("operatorId");
|
String operatorName= operator.get("operatorName");
|
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
|
|
List<OrderRefundNoteDto> orderRefundNoteDtos=orderRefundNoteListDto.getOrderRefundNoteDtos();
|
if("crm".equals(ordersTotal.getAppIdCode())){
|
//CRM退款
|
handleCrmRefundOrder(orderRefundNoteDtos,ordersTotal,refundRecord,operatorId,operatorName,orderNodeBuilder);
|
}else {
|
sqlSentence.sqlSentence(" refundroute=#{m.refundroute},refundNumberNo=#{m.refundNumberNo},refundName=#{m.refundName}, " +
|
" refundStoredTotal=#{m.refundStoredTotal},refundStatus=#{m.refundStatus},remarks=#{m.remarks},shopId=#{m.shopId}, " +
|
" shopName=#{m.shopName},operationName=#{m.operationName},operationId=#{m.operationId} where id=#{m.id} ",map);
|
|
map.put("shopId",ordersTotal.getShopId());
|
map.put("shopName",ordersTotal.getShopName());
|
map.put("operationName",operatorName);
|
map.put("operationId",operatorId);
|
map.put("refundStatus",RefundNote.STATUS_SUCCESS);
|
for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
|
map.put("refundroute",orderRefundNoteDto.getRefundroute());
|
map.put("refundNumberNo",orderRefundNoteDto.getRefundNumberNo());
|
map.put("refundName",orderRefundNoteDto.getRefundName());
|
map.put("refundStoredTotal",orderRefundNoteDto.getRefundStoredTotal());
|
map.put("remarks",orderRefundNoteDto.getRemarks());
|
map.put("id",orderRefundNoteDto.getId());
|
refundNoteMapper.updateWhere(sqlSentence);
|
|
if (!StringUtils.isEmpty(orderRefundNoteDto.getImageList())){
|
String [] imageList= orderRefundNoteDto.getImageList().split(",");
|
for (String s : imageList) {
|
RefundNoteItems refundNoteItems=new RefundNoteItems();
|
refundNoteItems.setRefundNoteId(orderRefundNoteDto.getId());
|
refundNoteItems.setImgUrl(s);
|
refundNoteItemsMapper.insert(refundNoteItems);
|
}
|
}
|
}
|
}
|
|
|
//记录操作日志
|
StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",已支付订单现金支付退款:");
|
OrderLog orderLog=new OrderLog(ordersTotal.getId(),OrderLogConstants.LOG_TYPE_CANCEL_ORDER,stringBuffer.toString()
|
,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
|
commonService.insert(OrderLogMapper.class,orderLog);
|
|
return PlatformResult.success();
|
}
|
/**处理crm退款*/
|
public void handleCrmRefundOrder(List<OrderRefundNoteDto> orderRefundNoteDtos,OrdersTotal ordersTotal,RefundRecord refundRecord
|
,String operatorId, String operatorName,StringBuilder orderNodeBuilder){
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
|
//待确认
|
BigDecimal crmAmount = orderRefundNoteDtos.stream().filter(item->RefundNote.ORIGINAL_ROAD.equals(item.getRefundroute())).map(o->o.getPaymentTotal())
|
.reduce(BigDecimal.ZERO,BigDecimal::add);
|
List<RefundAmountModelDto> amountModelList=new ArrayList<>();
|
RefundAmountModelDto refundAmountModelDto;
|
for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
|
if(RefundNote.ORIGINAL_ROAD.equals(orderRefundNoteDto.getRefundroute())){
|
refundAmountModelDto=new RefundAmountModelDto();
|
refundAmountModelDto.setRefundType(PayMethodTypeConstants.PAY_CRM_WX.equals(orderRefundNoteDto.getPaymentNumberNo()) ?0:1);
|
refundAmountModelDto.setAmountTotal(orderRefundNoteDto.getPaymentTotal());
|
amountModelList.add(refundAmountModelDto);
|
}
|
|
}
|
logger.info("退款金额：{}",crmAmount);
|
if(1==crmAmount.compareTo(BigDecimal.ZERO)){
|
RefundDto refundDto=new RefundDto();
|
refundDto.setRefundOrderType(0);
|
refundDto.setOrderId(ordersTotal.getId());
|
refundDto.setRefundType(0);
|
refundDto.setRefundAmountTotal(crmAmount);
|
refundDto.setRefundRecharge(new BigDecimal(0));
|
refundDto.setRefundIncrement(new BigDecimal(0));
|
refundDto.setRefundIntegral(new BigDecimal(0));
|
refundDto.setIsWholeOrder(0);
|
refundDto.setRemarks("phis退款单退款,订单号："+ordersTotal.getOrderNo());
|
refundDto.setAmountModelList(amountModelList);
|
logger.info("调用crm退款入参：{}",JSONObject.toJSONString(refundDto));
|
Result result= fOderService.refundOrder(refundDto);;
|
logger.info("调用crm退款返回：{}",JSONObject.toJSONString(result));
|
if (result != null) {
|
result.checkTips();
|
if("100".equals(result.getCode())){
|
RefundReturnDto refundReturnDto=JSON.parseObject(JSONObject.toJSONString(result.getData()),RefundReturnDto.class);
|
if (RefundReturnDto.REFUND_STATUS_SUECCESS == refundReturnDto.getRefundStatus()){
|
orderNodeBuilder.append("-调用CRM退款金额："+crmAmount+",返回成功返回流水号："+refundReturnDto.getRefundNo()+",json："+result);
|
logger.info("crm退款成功进行下面操作");
|
}else {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,退款失败!退款状态不是成功状态");
|
}
|
//生成CRM回执记录
|
createCrmRefundReceipt(refundReturnDto,refundRecord,commonService);
|
}else{
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,接口返回错误!:code不是100");
|
}
|
} else {
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"请求crm退款接口报错,返回为空!");
|
}
|
|
}
|
logger.info("订单状态为：{}",ordersTotal.getRefundStatus());
|
|
sqlSentence.sqlSentence(" refundroute=#{m.refundroute},refundNumberNo=#{m.refundNumberNo},refundName=#{m.refundName}, " +
|
" refundStoredTotal=#{m.refundStoredTotal},refundStatus=#{m.refundStatus},remarks=#{m.remarks},shopId=#{m.shopId}, " +
|
" shopName=#{m.shopName},operationName=#{m.operationName},operationId=#{m.operationId} where id=#{m.id} ",map);
|
|
map.put("shopId",ordersTotal.getShopId());
|
map.put("shopName",ordersTotal.getShopName());
|
map.put("operationName",operatorName);
|
map.put("operationId",operatorId);
|
map.put("refundStatus",RefundNote.STATUS_SUCCESS);
|
for (OrderRefundNoteDto orderRefundNoteDto : orderRefundNoteDtos) {
|
map.put("refundroute",orderRefundNoteDto.getRefundroute());
|
map.put("refundNumberNo",orderRefundNoteDto.getRefundNumberNo());
|
map.put("refundName",orderRefundNoteDto.getRefundName());
|
map.put("refundStoredTotal",orderRefundNoteDto.getRefundStoredTotal());
|
map.put("remarks",orderRefundNoteDto.getRemarks());
|
map.put("id",orderRefundNoteDto.getId());
|
refundNoteMapper.updateWhere(sqlSentence);
|
|
if (!StringUtils.isEmpty(orderRefundNoteDto.getImageList())){
|
String [] imageList= orderRefundNoteDto.getImageList().split(",");
|
for (String s : imageList) {
|
RefundNoteItems refundNoteItems=new RefundNoteItems();
|
refundNoteItems.setRefundNoteId(orderRefundNoteDto.getId());
|
refundNoteItems.setImgUrl(s);
|
refundNoteItemsMapper.insert(refundNoteItems);
|
}
|
}
|
}
|
|
//退款成功发送企业微信给订单开单人
|
JSONObject object = new JSONObject();
|
object.put("abnormal","订单退款成功，现金支付资产已退回！");
|
object.put("orderNo",ordersTotal.getOrderNo());
|
User user=commonService.selectOneByKeyBlob(UserMapper.class,ordersTotal.getUserId());
|
object.put("userName",user==null?"":user.getName());
|
object.put("notificationSubject", NotificationLog.NOTIFICATION_SUBJECT_REFUND_NOTE_PHISKIN_SUC_NOTICE);
|
SendNoticeUtil.successOrderSendNotice(commonService, customParameter, ordersTotal,object);
|
|
}
|
|
/**
|
* 生成CRM退款回执
|
* @param refundReturnDto crm退款返回总结构
|
* @param refundRecord 退款总单
|
* @param commonService 映射
|
*/
|
public static void createCrmRefundReceipt(RefundReturnDto refundReturnDto,RefundRecord refundRecord,CommonService commonService){
|
try{
|
if (RefundReturnDto.REFUND_STATUS_SUECCESS==refundReturnDto.getRefundStatus()
|
||RefundReturnDto.REFUND_STATUS_PART==refundReturnDto.getRefundStatus()){
|
StringBuilder crmReturnData = new StringBuilder();
|
crmReturnData.append("<p>【CRM退款】</p>");
|
crmReturnData.append("<p>CRM退款流水号：").append(refundReturnDto.getRefundNo()).append("</p>");
|
crmReturnData.append("<p>已退款总金额:");
|
crmReturnData.append(refundReturnDto.getRefundTotal());
|
crmReturnData.append("；");
|
crmReturnData.append("已退款其他金额:");
|
crmReturnData.append(refundReturnDto.getRefundAmountTotal());
|
crmReturnData.append("；");
|
crmReturnData.append("已退款储值金:");
|
crmReturnData.append(refundReturnDto.getRefundRecharge());
|
crmReturnData.append("；");
|
crmReturnData.append("已退款增值金:");
|
crmReturnData.append(refundReturnDto.getRefundIncrement());
|
crmReturnData.append("；");
|
crmReturnData.append("已退款积分:");
|
crmReturnData.append(refundReturnDto.getRefundIntegral());
|
crmReturnData.append("</p>");
|
crmReturnData.append("<p>退款方式:</p>");
|
if(refundReturnDto.getRefundAmountModelDtoList() != null && refundReturnDto.getRefundAmountModelDtoList().size() > 0){
|
for(RefundAmountModelDto refundAmountModelDto1:refundReturnDto.getRefundAmountModelDtoList()){
|
crmReturnData.append("<p>");
|
switch (refundAmountModelDto1.getRefundType()){
|
case RefundAmountModelDto.REFUND_TYPE_WX:
|
crmReturnData.append("微信[CRM]:").append(refundAmountModelDto1.getAmountTotal());
|
break;
|
case RefundAmountModelDto.REFUND_TYPE_ZFB:
|
crmReturnData.append("支付宝[CRM]:").append(refundAmountModelDto1.getAmountTotal());
|
break;
|
default:
|
crmReturnData.append("[").append(refundAmountModelDto1.getRefundType()).append("]");
|
crmReturnData.append("未知方式[CRM]：").append(refundAmountModelDto1.getAmountTotal());
|
}
|
crmReturnData.append("</p>");
|
}
|
}
|
RefundRecordReceipt refundRecordReceipt = new RefundRecordReceipt();
|
refundRecordReceipt.setReceiptSource(RefundRecordReceipt.RECEIPT_SOURCE_CRM);
|
refundRecordReceipt.setReceiptSourceNo(refundReturnDto.getRefundNo());
|
refundRecordReceipt.setReceiptSourceData(JSON.toJSONString(refundReturnDto));
|
refundRecordReceipt.setReceiptType(RefundRecordReceipt.RECEIPT_TYPE_REFUND);
|
refundRecordReceipt.setRemarks(crmReturnData.toString());
|
refundRecordReceipt.setOperatorId(refundRecord.getOperatorId());
|
refundRecordReceipt.setOperatorNo(refundRecord.getOperatorNo());
|
refundRecordReceipt.setOperatorName(refundRecord.getOperatorName());
|
refundRecordReceipt.setRefundRecordId(refundRecord.getId());
|
commonService.insert(RefundRecordReceiptMapper.class,refundRecordReceipt);
|
}
|
}catch (Exception e){
|
logger.error("退款生成CRM回执报错:{}",e);
|
}
|
}
|
|
/**
|
* 营销中心回调审批处理接口
|
* @param aduitDto
|
* @return
|
*/
|
@Override
|
public PlatformResult partRefundApproval(AduitDto aduitDto) {
|
logger.info("营销中心审批退款入参：{}",JSON.toJSONString(aduitDto));
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
map.put("applyId",aduitDto.getApplyId());
|
sqlSentence.sqlSentence("SELECT * FROM cancel_order WHERE applyId=#{m.applyId} and isDel=0 ",map);
|
CancelOrder cancelOrder=commonService.selectOne(CancelOrderMapper.class,sqlSentence);
|
if( cancelOrder == null ){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该审核标识");
|
}
|
if(!CancelOrder.PENDING.equals(cancelOrder.getApprovalstatus())){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"该条审核标识已经处理过了，不要重复提交");
|
}
|
|
Map<String, String> operator=new HashMap<>();
|
operator.put("operatorId",cancelOrder.getOperatorId());
|
operator.put("operatorName",cancelOrder.getOperatorName());
|
|
//先判断项目的状态是否存在
|
OrdersTotal ordersTotal= ordersTotalMapper.selectOneByKey(cancelOrder.getOrderId());
|
if(ordersTotal==null){
|
logger.info("取消订单流程:未找到总订单信息！订单id：{}",cancelOrder.getOrderId());
|
return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:未找到总订单信息！");
|
}
|
|
cancelOrder.setExamEmplId(aduitDto.getExamEmplId());
|
cancelOrder.setExamEmplName(aduitDto.getExamEmplName());
|
|
//获取退款记录
|
RefundRecord refundRecord = commonService.selectOneByKey(RefundRecordMapper.class,cancelOrder.getRefundRecordId());
|
if(refundRecord==null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"未找到该审核的退款记录");
|
}
|
|
//订单节点日志
|
OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
|
StringBuilder orderNodeBuilder = new StringBuilder();
|
|
if(BaseEntity.NO.equals(aduitDto.getType())){
|
|
orderNodeBuilder.append("审核不通过");
|
orderNodeBuilder.append("-最后审核人：").append(aduitDto.getExamEmplName());
|
|
//审核不通过
|
cancelOrder.setApprovalstatus(CancelOrder.FAIL);
|
cancelOrder.setEditTime(new Date());
|
commonService.updateAll(CancelOrderMapper.class,cancelOrder);
|
|
//更改总订单退款状态
|
map.put("orderId",ordersTotal.getId());
|
sqlSentence.sqlSentence("select * from order_item WHERE orderId=#{m.orderId} and isDel=0",map);
|
List<OrderItem> orderItemList=commonService.selectList(OrderItemMapper.class,sqlSentence);
|
|
List<Integer> collect = orderItemList.stream().map(o -> o.getRefundStatus()).collect(Collectors.toList());
|
if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)
|
&& collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
|
}else {
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
}
|
|
map.put("refundStatus",ordersTotal.getRefundStatus());
|
map.put("id",ordersTotal.getId());
|
sqlSentence.sqlSentence(" refundStatus=#{m.refundStatus} WHERE id=#{m.id} ",map);
|
ordersTotalMapper.updateWhere(sqlSentence);
|
|
refundRecord.setRefundStatus(RefundStatus.STATUS_INVALID_REFUND);
|
refundRecord.setEditTime(new Date());
|
commonService.updateAll(RefundRecordMapper.class,refundRecord);
|
|
//处理老带新的佣金，没有退款才退
|
if(ordersTotal.getRefundStatus() == OrderTotalConstants.STATUS_REFUND_NONE){
|
oldBlingNewRefundFail(refundRecord,orderNodeBuilder,commonService);
|
}
|
|
//拒绝审批需要还原回去储值金
|
//判断是否是充值订单，是的话需要把前面预扣的还原
|
if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
|
//判断金额不等于0，才执行操作，不然操作余额的时候会爆操作数量或金额不能为0
|
if(ordersTotal.getActualTotal().compareTo(BigDecimal.ZERO)!=0){
|
|
UserMoneyUtil.setNewUserMoneyUnclaimed(refundRecord.getUserId(),refundRecord.getRemarks(),"充值单："+ordersTotal.getOrderNo()+" 申请退款，拒绝审批，返还预扣除金额:"+ordersTotal.getTotal(),operator.get("operatorId"),refundRecord.getOrderId(),ordersTotal.getAppIdCode(),refundRecord.getId(),new BigDecimal(String.valueOf(ordersTotal.getTotal())), UserMoneyUnclaimed.FUND_TYPE_STORED_VALUE_FUND, OperationReasonConstants.OP_REASON_RECHARGE_REFUND,commonService,UserMoneyUnclaimed.NO);
|
OrderLog orderLog = RefundToolUtil.setOrderLog(refundRecord, operator.get("operatorId"), operator.get("operatorName"), "充值单："+ordersTotal.getOrderNo()+"申请退款，预扣除金额："+ordersTotal.getTotal(), 0, OrderLogConstants.LOG_TYPE_REFUND);
|
commonService.insert(OrderLogMapper.class,orderLog);
|
//活动规则退款处理
|
map.put("orderId", ordersTotal.getId());
|
sqlSentence.sqlSentence("select * from orders_info where isDel=0 and orderId=#{m.orderId}",map);
|
OrderInfo orderInfo=commonService.selectOne(OrderInfoMapper.class,sqlSentence);
|
handActivityRule(commonService, operator.get("operatorId"), operator.get("operatorName"), sqlSentence, map, refundRecord,ordersTotal,orderInfo,1);
|
}
|
}
|
|
ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
|
ordersNodeLog.setContent(orderNodeBuilder.toString());
|
ordersNodeLog.setOrderId(ordersTotal.getId());
|
commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);
|
|
|
return PlatformResult.success("拒绝取消审核通过");
|
}
|
|
cancelOrder.setEditTime(new Date());
|
cancelOrder.setApprovalstatus(CancelOrder.SUCCESS);
|
commonService.updateAll(CancelOrderMapper.class,cancelOrder);
|
|
orderNodeBuilder.append("审核通过，开始处理退款");
|
|
|
Map<String, Object>refund =handleRefundOrder(operator,refundRecord,ordersTotal,ordersNodeLog,orderNodeBuilder,cancelOrder);
|
return PlatformResult.success(refund);
|
}
|
|
|
/**
|
* 全部退款处理退款逻辑
|
* @param orderRefundDto
|
* @return
|
*/
|
@Override
|
public PlatformResult wholeRefund(OrderRefundDto orderRefundDto,ThirtApplication thirtApplication) {
|
|
OrdersTotal ordersTotal = ordersTotalMapper.selectOneByKey(orderRefundDto.getOrderId());
|
|
//获取该笔订单的项目详情
|
List<Map<String, Object>> refundDetails=refundDetails(ordersTotal);
|
|
// 退款信息集合
|
List<OrderItemRefundDto> refundList=new ArrayList<>();
|
//退款二级子订单信息集合
|
List<OrderItemSourceRefundDto> orderItemSourceRefundDtos;
|
List<Map<String, Object>> refundSonDetails;
|
|
OrderItemRefundDto orderItemRefundDto;
|
OrderItemSourceRefundDto orderItemSourceRefundDto;
|
for (Map<String, Object> refundDetail : refundDetails) {
|
orderItemRefundDto = new OrderItemRefundDto();
|
orderItemRefundDto.setOrderItemId(String.valueOf(refundDetail.get("id")));
|
orderItemRefundDto.setType(String.valueOf(refundDetail.get("type")));
|
|
////退款备注
|
orderItemRefundDto.setRemarks(orderRefundDto.getRemarks());
|
orderItemRefundDto.setRefundReason(orderRefundDto.getRefundReason());
|
|
if(OrderItemConstants.TYPE_PROMOTION.equals(orderItemRefundDto.getType())
|
|| OrderItemConstants.CARD_BAG.equals(orderItemRefundDto.getType())){
|
orderItemRefundDto.setRefundNum(0);
|
refundSonDetails= (List<Map<String, Object>>) refundDetail.get("list");
|
orderItemSourceRefundDtos=new ArrayList<>();
|
for (Map<String, Object> refundSonDetail : refundSonDetails) {
|
orderItemSourceRefundDto=new OrderItemSourceRefundDto();
|
orderItemSourceRefundDto.setOrderItemSonId(String.valueOf(refundSonDetail.get("id")));
|
orderItemSourceRefundDto.setType(String.valueOf(refundSonDetail.get("type")));
|
orderItemSourceRefundDto.setRefundNum(Integer.parseInt(String.valueOf(refundSonDetail.get("notUsedNum"))));
|
|
//退款备注
|
orderItemSourceRefundDto.setRemarks(orderRefundDto.getRemarks());
|
orderItemSourceRefundDto.setRefundReason(orderRefundDto.getRefundReason());
|
|
orderItemSourceRefundDtos.add(orderItemSourceRefundDto);
|
}
|
orderItemRefundDto.setOrderItemSourceRefundDtos(orderItemSourceRefundDtos);
|
}else {
|
orderItemRefundDto.setRefundNum(Integer.parseInt(refundDetail.get("notUsedNum").toString()) );
|
}
|
refundList.add(orderItemRefundDto);
|
}
|
orderRefundDto.setRefundList(refundList);
|
|
//获取退款资金信息
|
OrderRefundDto parameter= nextStep(ordersTotal,orderRefundDto);
|
|
parameter.setOperatorId(orderRefundDto.getOperatorId());
|
parameter.setIsRefund(orderRefundDto.getIsRefund());
|
parameter.setIsApproval(orderRefundDto.getIsApproval());
|
parameter.setRoleId(orderRefundDto.getRoleId());
|
parameter.setPlatformSource(orderRefundDto.getPlatformSource());
|
parameter.setRefundOperationType(BaseEntity.NO);
|
parameter.setRemarks(orderRefundDto.getRemarks());
|
parameter.setRefundReason(orderRefundDto.getRefundReason());
|
parameter.setCouponList(parameter.getPayCouponList());
|
|
//退款金额
|
List<OrderPayMethodDto> refundPayMethodList = parameter.getPayMethodList();
|
for(OrderPayMethodDto orderPayMethodDto:refundPayMethodList){
|
orderPayMethodDto.setRefundNumberNo(orderPayMethodDto.getPayMethodNo());
|
orderPayMethodDto.setRefundNumberName(orderPayMethodDto.getPayMethodName());
|
orderPayMethodDto.setMoney(orderPayMethodDto.getPayTotal());
|
}
|
|
parameter.setRefundPayMethod(refundPayMethodList);
|
|
//调用退款处理退款逻辑
|
return partRefund(ordersTotal,parameter,thirtApplication);
|
}
|
|
/**
|
* 伪造退款处理退款逻辑
|
* @param orderRefundDto
|
* @return
|
*/
|
@Override
|
public PlatformResult forgePartRefund(OrderRefundDto orderRefundDto) {
|
logger.info("退款打印参数：{}", JSON.toJSONString(orderRefundDto));
|
//先判断项目的状态是否存在
|
OrdersTotal ordersTotal=null;
|
try {
|
ordersTotal=ordersTotalMapper.selectOneByKey(orderRefundDto.getOrderId());
|
if(ordersTotal==null){
|
logger.info("取消订单流程:未找到总订单信息！订单id：{}",orderRefundDto.getOrderId());
|
return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:未找到总订单信息！");
|
}
|
}catch (Exception e){
|
logger.info("取消订单流程:根据订单id查询多条总订单信息！订单id：{}",orderRefundDto.getOrderId());
|
return PlatformResult.failure(PlatformCode.ERROR_TIPS,"取消订单流程:根据订单id查询多条总订单信息！");
|
}
|
|
if(!(OrderTotalConstants.STATUS_REFUND_NONE==ordersTotal.getRefundStatus()) &&
|
!(OrderTotalConstants.STATUS_REFUND_PART==ordersTotal.getRefundStatus())){
|
throw new TipsException("订单标识错误,订单退款状态不正确!");
|
}
|
|
// orderRefundDto=parameterVerification(orderRefundDto);
|
|
return handleforgePartRefund(ordersTotal,orderRefundDto);
|
|
}
|
|
|
|
/**
|
* 伪造处理退款详情
|
*/
|
public PlatformResult handleforgePartRefund(OrdersTotal ordersTotal,OrderRefundDto orderRefundDto){
|
|
//订单节点日志
|
OrdersNodeLog ordersNodeLog = new OrdersNodeLog();
|
StringBuilder orderNodeBuilder = new StringBuilder();
|
|
orderNodeBuilder.append("开始退款(WZ)");
|
|
// 获取退款方式，退款项目，退款优惠卷
|
List<OrderPayMethodDto> refundPayMethod=orderRefundDto.getRefundPayMethod();
|
List<OrderItemRefundDto> refundList=orderRefundDto.getRefundList();
|
List<OrderCouponRefunDto> couponList=orderRefundDto.getCouponList();
|
|
//客户选的退款方式总金额
|
BigDecimal sumMoney=refundPayMethod.stream().map(OrderPayMethodDto::getMoney).reduce(BigDecimal.ZERO,BigDecimal::add);
|
//本次退款总金额
|
BigDecimal refundSumMoney=refundList.stream().map(OrderItemRefundDto::getRefundMoney).reduce(BigDecimal.ZERO,BigDecimal::add);
|
|
if(!OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
|
if(sumMoney.compareTo(refundSumMoney)==1){
|
throw new TipsException("退款金额不能大于可退金额!");
|
}
|
orderNodeBuilder.append("-本次退款项目总金额："+refundSumMoney+",客户选的退款方式总金额："+sumMoney);
|
}else {
|
orderNodeBuilder.append("-本次退款项目总金额："+ordersTotal.getActualTotal()+",客户选的退款方式总金额："+sumMoney);
|
}
|
|
Map<String, String> operator = ApiOrderUtil.getOperator(commonService, orderRefundDto.getOperatorId());//获取操作人信息
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> map=new HashMap<>();
|
sqlSentence.setM(map);
|
|
//退款总记录
|
orderNodeBuilder.append("-处理退款总记录");
|
String totalCode = CreateNo.createTimeNo(systemParameterMapper, "R", 8, "yyyyMMddHHmmss");//总订单编号
|
RefundRecord refundRecord=new RefundRecord(totalCode,ordersTotal.getShopId(),ordersTotal.getShopName(),sumMoney, RefundStatus.STATUS_APPLY_REFUND,0, RefundSoruceConstants.TYPE_SOURCE_ORDER,"phis退款",ordersTotal.getId(),ordersTotal.getUserId());
|
refundRecord.setOperatorType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
|
Employee employee = commonService.selectOneByKey(EmployeeMapper.class,orderRefundDto.getOperatorId());
|
refundRecord.setOperatorId(employee.getId());
|
refundRecord.setRefundOperationType(orderRefundDto.getRefundOperationType());
|
refundRecord.setOperatorName(employee.getCnName());
|
refundRecordService.insert(refundRecord);
|
|
if(refundPayMethod!=null && refundPayMethod.size()>0){
|
//处理退款方式记录表
|
handleRefundPayMethod(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord);
|
}
|
if(refundList!=null && refundList.size()>0){
|
//记录本次退款的项目详情
|
//分摊比例
|
//因为优惠卷抵扣金额可能超过订单的金额，所以不会有支付记录
|
BigDecimal percentage;
|
if(sumMoney.compareTo(BigDecimal.ZERO)==0){
|
percentage=new BigDecimal(1);
|
}else {
|
percentage=sumMoney.divide(refundSumMoney,10,BigDecimal.ROUND_HALF_UP);
|
}
|
|
//handleRefundRecordItem(orderRefundDto,orderNodeBuilder,ordersTotal,refundRecord,percentage);
|
}
|
if(couponList!=null && couponList.size()>0){
|
//处理优惠卷
|
handleOrderCouponRefunDto(couponList,orderNodeBuilder,ordersTotal,refundRecord);
|
}
|
try{
|
orderNodeBuilder.append("-开始记录收入确认表");
|
PerformanceInfoTool.handRefundPerformanceInfo(commonService,refundRecord);
|
orderNodeBuilder.append("-记录收入确认表成功");
|
}catch (Exception e){
|
orderNodeBuilder.append("-记录收入确认表失败");
|
logger.info("记录收入确认表,异常:{}",e.getMessage(),e);
|
// 添加错误日志
|
PerformanceInfoTool.addErrorLog(commonService, refundRecord.getId(), PerformanceInfo.ASSOCIATION_TYPE_GOODS_REFUND, e.getMessage());
|
}
|
//记录操作日志
|
orderNodeBuilder.append("-记录操作日志");
|
StringBuffer stringBuffer=new StringBuffer("操作人:"+operator.get("operatorName")+",进行退款(WZ)");
|
OrderLog orderLog=new OrderLog(ordersTotal.getId(), OrderLogConstants.LOG_TYPE_REFUND,stringBuffer.toString()
|
,operator.get("operatorName"),operator.get("operatorId"),OrderTotalConstants.STATUS_CANCEL);
|
commonService.insert(OrderLogMapper.class,orderLog);
|
|
orderNodeBuilder.append("-结束处理退款");
|
ordersNodeLog.setCommonType(OrdersNodeLog.TYPE_COMMON_ORDER_REFUND);
|
ordersNodeLog.setContent(orderNodeBuilder.toString());
|
ordersNodeLog.setOrderId(ordersTotal.getId());
|
commonService.insert(OrdersNodeLogMapper.class,ordersNodeLog);
|
|
return PlatformResult.success("成功");
|
}
|
|
/**
|
* 根据订单 重新绑定订单退款状态
|
*
|
*/
|
@Override
|
public void verifyOrderRefundStatus(OrdersTotal ordersTotalDto) {
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String, Object> sqlMap = new HashMap<>();
|
sqlSentence.setM(sqlMap);
|
sqlMap.put("isDel", BaseEntity.NO);
|
sqlMap.put("orderId", ordersTotalDto.getId());
|
sqlMap.put("type", OrderItemConstants.TYPE_PROJECT);
|
|
sqlSentence.sqlSentence("SELECT * FROM orders_total WHERE id = #{m.orderId} and isDel = #{m.isDel} ",sqlMap);
|
OrdersTotal ordersTotal = ordersTotalMapper.selectOne(sqlSentence);
|
if(ordersTotal==null){
|
throw new TipsException("订单标识错误,找不到订单!");
|
}
|
//查询二级订单
|
sqlSentence.sqlSentence("SELECT * FROM order_item_source WHERE orderId = #{m.orderId} and type = #{m.type} and isDel = #{m.isDel} ",sqlMap);
|
List<OrderItemSon> orderItemSonList=orderItemSonMapper.selectList(sqlSentence);
|
|
|
if(orderItemSonList!=null && orderItemSonList.size()>0){
|
int oldRefundStatus;
|
int newRefundStatus;
|
UserProjectItem userProjectItem;
|
for (OrderItemSon orderItemSon : orderItemSonList) {
|
if(OrderTotalConstants.STATUS_REFUND_FINSH==orderItemSon.getRefundStatus()){
|
oldRefundStatus=OrderTotalConstants.STATUS_REFUND_FINSH;
|
|
userProjectItem = PartialRefundUtil.getUserProject(orderItemSon.getId(),commonService);
|
|
if(userProjectItem.getNotUsedNum()>0){
|
newRefundStatus=OrderTotalConstants.STATUS_REFUND_PART;
|
}else {
|
newRefundStatus=oldRefundStatus;
|
}
|
|
if(newRefundStatus!=oldRefundStatus){
|
sqlMap.put("refundStatus", newRefundStatus);
|
sqlMap.put("id", orderItemSon.getId());
|
sqlSentence.sqlSentence(" refundStatus = #{m.refundStatus} WHERE id = #{m.id} ",sqlMap);
|
orderItemSonMapper.updateWhere(sqlSentence);
|
|
sqlMap.put("refundStatus", newRefundStatus);
|
sqlMap.put("id", orderItemSon.getOrderItemId());
|
sqlSentence.sqlSentence(" refundStatus = #{m.refundStatus} WHERE id = #{m.id} ",sqlMap);
|
orderItemMapper.updateWhere(sqlSentence);
|
}
|
|
}
|
}
|
|
}
|
|
//查询二级订单
|
sqlSentence.sqlSentence("SELECT * FROM order_item WHERE orderId = #{m.orderId} and type = #{m.type} and isDel = #{m.isDel} ",sqlMap);
|
List<OrderItem> orderItemList=orderItemMapper.selectList(sqlSentence);
|
if(orderItemList!=null && orderItemList.size()>0){
|
int oldRefundStatus;
|
int newRefundStatus;
|
UserProjectItem userProjectItem;
|
for (OrderItem orderItem : orderItemList) {
|
oldRefundStatus=OrderTotalConstants.STATUS_REFUND_FINSH;
|
|
userProjectItem = PartialRefundUtil.getUserProject(orderItem.getId(),commonService);
|
|
if(userProjectItem.getNotUsedNum()>0){
|
newRefundStatus=OrderTotalConstants.STATUS_REFUND_PART;
|
}else {
|
newRefundStatus=oldRefundStatus;
|
}
|
|
if(newRefundStatus!=oldRefundStatus){
|
sqlMap.put("refundStatus", newRefundStatus);
|
sqlMap.put("id", orderItem.getId());
|
sqlSentence.sqlSentence(" refundStatus = #{m.refundStatus} WHERE id = #{m.id} ",sqlMap);
|
orderItemMapper.updateWhere(sqlSentence);
|
}
|
|
}
|
}
|
|
|
sqlMap.put("orderId",ordersTotal.getId());
|
sqlSentence.sqlSentence("select * from order_item WHERE orderId=#{m.orderId} and isDel=0",sqlMap);
|
List<OrderItem> orderItems=commonService.selectList(OrderItemMapper.class,sqlSentence);
|
|
List<Integer> collect = orderItems.stream().map(o -> o.getRefundStatus()).collect(Collectors.toList());
|
if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE) && collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_CANCEL);
|
}else {
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
}
|
ordersTotal.setEditTime(new Date());
|
commonService.updateAll(OrdersTotalMapper.class,ordersTotal);
|
}
|
|
/**作废退款*/
|
@Override
|
public void refundCancel(RefundCancelVo refundCancelVo, RefundRecord refundRecord,Employee employee,EmployeeRole employeeRole
|
, ThirtApplication thirtApplication) {
|
|
//判断退款单状态
|
if(refundRecord.getRefundStatus() != RefundStatus.STATUS_SUCC_REFUND){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，退款单状态错误！");
|
}
|
|
//获取订单信息
|
OrdersTotal ordersTotal = ordersTotalMapper.selectOneByKey(refundRecord.getOrderId());
|
if(ordersTotal == null){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，获取订单信息失败！");
|
}
|
|
SqlSentence sqlSentence = new SqlSentence();
|
Map<String,Object> values = new HashMap<>();
|
StringBuilder sql = new StringBuilder();
|
|
//填充数据，后面会用到
|
refundRecord.setInvalidType(RefundRecord.OPERATOR_TYPE_EMPLOYEE);
|
refundRecord.setInvalidRemarks(refundCancelVo.getRemarks());
|
|
//****更新退款单信息，更新完退款单再去做剩下的操作
|
values.put("refundStatus",RefundStatus.STATUS_REFUND_CANCEL);
|
values.put("refundStatusOld",RefundStatus.STATUS_SUCC_REFUND);
|
values.put("id",refundRecord.getId());
|
values.put("invalidTime",new Date());
|
values.put("invalidType",RefundRecord.OPERATOR_TYPE_EMPLOYEE);
|
values.put("invalidRemarks",refundCancelVo.getRemarks());
|
sql.append("refundStatus = #{m.refundStatus},invalidTime = #{m.invalidTime},invalidRemarks = #{m.invalidRemarks},invalidType = #{m.invalidType}");
|
|
if(employee != null){
|
refundRecord.setInvalidId(employee.getId());
|
refundRecord.setInvalidNo(employee.getEmployeeNo());
|
refundRecord.setInvalidName(employee.getCnName());
|
values.put("invalidId",employee.getId());
|
values.put("invalidNo",employee.getEmployeeNo());
|
values.put("invalidName",employee.getCnName());
|
sql.append(",invalidId = #{m.invalidId},invalidNo = #{m.invalidNo},invalidName = #{m.invalidName}");
|
}
|
if(employeeRole != null){
|
refundRecord.setInvalidRoleNo(employeeRole.getRoleUniqueStr());
|
refundRecord.setInvalidRoleName(employeeRole.getRoleName());
|
values.put("invalidRoleNo",employeeRole.getRoleUniqueStr());
|
values.put("invalidRoleName",employeeRole.getRoleName());
|
sql.append(",invalidRoleNo = #{m.invalidRoleNo},invalidRoleName = #{m.invalidRoleName}");
|
}
|
if(thirtApplication != null){
|
refundRecord.setInvalidAppId(thirtApplication.getAppId());
|
refundRecord.setInvalidAppCode(thirtApplication.getAppIdCode());
|
refundRecord.setInvalidAppName(thirtApplication.getName());
|
values.put("invalidAppId",thirtApplication.getAppId());
|
values.put("invalidAppCode",thirtApplication.getAppIdCode());
|
values.put("invalidAppName",thirtApplication.getName());
|
sql.append(",invalidAppId = #{m.invalidAppId},invalidAppCode = #{m.invalidAppCode},invalidAppName = #{m.invalidAppName}");
|
}
|
sql.append(" WHERE id = #{m.id} AND refundStatus = #{m.refundStatusOld}");
|
sqlSentence.sqlUpdate(sql.toString(),values);
|
if(refundRecordMapper.updateWhere(sqlSentence) != 1){
|
throw new PlatTipsException(PlatformCode.ERROR_TIPS,"操作失败，退款单状态已发生变化！");
|
}
|
|
//判断订单类型
|
if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
|
//充值订单
|
OrderRefundCancelTool.rechargeHandle(ordersTotal,refundRecord,1,commonService);
|
}else{
|
//处理子单
|
OrderRefundCancelTool.refundRecordItemHandle(ordersTotal,refundRecord,commonService);
|
}
|
|
//处理订单活动
|
OrderRefundCancelTool.activityRuleHandle(ordersTotal,refundRecord,1,commonService);
|
//处理订单优惠券
|
OrderRefundCancelTool.handCoupon(ordersTotal,refundRecord,commonService);
|
//退款子单操作
|
OrderRefundCancelTool.refundRecordMotnedHandle(refundRecord,ordersTotal,commonService);
|
|
//****更改总订单退款状态
|
values.clear();
|
values.put("orderId",ordersTotal.getId());
|
sqlSentence.sqlSentence("select * from order_item WHERE orderId=#{m.orderId} and isDel=0",values);
|
List<OrderItem> orderItemList=commonService.selectList(OrderItemMapper.class,sqlSentence);
|
|
values.clear();
|
values.put("oldStatus",ordersTotal.getStatus());
|
values.put("oldRefundStatus",ordersTotal.getRefundStatus());
|
|
List<Integer> collect = orderItemList.stream().map(OrderItem::getRefundStatus).collect(Collectors.toList());
|
if(collect.contains(OrderTotalConstants.STATUS_REFUND_PART)){
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE) && collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_NONE)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setReTotal(BigDecimal.ZERO);
|
}else if (collect.contains(OrderTotalConstants.STATUS_REFUND_FINSH)){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_FINSH);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_CANCEL);
|
ordersTotal.setReTotal(orderItemList.stream().map(OrderItem::getReTotal).reduce(BigDecimal.ZERO,BigDecimal::add));
|
}else {
|
if(OrderTotalConstants.TYPE_RECHARGE.equals(ordersTotal.getType())){
|
if(ordersTotal.getReTotal().compareTo(refundRecord.getRefundTotal()) == 0){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
|
}else if(ordersTotal.getReTotal().compareTo(refundRecord.getRefundTotal()) > 0){
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_PART);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
|
}
|
}else{
|
ordersTotal.setRefundStatus(OrderTotalConstants.STATUS_REFUND_NONE);
|
ordersTotal.setStatus(OrderTotalConstants.STATUS_PAY);
|
ordersTotal.setReTotal(ordersTotal.getReTotal().subtract(refundRecord.getRefundTotal()));
|
}
|
}
|
ordersTotal.setIsSyncOrder(BaseEntity.NO);
|
|
values.put("isSyncOrder",BaseEntity.NO);
|
values.put("status",ordersTotal.getStatus());
|
values.put("refundStatus",ordersTotal.getRefundStatus());
|
values.put("reTotal",ordersTotal.getReTotal());
|
values.put("id",ordersTotal.getId());
|
sqlSentence.sqlUpdate("isSyncOrder = #{m.isSyncOrder},status = #{m.status},refundStatus = #{m.refundStatus},reTotal = #{m.reTotal}" +
|
" WHERE id = #{m.id} AND status = #{m.oldStatus} AND refundStatus = #{m.oldRefundStatus}",values);
|
if(commonService.updateWhere(OrdersTotalMapper.class,sqlSentence) != 1){
|
throw new TipsException("作废失败，订单状态已发生改变！");
|
}
|
|
}
|
|
}
|
