package com.ruoyi.order.service.impl;
|
|
|
import com.alibaba.fastjson2.JSON;
|
|
import com.alibaba.fastjson2.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.account.api.feignClient.*;
|
import com.ruoyi.account.api.model.*;
|
|
import com.ruoyi.common.core.constant.ExpressCompanyMap;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.core.exception.ServiceException;
|
|
import com.ruoyi.common.core.utils.StringUtils;
|
import com.ruoyi.common.core.utils.bean.BeanUtils;
|
import com.ruoyi.common.core.utils.uuid.QRCodeGenerator;
|
import com.ruoyi.common.core.web.page.PageInfo;
|
import com.ruoyi.common.security.service.TokenService;
|
import com.ruoyi.order.enums.OrderStatus;
|
|
import com.ruoyi.order.mapper.OrderGoodMapper;
|
import com.ruoyi.order.mapper.OrderMapper;
|
import com.ruoyi.order.model.Order;
|
import com.ruoyi.order.model.OrderGood;
|
import com.ruoyi.order.service.OrderGoodService;
|
import com.ruoyi.order.service.OrderService;
|
|
import com.ruoyi.order.util.payment.PaymentUtil;
|
import com.ruoyi.order.util.payment.model.*;
|
|
import com.ruoyi.order.vo.*;
|
import com.ruoyi.other.api.domain.*;
|
import com.ruoyi.other.api.feignClient.*;
|
import com.ruoyi.other.api.vo.GetSeckillActivityInfo;
|
import com.ruoyi.system.api.domain.SysConfig;
|
import com.ruoyi.system.api.domain.SysUser;
|
import com.ruoyi.system.api.feignClient.SysConfigClient;
|
import com.ruoyi.system.api.feignClient.SysUserClient;
|
import com.ruoyi.system.api.model.LoginUser;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.context.ApplicationEventPublisher;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
|
import java.text.SimpleDateFormat;
|
import java.time.*;
|
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
|
import java.util.function.Function;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 服务实现类
|
* </p>
|
*
|
* @author luodangjia
|
* @since 2024-11-21
|
*/
|
@Slf4j
|
@Service
|
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements OrderService {
|
@Resource
|
private OrderMapper orderMapper;
|
@Resource
|
private OrderGoodMapper orderGoodMapper;
|
@Resource
|
private AppUserClient appUserClient;
|
@Resource
|
private TokenService tokenService;
|
@Resource
|
private ShopClient shopClient;
|
@Resource
|
private BaseSettingClient baseSettingClient;
|
|
@Resource
|
private SysUserClient sysUserClient;
|
|
@Resource
|
private GoodsClient goodsClient;
|
@Resource
|
private SeckillActivityInfoClient seckillActivityInfoClient;
|
@Resource
|
private SysConfigClient sysConfigClient;
|
@Resource
|
private GoodsShopClient goodsShopClient;
|
@Resource
|
private OrderGoodService orderGoodService;
|
|
@Resource
|
private UserPointClient userPointClient;
|
|
@Resource
|
private RedisTemplate redisTemplate;
|
|
@Resource
|
private ShopBalanceStatementClient shopBalanceStatementClient;
|
|
@Resource
|
private GoodsEvaluateClient goodsEvaluateClient;
|
|
@Resource
|
private SystemConfigClient systemConfigClient;
|
|
@Resource
|
private RegionClient regionClient;
|
@Resource
|
private ApplicationEventPublisher applicationEventPublisher;
|
|
|
@Override
|
public List<OrderVO> selectOrderListByUserId(Integer status, Long userId) {
|
return orderMapper.selectOrderListByUserId(status, userId);
|
}
|
|
|
@Override
|
public OrderDetailVO getOrderDetail(Long orderId) {
|
Order order = orderMapper.selectById(orderId);
|
if (order == null) {
|
throw new ServiceException("订单不存在");
|
}
|
R<Shop> shopR = shopClient.getShopById(order.getShopId());
|
if (!R.isSuccess(shopR)) {
|
throw new ServiceException("获取门店信息失败");
|
}
|
|
// 商品
|
OrderGood orderGood = orderGoodMapper.selectOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId));
|
String goodJson = orderGood.getGoodJson();
|
Goods goods = JSONObject.parseObject(goodJson, Goods.class);
|
GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);
|
|
OrderGoodsVO orderGoodsVO = new OrderGoodsVO();
|
orderGoodsVO.setGoodsId(goods.getId());
|
orderGoodsVO.setGoodsName(goods.getName());
|
orderGoodsVO.setGoodsPic(goods.getHomePagePicture());
|
orderGoodsVO.setNum(order.getNum());
|
if (null!=goodsSeckill){
|
orderGoodsVO.setSellingPrice(goodsSeckill.getSellingPrice());
|
orderGoodsVO.setIntegral(goodsSeckill.getIntegral());
|
}else {
|
orderGoodsVO.setSellingPrice(goods.getSellingPrice());
|
orderGoodsVO.setIntegral(goods.getIntegral());
|
}
|
|
|
orderGoodsVO.setOriginalPrice(goods.getOriginalPrice());
|
|
OrderDetailVO orderDetailVO = new OrderDetailVO();
|
orderDetailVO.setOrderGoodsVO(orderGoodsVO);
|
Shop shop = shopR.getData();
|
|
orderDetailVO.setId(order.getId());
|
orderDetailVO.setOrderStatus(order.getOrderStatus());
|
orderDetailVO.setPoint(order.getPoint());//使用的积分
|
orderDetailVO.setOrderNumber(order.getOrderNumber());
|
orderDetailVO.setCreateTime(order.getCreateTime());
|
orderDetailVO.setTotalAmount(order.getTotalAmount());
|
orderDetailVO.setPointDeductionAmount(order.getPointDeductionAmount());//积分抵扣金额
|
orderDetailVO.setPaymentAmount(order.getPaymentAmount());
|
orderDetailVO.setShopName(shop.getName());
|
orderDetailVO.setShopAddress(shop.getAddress());
|
orderDetailVO.setLongitude(shop.getLongitude());
|
orderDetailVO.setLatitude(shop.getLatitude());
|
orderDetailVO.setShopId(shop.getId());
|
// 生成核销码BASE64
|
try {
|
String base64 = QRCodeGenerator.generateQRCodeBase64(String.valueOf(order.getId()), 124, 124);
|
orderDetailVO.setWriteOffCode(base64);
|
} catch (Exception e) {
|
e.printStackTrace();
|
throw new ServiceException("生成核销码失败");
|
}
|
if(3!=order.getOrderStatus()){
|
//不属于未使用的，应该有个核销\取消时间
|
orderDetailVO.setEndTime(order.getEndTime());
|
}
|
//该商品是否被用户评论
|
Long evaluateId = goodsEvaluateClient.getEvaluateIdByOrderId(order.getId()).getData();
|
orderDetailVO.setEvaluateId(evaluateId);
|
|
return orderDetailVO;
|
}
|
|
|
@Override
|
public boolean check(Order order, Integer shopId, Long userId) {
|
// 判断订单是否属于该门店
|
if (order == null) {
|
throw new ServiceException("订单不存在");
|
}
|
return order.getShopId().equals(shopId);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void writeOff(String id, Integer shopId) {
|
LoginUser loginUserApplet = tokenService.getLoginUserApplet();
|
Order order = orderMapper.selectById(id);
|
if (order == null) {
|
throw new ServiceException("订单不存在");
|
}
|
if (!order.getShopId().equals(shopId)) {
|
throw new ServiceException("该订单与当前扫码门店不一致");
|
}
|
if (order.getOrderStatus()!=3){
|
throw new ServiceException("订单已被核销过");
|
}
|
|
|
// 售后设置
|
R<BaseSetting> baseSettingR = baseSettingClient.getBaseSetting(5);
|
if (R.isError(baseSettingR)) {
|
throw new ServiceException("售后设置获取失败");
|
}
|
BaseSetting baseSetting = baseSettingR.getData();
|
if (baseSetting == null) {
|
throw new ServiceException("售后设置获取失败");
|
}
|
String content = baseSetting.getContent();
|
JSONObject jsonObject = JSONObject.parseObject(content);
|
Long days = jsonObject.getLong("days");
|
order.setOrderStatus(OrderStatus.COMPLETED.getCode());
|
order.setAfterSaleTime(LocalDateTime.now().plusDays(days));
|
order.setEndTime(LocalDateTime.now());
|
order.setCancellerAppUserId(loginUserApplet.getUserid());
|
orderMapper.updateById(order);
|
//店铺可用金额增加
|
Shop shop = shopClient.getShopById(shopId).getData();
|
shop.setCanWithdrawMoney(shop.getCanWithdrawMoney().add(order.getTotalAmount()));
|
shopClient.updateShop(shop);
|
}
|
|
|
/**
|
* 管理后台获取订单列表数据
|
*
|
* @param orderPageList
|
* @return
|
*/
|
@Override
|
public PageInfo<OrderManagePageListVO> getOrderPageList(OrderPageList orderPageList) {
|
//搜索条件，用户电话
|
if (StringUtils.isNotEmpty(orderPageList.getPhone())) {
|
List<AppUser> data = appUserClient.getAppUserByPhoneNoFilter(orderPageList.getPhone()).getData();
|
List<Long> collect = data.stream().map(AppUser::getId).collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(collect)) {
|
return new PageInfo<>();
|
}
|
|
if (null != orderPageList.getAppUserIds()) {
|
List<Long> appUserIds = orderPageList.getAppUserIds();
|
if (!containsAny(appUserIds, collect)) {
|
return new PageInfo<>();
|
}
|
appUserIds.addAll(collect);
|
orderPageList.setAppUserIds(appUserIds);
|
} else {
|
orderPageList.setAppUserIds(collect);
|
}
|
}
|
if (null != orderPageList.getAppUserIds()) {
|
orderPageList.setAppUserIds(orderPageList.getAppUserIds().stream().distinct().collect(Collectors.toList()));
|
}
|
|
|
PageInfo<OrderManagePageListVO> pageInfo = new PageInfo<>(orderPageList.getPageCurr(), orderPageList.getPageSize());
|
|
List<OrderManagePageListVO> list = this.baseMapper.getOrderPageList(pageInfo, orderPageList);
|
|
for (OrderManagePageListVO orderPageListVo : list) {
|
Long appUserId = orderPageListVo.getAppUserId();
|
AppUser appUser = appUserClient.getAppUserById(appUserId);
|
if (null != appUser) {
|
orderPageListVo.setUserName(appUser.getName());
|
orderPageListVo.setPhone(appUser.getPhone());
|
}
|
//店铺名称
|
Shop shop = shopClient.getShopById(orderPageListVo.getShopId()).getData();
|
if (null != shop) {
|
orderPageListVo.setShopName(shop.getName());
|
}
|
orderPageListVo.setIdStr(orderPageListVo.getId().toString());
|
|
}
|
return pageInfo.setRecords(list);
|
}
|
|
/**
|
* 判断 list1 是否包含 list2 中的至少一个元素
|
*
|
* @param list1 第一个列表
|
* @param list2 第二个列表
|
* @return 如果 list1 包含 list2 中的至少一个元素，返回 true；否则返回 false
|
*/
|
private boolean containsAny(List<Long> list1, List<Long> list2) {
|
// 将 list1 转换为 HashSet 以提高查询效率
|
Set<Long> set1 = new HashSet<>(list1);
|
|
// 遍历 list2，检查是否有元素存在于 set1 中
|
for (Long element : list2) {
|
if (set1.contains(element)) {
|
return true;
|
}
|
}
|
|
// 如果没有找到共同元素，返回 false
|
return false;
|
}
|
|
|
/**
|
* 小程序取消订单
|
*/
|
@Override
|
public R cancel(Long orderId) {
|
Order order = this.getById(orderId);
|
if (null == order) {
|
return R.fail("取消失败");
|
}
|
Long userid = tokenService.getLoginUserApplet().getUserid();
|
if (!order.getAppUserId().equals(userid)) {
|
return R.fail("取消失败");
|
}
|
if (!Arrays.asList(1, 2, 3).contains(order.getOrderStatus())) {
|
return R.fail("订单取消失败");
|
}
|
if (null != order.getAfterSaleTime() && LocalDateTime.now().isAfter(order.getAfterSaleTime())) {
|
return R.fail("订单取消失败");
|
}
|
order.setOrderStatus(5);
|
R r = refundPayMoney(order);
|
if (200 == r.getCode()) {
|
this.updateById(order);
|
}
|
return r;
|
}
|
|
|
|
|
/**
|
* 取消订单操作
|
*
|
* @param orderId
|
* @return
|
*/
|
@Override
|
public R cancelOrder(Long orderId) {
|
Order order = this.getById(orderId);
|
if (Arrays.asList(4,5,8).contains(order.getOrderStatus())) {
|
return R.fail("无效的操作");
|
}
|
|
order.setOrderStatus(5);
|
R r = refundPayMoney(order);
|
if (200 == r.getCode()) {
|
this.updateById(order);
|
}
|
return r;
|
}
|
|
|
/**
|
* 回退积分和返回订单支付金额
|
*/
|
public R refundPayMoney(Order order) {
|
//开始退款
|
BigDecimal paymentAmount = order.getPaymentAmount();
|
if (BigDecimal.ZERO.compareTo(order.getPaymentAmount()) < 0) {//支付的金额是否大于0
|
//微信退款
|
RefundResult refund = PaymentUtil.refund(order.getOrderNumber(), "R" + order.getOrderNumber(), paymentAmount.doubleValue(), "/order/order/refundPayMoneyCallback");
|
if (!"100".equals(refund.getRa_Status())) {
|
return R.fail(refund.getRc_CodeMsg());//退款失败
|
}
|
}
|
//退款成功再回退积分
|
AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
|
if (order.getPoint()>0) {
|
if(null==appUser.getCancelPoint()){
|
appUser.setCancelPoint(0);
|
}
|
//返回订单抵扣积分
|
Integer historicalPoint = appUser.getAvailablePoint();
|
Integer availablePoint = appUser.getAvailablePoint() + order.getPoint();//可用积分
|
Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分
|
|
appUser.setAvailablePoint(availablePoint);
|
appUser.setCancelPoint(cancelPoint);
|
appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());
|
appUserClient.editAppUserById(appUser);
|
//构建积分流水
|
UserPoint userPoint = new UserPoint();
|
userPoint.setType(16);//取消订单
|
userPoint.setHistoricalPoint(historicalPoint);
|
userPoint.setVariablePoint(order.getPoint());
|
userPoint.setBalance(availablePoint);
|
userPoint.setCreateTime(LocalDateTime.now());
|
userPoint.setAppUserId(order.getAppUserId());
|
userPoint.setObjectId(order.getId());
|
userPointClient.saveUserPoint(userPoint);
|
}
|
|
order.setRefundStatus(2);
|
order.setRefundTime(LocalDateTime.now());
|
|
//商品销售数量
|
OrderGood orderGood = orderGoodService.getOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, order.getId()));
|
goodsClient.editGoodsNum(orderGood.getGoodsId(), -1);
|
//获取商品json
|
Goods good = JSON.parseObject(orderGood.getGoodJson(), Goods.class);
|
GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);
|
|
//门店减少冻结资金 即减少余额， 冻结资金=余额-可用资金
|
Shop shop = shopClient.getShopById(order.getShopId()).getData();
|
|
BigDecimal historicalBalance=shop.getBalance();//历史余额
|
BigDecimal variableAmount=BigDecimal.ZERO;//变动金额
|
if (null != goodsSeckill) {
|
variableAmount=goodsSeckill.getSellingPrice();
|
}else {
|
variableAmount=good.getSellingPrice();
|
}
|
|
BigDecimal balance=shop.getBalance().subtract(variableAmount);//变动后余额
|
|
shop.setBalance(balance);
|
shopClient.updateShop(shop);
|
|
//门店余额流水记录
|
ShopBalanceStatement shopBalanceStatement = new ShopBalanceStatement();
|
shopBalanceStatement.setShopId(shop.getId());
|
shopBalanceStatement.setShopName(shop.getName());
|
shopBalanceStatement.setShopManagerName(shop.getShopManager());
|
shopBalanceStatement.setPhone(shop.getPhone());
|
shopBalanceStatement.setType(6);//变更类型，订单退款
|
shopBalanceStatement.setHistoricalBalance(historicalBalance);
|
shopBalanceStatement.setVariableAmount(variableAmount);
|
shopBalanceStatement.setCreateTime(LocalDateTime.now());
|
shopBalanceStatement.setBalance(balance);
|
shopBalanceStatement.setCreateUserId(appUser.getId());
|
shopBalanceStatement.setObjectId(order.getId());
|
shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
|
|
return R.ok();
|
}
|
|
|
/**
|
* 退款后后回调处理
|
*
|
* @return
|
*/
|
@Override
|
public R refundPayMoneyCallback(RefundCallbackResult refundCallbackResult) {
|
String code = refundCallbackResult.getR3_RefundOrderNo().substring(1);
|
Order order = this.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, code));
|
if (null == order || order.getPayStatus() == 1 || order.getOrderStatus() == 6) {
|
return R.ok();
|
}
|
order.setRefundCode(refundCallbackResult.getR5_RefundTrxNo());
|
order.setRefundStatus(2);
|
order.setRefundTime(LocalDateTime.now());
|
this.updateById(order);
|
return R.ok();
|
}
|
|
|
|
|
/**
|
* 收货操作
|
*
|
* @param orderId
|
* @return
|
*/
|
@Override
|
public R receivingOperation(Long orderId) {
|
Order order = this.getById(orderId);
|
if (order.getOrderStatus() != 2) {
|
return R.fail("无效的操作");
|
}
|
order.setOrderStatus(4);
|
R<BaseSetting> baseSettingR = baseSettingClient.getBaseSetting(5);
|
if (R.isError(baseSettingR)) {
|
return R.fail("售后设置获取失败");
|
}
|
BaseSetting baseSetting = baseSettingR.getData();
|
if (baseSetting == null) {
|
return R.fail("售后设置获取失败");
|
}
|
String content = baseSetting.getContent();
|
JSONObject jsonObject = JSONObject.parseObject(content);
|
Long days = jsonObject.getLong("days");
|
order.setAfterSaleTime(LocalDateTime.now().plusDays(days));
|
this.updateById(order);
|
return R.ok();
|
}
|
|
|
/**
|
* 获取订单详情
|
*
|
* @param orderId
|
* @return
|
*/
|
@Override
|
public OrderInfoVo getOrderInfo(Long orderId) {
|
Order order = this.getById(orderId);
|
OrderInfoVo orderInfo = new OrderInfoVo();
|
orderInfo.setId(orderId.toString());
|
orderInfo.setOrderNumber(order.getOrderNumber());
|
orderInfo.setOrderStatus(order.getOrderStatus());
|
orderInfo.setCreateTime(order.getCreateTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
|
orderInfo.setPointDeductionAmount(order.getPointDeductionAmount());
|
|
AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
|
if (null != appUser) {
|
orderInfo.setUserName(appUser.getName());
|
orderInfo.setPhone(appUser.getPhone());
|
}
|
|
Shop shop = shopClient.getShopById(order.getShopId()).getData();
|
if (null != shop) {
|
orderInfo.setShopName(shop.getName());
|
}
|
orderInfo.setPaymentMethod(order.getPayMethod());
|
orderInfo.setTotalAmount(order.getTotalAmount());
|
|
orderInfo.setPaymentAmount(order.getPaymentAmount());
|
|
|
OrderGood orderGood = orderGoodMapper.selectOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, orderId).eq(OrderGood::getDelFlag, 0));
|
orderInfo.setGoodsNum(1);
|
orderInfo.setGoodsJson(orderGood.getGoodJson());
|
if (null != orderGood.getSeckillJson()&& !"".equals(orderGood.getSeckillJson())) {
|
orderInfo.setSeckillJson(orderGood.getSeckillJson());
|
orderInfo.setActivityName("秒杀活动");
|
}
|
|
|
|
orderInfo.setPoint(order.getPoint());
|
if (null != order.getAfterSaleTime()) {
|
orderInfo.setAfterSaleTime(order.getAfterSaleTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
|
}
|
if (null != order.getEndTime()) {
|
AppUser user = appUserClient.getAppUserById(order.getCancellerAppUserId());
|
orderInfo.setCanceller(user.getName());
|
orderInfo.setWriteOffTime(order.getEndTime().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
|
}
|
return orderInfo;
|
}
|
|
|
/**
|
* 获取商品销售数量
|
*
|
* @param goodsId
|
* @return
|
*/
|
@Override
|
public Integer getGoodsSaleNum(Integer goodsId, Integer type, Long userId) {
|
return this.baseMapper.getGoodsSaleNum(goodsId, type, userId);
|
}
|
|
|
/**
|
* 获取店铺订单数量
|
*
|
* @param shopId
|
* @param type
|
* @return
|
*/
|
@Override
|
public Integer getShopSaleNum(Integer shopId, Integer type) {
|
return this.baseMapper.getShopSaleNum(shopId, type);
|
}
|
|
|
@Override
|
public Integer getShopSaleNumByShopIds(List<Integer> shopIds, Integer type) {
|
return this.baseMapper.getShopSaleNumByShopIds(shopIds, type);
|
}
|
|
@Override
|
public List<OrderExport> getOrderExportList(OrderPageList orderPageList) {
|
return Collections.emptyList();
|
}
|
|
/**
|
* 确认订单
|
*/
|
@Override
|
public ConfirmOrderVo confirmOrder(Integer goodId,Integer type) {
|
ConfirmOrderVo confirmOrderVo=new ConfirmOrderVo();
|
//用户信息
|
Long userid = tokenService.getLoginUserApplet().getUserid();
|
AppUser appUser = appUserClient.getAppUserById(userid);
|
//获取商品信息
|
Goods good = goodsClient.getGoodsById(goodId).getData();
|
if (null == good||good.getDelFlag()==1||good.getStatus()==0) {
|
//商品不存在
|
throw new ServiceException("商品不存在");
|
}
|
//查询店铺信息
|
|
GoodsShop shop = goodsShopClient.getGoodsShop(goodId).getData();
|
System.out.println(shop);
|
if (null == shop){
|
//门店不存在
|
throw new ServiceException("该商品门店不存在");
|
}
|
//插入基础信息
|
confirmOrderVo.setGoodId(goodId);
|
confirmOrderVo.setGoodName(good.getName());
|
confirmOrderVo.setHomePicture(good.getHomePagePicture());
|
confirmOrderVo.setNumber(1);
|
confirmOrderVo.setShopId(shop.getShopId());
|
confirmOrderVo.setShopName(shop.getShopName());
|
confirmOrderVo.setPurchaseLimitNum(good.getPurchaseLimit());
|
confirmOrderVo.setOriginalPrice(good.getOriginalPrice());
|
|
confirmOrderVo.setResidualPoint(appUser.getAvailablePoint());
|
//插入价格
|
confirmOrderVo.setCash(good.getSellingPrice());
|
confirmOrderVo.setPoint(good.getIntegral());
|
|
//是否在秒杀活动中
|
GetSeckillActivityInfo info = new GetSeckillActivityInfo();
|
info.setGoodsId(goodId);
|
GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();
|
|
if (null != goodsSeckill){
|
SeckillActivityInfo activityInfo = seckillActivityInfoClient.getSeckillActivityInfoById(goodsSeckill.getSeckillActivityInfoId()).getData();
|
//价格
|
confirmOrderVo.setCash(goodsSeckill.getSellingPrice());//秒杀活动价格
|
confirmOrderVo.setPoint(goodsSeckill.getIntegral());//秒杀活动积分价格
|
confirmOrderVo.setPurchaseLimitNum(activityInfo.getMaxNum());//限购数量
|
confirmOrderVo.setEndTimeStamp(activityInfo.getEndTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());//结束时间戳
|
}
|
|
|
//判断是否是积分支付
|
if (type == 1) {//现金
|
confirmOrderVo.setOrderMoney(confirmOrderVo.getCash());
|
Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
|
|
BigDecimal maxPointDeductionAmount = getCashByPoint(availablePoint);//最大可抵扣金额
|
|
//计算积分抵扣的金额 将积分转为金额，去掉小数
|
//实际抵扣金额
|
BigDecimal deduction= maxPointDeductionAmount.min(confirmOrderVo.getCash());
|
confirmOrderVo.setDeduction(deduction);
|
}else {//积分
|
confirmOrderVo.setOrderPoint(confirmOrderVo.getPoint());
|
}
|
//限购检查
|
//判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
|
if(null == confirmOrderVo.getPurchaseLimitNum() || -1 == confirmOrderVo.getPurchaseLimitNum()){
|
confirmOrderVo.setIsPurchaseLimit(false);
|
confirmOrderVo.setPurchaseLimitNum(-1);
|
}else{
|
// 查当前用户的订单
|
List<Order> orders = this.list(new LambdaQueryWrapper<Order>().eq(Order::getAppUserId, appUser.getId()).eq(Order::getDelFlag, 0).in(Order::getOrderStatus, Arrays.asList(4, 8)));
|
List<Long> orderIds = orders.stream().map(Order::getId).collect(Collectors.toList());
|
int sum = 0;
|
if(!orderIds.isEmpty()){
|
//关于该商品的订单
|
List<OrderGood> orderGoodList = orderGoodService.list(new LambdaQueryWrapper<OrderGood>().in(OrderGood::getOrderId, orderIds)
|
.eq(OrderGood::getGoodsId, good.getId()).eq(OrderGood::getDelFlag, 0));
|
sum = orderGoodList.stream().mapToInt(OrderGood::getNum).sum();
|
}
|
confirmOrderVo.setIsPurchaseLimit((1 + sum) > good.getPurchaseLimit());
|
confirmOrderVo.setPurchaseLimitNum(confirmOrderVo.getPurchaseLimitNum() - sum);
|
}
|
|
return confirmOrderVo;
|
}
|
|
/**
|
* 订单支付
|
*/
|
@Override
|
public R orderPayment(OrderPayment orderPayment) {
|
Long userid = tokenService.getLoginUserApplet().getUserid();
|
AppUser appUser = appUserClient.getAppUserById(userid);
|
int type=1;//商品类型 1=普通商品，2=秒杀商品
|
//商品信息
|
Goods goods = goodsClient.getGoodsById(orderPayment.getGoodId()).getData();
|
String goodsJson= JSON.toJSONString(goods);
|
if (null == goods || 1==goods.getDelFlag()){
|
return R.fail( "商品不存在");
|
}
|
if(goods.getStatus() == 1){
|
return R.fail(goods.getName() + "商品已被下架");
|
}
|
|
//是否在秒杀活动中
|
GetSeckillActivityInfo info = new GetSeckillActivityInfo();
|
info.setGoodsId(orderPayment.getGoodId());
|
GoodsSeckill goodsSeckill = seckillActivityInfoClient.getSeckillActivityInfo(info).getData();
|
|
if (null != goodsSeckill){
|
//秒杀商品
|
type=2;
|
//判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
|
Integer goodsSaleNum = orderMapper.getGoodsSaleNum(orderPayment.getGoodId(), 2, userid);//已购买数量
|
SeckillActivityInfo activityInfo = seckillActivityInfoClient.getSeckillActivityInfoById(goodsSeckill.getSeckillActivityInfoId()).getData();
|
if(null != activityInfo.getMaxNum() && -1 != activityInfo.getMaxNum() && (goodsSaleNum + 1) > activityInfo.getMaxNum()){
|
return R.fail(goods.getName() + "已超出秒杀活动购买上限");
|
}
|
//价格
|
goods.setSellingPrice(goodsSeckill.getSellingPrice());//秒杀活动价格
|
goods.setIntegral(goodsSeckill.getIntegral());//秒杀活动积分价格
|
}else {
|
//普通商品
|
//判断当前数量是否已经超出限购数量（需要计算已经购买的数量）
|
Integer goodsSaleNum = orderMapper.getGoodsSaleNum(orderPayment.getGoodId(), 1, userid);//已购买数量
|
//普通商品
|
if(null != goods.getPurchaseLimit() && -1 != goods.getPurchaseLimit() && (goodsSaleNum + 1) > goods.getPurchaseLimit()){
|
return R.fail(goods.getName() + "已超出购买上限");
|
}
|
}
|
|
//判断支付方式是否正确
|
if(1 != orderPayment.getPaymentType() && 3 != orderPayment.getPaymentType()){
|
return R.fail("支付方式不正确");
|
}
|
|
//订单总金额
|
BigDecimal orderMoney = BigDecimal.ZERO;
|
//积分支付的订单积分
|
Integer orderPoint = 0;
|
|
//现金的实际支付金额
|
BigDecimal paymentMoney = BigDecimal.ZERO;
|
//积分抵扣金额
|
BigDecimal pointDeductionAmount = BigDecimal.ZERO;
|
|
if(3 != orderPayment.getPaymentType()){
|
//现金支付
|
orderMoney = goods.getSellingPrice();
|
paymentMoney=orderMoney.setScale(2, RoundingMode.HALF_EVEN);;
|
|
//是否使用积分抵扣
|
if (orderPayment.getIsPointDeduction() == 1) {
|
//积分抵扣金额
|
Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
|
BigDecimal maxPointDeductionAmount = getCashByPoint(availablePoint);//最大可抵扣金额
|
pointDeductionAmount=maxPointDeductionAmount.min(orderMoney);//实际抵扣金额
|
// 计算实际支付金额
|
paymentMoney = orderMoney.subtract(pointDeductionAmount).setScale(2, RoundingMode.HALF_EVEN);
|
//计算消耗积分
|
orderPoint=getPoint(pointDeductionAmount);
|
}
|
}else{
|
//积分支付
|
orderPoint=goods.getIntegral();
|
orderMoney = goods.getSellingPrice();
|
Integer availablePoint = appUser.getAvailablePoint();//用户可用积分
|
if(availablePoint.compareTo(orderPoint) < 0){
|
return R.fail("账户可用积分不足");
|
}
|
}
|
//构建订单
|
Order order = new Order();
|
order.setAppUserId(appUser.getId());
|
order.setNum(1);
|
order.setGoodPics(goods.getHomePagePicture());
|
order.setGoodName(goods.getName());
|
order.setOrderStatus( 3 );//待使用
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
|
order.setOrderNumber("QJS" + getNumber(3) + sdf.format(new Date()));
|
order.setTotalAmount(orderMoney.setScale(2, RoundingMode.HALF_EVEN));//订单总金额
|
order.setPointDeductionAmount(pointDeductionAmount.setScale(2, RoundingMode.HALF_EVEN));
|
order.setPaymentAmount(paymentMoney);//实际支付价格
|
order.setPoint(orderPoint);//使用积分
|
if (orderPayment.getPaymentType()==3 && orderPoint>0){//微信支付 但支付的积分也大于0
|
order.setPayMethod(4);//组合支付
|
}else {
|
order.setPayMethod(orderPayment.getPaymentType());//积分或者微信
|
}
|
order.setPayStatus(1);
|
order.setShopId(orderPayment.getShopId());
|
order.setDelFlag(0);
|
order.setCreateTime(LocalDateTime.now());
|
|
this.save(order);
|
|
|
//构建订单明细数据
|
OrderGood orderGood = new OrderGood();
|
orderGood.setGoodsId(goods.getId());
|
orderGood.setOrderId(order.getId());
|
orderGood.setNum(1);
|
orderGood.setType(type);
|
if (2==type){
|
orderGood.setSeckillJson(JSON.toJSONString(goodsSeckill));
|
}
|
orderGood.setGoodJson(goodsJson);
|
orderGood.setDelFlag(0);
|
orderGood.setCreateTime(LocalDateTime.now());
|
orderGood.setCashPayment(orderPayment.getPaymentType()==1 ? 1 : 0);
|
orderGood.setPointPayment(orderPayment.getPaymentType()==3 ? 1 : 0);
|
orderGood.setSellingPrice(goods.getSellingPrice());
|
orderGood.setIntegral(goods.getIntegral());
|
orderGoodService.save(orderGood);
|
|
//开始构建支付信息
|
if(BigDecimal.ZERO.compareTo(paymentMoney) > 0){
|
paymentMoney = BigDecimal.ZERO;
|
}
|
//判断积分是否为零，积分支付
|
if (0 != order.getPoint()){
|
if (null==appUser.getAvailablePoint()){
|
appUser.setAvailablePoint(0);
|
}
|
if (null==appUser.getExchangePoint()){
|
appUser.setExchangePoint(0);
|
}
|
|
//积分支付
|
Integer historicalPoint = appUser.getAvailablePoint();//历史积分
|
Integer availablePoint = historicalPoint - orderPoint;//可用积分
|
Integer exchangePoint = appUser.getExchangePoint() + orderPoint;//兑换商品消费积分
|
//扣减订单支付积分
|
appUser.setAvailablePoint(availablePoint);
|
appUser.setExchangePoint(exchangePoint );
|
appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());//总积分
|
//构建积分流水记录
|
UserPoint userPoint = new UserPoint();
|
userPoint.setType(4);//兑换商品
|
userPoint.setHistoricalPoint(historicalPoint);
|
userPoint.setVariablePoint(orderPoint);
|
userPoint.setBalance(availablePoint);
|
userPoint.setCreateTime(LocalDateTime.now());
|
userPoint.setAppUserId(appUser.getId());
|
userPoint.setObjectId(order.getId());
|
userPointClient.saveUserPoint(userPoint);
|
|
//用户积分变动
|
appUser.setLastShopTime(LocalDateTime.now());
|
appUserClient.editAppUserById(appUser);
|
|
|
}
|
//判断需要支付的金额是否大于0
|
if ( BigDecimal.ZERO.compareTo(paymentMoney) < 0){
|
//调起微信支付
|
String goodsNames = goods.getName();
|
UniPayResult uniPayResult = PaymentUtil.uniPay(order.getOrderNumber(), paymentMoney.doubleValue(), "购买单品商品",
|
goodsNames, "", "/order/order/orderPaymentCallback", appUser.getWxOpenid(), null);
|
if(null == uniPayResult || !"100".equals(uniPayResult.getRa_Code())){
|
return R.fail(null == uniPayResult ? "支付失败" : uniPayResult.getRb_CodeMsg());
|
}
|
String rc_result = uniPayResult.getRc_Result();
|
JSONObject jsonObject = JSON.parseObject(rc_result);
|
jsonObject.put("orderId", order.getId().toString());
|
//将支付数据添加到redis队列中，便于定时任务去校验是否完成支付，没有完成支付支付，15分钟后关闭订单。
|
long second = LocalDateTime.now().plusMinutes(15).toEpochSecond(ZoneOffset.UTC);
|
redisTemplate.opsForZSet().add("OrderPayment", order.getOrderNumber(), second);
|
return R.ok(jsonObject.toJSONString());
|
|
}
|
|
//积分支付，不需要微信支付，直接修改订支付状态
|
order.setPayStatus(2);
|
orderMapper.updateById(order);
|
//商品销量增加
|
goodsClient.editGoodsNum(orderGood.getGoodsId(), 1);
|
|
//门店增加冻结资金 即增加余额， 冻结资金=余额-可用资金
|
Shop shop = shopClient.getShopById(order.getShopId()).getData();
|
if (null==shop.getBalance()){
|
shop.setBalance(BigDecimal.ZERO);
|
}
|
|
BigDecimal historicalBalance=shop.getBalance();//历史余额
|
BigDecimal variableAmount=goods.getSellingPrice();//变动金额
|
BigDecimal balance=shop.getBalance().add(goods.getSellingPrice());//变动后余额
|
|
shop.setBalance(balance);
|
shop.setOrderNumber(shop.getOrderNumber()+1);
|
shopClient.updateShop(shop);
|
|
//门店余额流水记录
|
ShopBalanceStatement shopBalanceStatement = new ShopBalanceStatement();
|
shopBalanceStatement.setShopId(shop.getId());
|
shopBalanceStatement.setShopName(shop.getName());
|
shopBalanceStatement.setShopManagerName(shop.getShopManager());
|
shopBalanceStatement.setPhone(shop.getPhone());
|
shopBalanceStatement.setType(5);//变更类型，订单收入
|
shopBalanceStatement.setHistoricalBalance(historicalBalance);
|
shopBalanceStatement.setVariableAmount(variableAmount);
|
shopBalanceStatement.setCreateTime(LocalDateTime.now());
|
shopBalanceStatement.setBalance(balance);
|
shopBalanceStatement.setCreateUserId(appUser.getId());
|
shopBalanceStatement.setObjectId(order.getId());
|
shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
|
return R.ok(order.getId().toString());
|
}
|
|
/**
|
* 订单支付回调通知
|
*/
|
@Override
|
public R orderPaymentCallback(UniPayCallbackResult uniPayCallbackResult) {
|
Order order = orderMapper.selectOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNumber, uniPayCallbackResult.getR2_OrderNo()));
|
if(null == order || order.getPayStatus() == 2){
|
return R.ok();
|
}
|
|
AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
|
BigDecimal paymentMoney = order.getPaymentAmount();
|
//增加用户消费总金额（微信支付金额）
|
appUser.setShopAmount(appUser.getShopAmount().add(paymentMoney).setScale(2, RoundingMode.HALF_EVEN));//消费总金额
|
appUser.setLastShopTime(LocalDateTime.now());
|
appUserClient.editAppUserById(appUser);
|
|
//修改订支付状态
|
order.setPayStatus(2);
|
//待使用
|
order.setOrderStatus(3);
|
String r7TrxNo = uniPayCallbackResult.getR9_BankTrxNo();
|
order.setSerialNumber(r7TrxNo);
|
orderMapper.updateById(order);
|
|
OrderGood orderGood = orderGoodService.getOne(new LambdaQueryWrapper<OrderGood>().eq(OrderGood::getOrderId, order.getId()));
|
//商品销量增加
|
goodsClient.editGoodsNum(orderGood.getGoodsId(), 1);
|
Goods goods = JSON.parseObject(orderGood.getGoodJson(), Goods.class);
|
GoodsSeckill goodsSeckill = JSON.parseObject(orderGood.getSeckillJson(), GoodsSeckill.class);
|
//门店增加冻结资金 即增加金额， 冻结资金=余额-可用资金
|
Shop shop = shopClient.getShopById(order.getShopId()).getData();
|
BigDecimal historicalBalance=shop.getBalance();//历史余额
|
BigDecimal variableAmount=BigDecimal.ZERO;//变动金额
|
if (null != goodsSeckill) {
|
variableAmount=goodsSeckill.getSellingPrice();
|
}else {
|
variableAmount=goods.getSellingPrice();
|
}
|
BigDecimal balance=shop.getBalance().add(variableAmount);//变动后余额
|
|
shop.setBalance(balance);
|
shop.setOrderNumber(shop.getOrderNumber()+1);
|
shopClient.updateShop(shop);
|
|
//门店金额变动记录
|
ShopBalanceStatement shopBalanceStatement = new ShopBalanceStatement();
|
shopBalanceStatement.setShopId(shop.getId());
|
shopBalanceStatement.setShopName(shop.getName());
|
shopBalanceStatement.setShopManagerName(shop.getShopManager());
|
shopBalanceStatement.setPhone(shop.getPhone());
|
shopBalanceStatement.setType(5);//变更类型，订单收入
|
shopBalanceStatement.setHistoricalBalance(historicalBalance);
|
shopBalanceStatement.setVariableAmount(variableAmount);
|
shopBalanceStatement.setCreateTime(LocalDateTime.now());
|
shopBalanceStatement.setBalance(balance);
|
shopBalanceStatement.setCreateUserId(appUser.getId());
|
shopBalanceStatement.setObjectId(order.getId());
|
shopBalanceStatementClient.saveShopBalanceStatement(shopBalanceStatement);
|
|
return R.ok();
|
}
|
|
/**
|
* 定时任务关闭订单
|
*/
|
@Override
|
public void closeOrder() {
|
//订单支付数据
|
long second = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
|
Set<String> orderPayment = redisTemplate.opsForZSet().rangeByScore("OrderPayment", 0, second);
|
if(orderPayment.size() > 0){
|
List<Order> list = orderMapper.selectList(new LambdaQueryWrapper<Order>().in(Order::getOrderNumber, orderPayment));
|
for (Order order : list) {
|
if(null == order || order.getPayStatus() != 1){
|
redisTemplate.opsForZSet().remove("OrderPayment", order.getOrderNumber());
|
continue;
|
}
|
//开始执行关闭订单操作
|
CloseOrderResult closeOrderResult = PaymentUtil.closeOrder(order.getOrderNumber());
|
if((null == closeOrderResult || !closeOrderResult.getRa_Status().equals("100")) &&
|
Arrays.asList("0", "4", "101", "10080000", "10080002", "10083004", "10083005").contains(closeOrderResult.getRb_Code())){
|
redisTemplate.opsForZSet().add("OrderPayment", order.getOrderNumber(), 0);
|
log.error("关闭订单失败：{}---->{}", order.getOrderNumber(), JSON.toJSONString(closeOrderResult));
|
}
|
redisTemplate.opsForZSet().remove("OrderPayment", order.getOrderNumber());
|
//关闭订单后，检查是否先有过积分抵扣了，是的话要返回订单已抵扣的积分，以及用户积分流水的删除
|
if (order.getPoint()>0) {
|
//返回订单抵扣积分
|
AppUser appUser = appUserClient.getAppUserById(order.getAppUserId());
|
Integer availablePoint = appUser.getAvailablePoint();//可用积分
|
Integer variablePoint = order.getPoint();//变动积分
|
Integer balance = appUser.getAvailablePoint() + order.getPoint();//变动后积分
|
Integer cancelPoint = appUser.getCancelPoint() + order.getPoint();//取消订单积分
|
appUser.setAvailablePoint(availablePoint);
|
appUser.setCancelPoint(cancelPoint);
|
appUser.setTotalPoint(appUser.getTotalPoint() + order.getPoint());
|
|
//构建积分流水记录
|
UserPoint userPoint = new UserPoint();
|
userPoint.setType(16);//取消订单
|
userPoint.setHistoricalPoint(availablePoint);
|
userPoint.setVariablePoint(variablePoint);
|
userPoint.setBalance(balance);
|
userPoint.setCreateTime(LocalDateTime.now());
|
userPoint.setAppUserId(appUser.getId());
|
userPoint.setObjectId(order.getId());
|
userPointClient.saveUserPoint(userPoint);
|
|
appUserClient.editAppUserById(appUser);
|
}
|
}
|
}
|
|
}
|
|
@Override
|
public IPage<OrderPageListVo> getShopOrderList(String content, Integer status, Integer shopId, Integer pageNum, Integer pageSize) {
|
// 创建分页对象
|
Page<Order> page = new Page<>(pageNum, pageSize);
|
// 构建查询条件
|
QueryWrapper<Order> queryWrapper = new QueryWrapper<>();
|
// 添加门店ID条件
|
if (shopId != null) {
|
queryWrapper.eq("shop_id", shopId);
|
}
|
// 添加订单状态条件
|
if (status != null&&status==4) { //4-已完成 8-已评价
|
queryWrapper.in("order_status",Arrays.asList(4,8));
|
}
|
if (status != null&&status!=4) {//3-待核销 5-已取消
|
queryWrapper.eq("order_status",status);
|
}
|
// 模糊查询条件
|
if (StringUtils.isNotBlank(content)) {
|
// 构建OR条件组：订单编号/商品名/手机号
|
queryWrapper.and(wrapper -> wrapper
|
.like("order_number", content) // 订单编号
|
.or()
|
.like("goods_name", content) // 商品名
|
.or()
|
.inSql("app_user_id", "select id from t_app_user where phone like '%" + content + "%'") // 手机号
|
);
|
}
|
|
// 执行分页查询
|
IPage<Order> orderPage = orderMapper.selectPage(page, queryWrapper);
|
// 转换为VO对象
|
return orderPage.convert(this::convertToOrderListVo);
|
}
|
|
@Override
|
public R shopCancelOrder(Long orderId) {
|
Order order = this.getById(orderId);
|
if (Arrays.asList(5, 6, 7).contains(order.getOrderStatus())) {
|
return R.fail("无效的操作");
|
}
|
if (null != order.getAfterSaleTime() && LocalDateTime.now().isAfter(order.getAfterSaleTime())) {
|
return R.fail("订单取消失败");
|
}
|
order.setOrderStatus(5);
|
order.setEndTime(LocalDateTime.now());
|
R r = refundPayMoney(order);
|
if (200 == r.getCode()) {
|
this.updateById(order);
|
}
|
return r;
|
}
|
|
/**
|
* 后台-工作台-折线图
|
* @param startTime
|
* @param endTime
|
* @return
|
*/
|
@Override
|
public List<OrderStatisticsDetail> getOrderListGroupByDate(LocalDate startTime, LocalDate endTime) {
|
// 查询数据库获取原始数据
|
List<OrderStatisticsDetail> rawData = orderMapper.getOrderListGroupByDate(
|
startTime.atTime(0,0, 0),
|
endTime.atTime(23,59,59)
|
);
|
|
// 创建完整日期范围的映射
|
Map<LocalDate, OrderStatisticsDetail> dateMap = rawData.stream()
|
.collect(Collectors.toMap(
|
OrderStatisticsDetail::getDateTime,
|
Function.identity()
|
));
|
|
// 生成完整日期序列并填充缺失数据
|
List<OrderStatisticsDetail> completeList = new ArrayList<>();
|
for (LocalDate date = startTime; !date.isAfter(endTime); date = date.plusDays(1)) {
|
if (dateMap.containsKey(date)) {
|
completeList.add(dateMap.get(date));
|
} else {
|
completeList.add(new OrderStatisticsDetail(date, 0, BigDecimal.ZERO));
|
}
|
}
|
return completeList;
|
}
|
|
|
private OrderPageListVo convertToOrderListVo(Order order) {
|
OrderPageListVo vo = new OrderPageListVo();
|
// 复制属性
|
BeanUtils.copyProperties(order, vo);
|
// 查询用户信息
|
AppUser user = appUserClient.getAppUserById(order.getAppUserId());
|
if (user != null) {
|
vo.setPhone(user.getPhone());
|
}
|
vo.setIdStr(order.getId().toString());
|
return vo;
|
}
|
|
|
public String getNumber(Integer size){
|
StringBuilder str = new StringBuilder();
|
for (int i = 0; i < size; i++) {
|
str.append(Double.valueOf(Math.random() * 10).intValue());
|
}
|
return str.toString();
|
}
|
|
/**
|
* 获取现金对应积分
|
*/
|
public Integer getPoint(BigDecimal cash){
|
if (cash == null || cash.compareTo(BigDecimal.ZERO) < 0) {
|
throw new IllegalArgumentException("金额不能为null或负数");
|
}
|
// 获取积分兑换比例配置
|
R<SysConfig> info = sysConfigClient.getInfo(6L);
|
if (info == null || info.getData() == null) {
|
throw new RuntimeException("获取积分兑换比例配置失败");
|
}
|
String configValue = info.getData().getConfigValue();
|
if (StringUtils.isBlank(configValue)) {
|
throw new RuntimeException("积分兑换比例配置值为空");
|
}
|
try {
|
// 使用BigDecimal处理比例，避免精度问题
|
BigDecimal ratio = new BigDecimal(configValue.trim());
|
if (ratio.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new RuntimeException("积分兑换比例必须大于0");
|
}
|
|
// 计算积分并四舍五入取整
|
return cash.multiply(ratio).intValue();
|
|
} catch (NumberFormatException e) {
|
throw new RuntimeException("积分兑换比例配置值格式错误", e);
|
} catch (ArithmeticException e) {
|
throw new RuntimeException("积分计算结果溢出", e);
|
}
|
|
}
|
|
/**
|
* 获取积分对应金额
|
*/
|
public BigDecimal getCashByPoint(Integer point){
|
// 参数校验
|
if (point == null || point < 0) {
|
throw new IllegalArgumentException("积分值不能为null或负数");
|
}
|
|
// 特殊情况：0积分直接返回0金额
|
if (point == 0) {
|
return BigDecimal.ZERO.setScale(2);
|
}
|
|
// 获取积分兑换比例配置
|
R<SysConfig> info = sysConfigClient.getInfo(6L);
|
if (info == null || info.getData() == null) {
|
throw new RuntimeException("获取积分兑换比例配置失败");
|
}
|
|
String configValue = info.getData().getConfigValue(); // 示例："100" 表示 100积分=1元
|
if (StringUtils.isBlank(configValue)) {
|
throw new RuntimeException("积分兑换比例配置值为空");
|
}
|
|
try {
|
// 解析兑换比例（转换为BigDecimal保证精度）
|
BigDecimal exchangeRate = new BigDecimal(configValue.trim());
|
if (exchangeRate.compareTo(BigDecimal.ZERO) <= 0) {
|
throw new RuntimeException("积分兑换比例必须为正数");
|
}
|
|
// 高精度计算（积分/比例）
|
return new BigDecimal(point)
|
.divide(exchangeRate, 2, RoundingMode.HALF_UP);
|
|
} catch (NumberFormatException e) {
|
throw new RuntimeException("积分兑换比例配置值格式错误，应为数字", e);
|
} catch (ArithmeticException e) {
|
throw new RuntimeException("积分计算错误", e);
|
}
|
}
|
}
|
