584 lines
22 KiB
Java
584 lines
22 KiB
Java
package com.peanut.modules.book.controller;
|
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
|
import com.peanut.common.utils.PageUtils;
|
|
import com.peanut.common.utils.R;
|
|
import com.peanut.config.Constants;
|
|
import com.peanut.config.DelayQueueConfig;
|
|
import com.peanut.modules.book.entity.*;
|
|
import com.peanut.modules.book.service.*;
|
|
import com.peanut.modules.book.vo.request.BuyOrderListRequestVo;
|
|
import com.peanut.modules.book.vo.request.ModifyOrderAddressRequestVo;
|
|
import com.peanut.modules.book.vo.request.ProductRequestVo;
|
|
import com.peanut.modules.book.vo.request.ProductTransportVo;
|
|
import com.peanut.modules.book.vo.response.BuyOrderResponseVo;
|
|
import com.peanut.modules.book.vo.response.ExpressQueryResponseVo;
|
|
import com.peanut.modules.book.vo.ShippingAddressRequestVo;
|
|
import com.peanut.modules.book.vo.UserAddressVo;
|
|
import com.peanut.modules.pay.weChatPay.dto.WechatPaymentInfo;
|
|
import com.peanut.modules.pay.weChatPay.service.WxpayService;
|
|
import com.peanut.modules.sys.entity.SysConfigEntity;
|
|
import com.peanut.modules.sys.service.SysConfigService;
|
|
import lombok.extern.slf4j.Slf4j;
|
|
import org.springframework.amqp.core.MessagePostProcessor;
|
|
import org.springframework.amqp.rabbit.core.RabbitTemplate;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.transaction.annotation.Transactional;
|
|
import org.springframework.web.bind.annotation.*;
|
|
|
|
import java.io.IOException;
|
|
import java.math.BigDecimal;
|
|
import java.math.MathContext;
|
|
import java.math.RoundingMode;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
|
|
/**
|
|
* 订单表
|
|
*
|
|
* @author yl
|
|
* @email yl328572838@163.com
|
|
* @date 2022-08-29 15:27:44
|
|
*/
|
|
@Slf4j
|
|
@RestController
|
|
@RequestMapping("book/buyOrder")
|
|
public class BuyOrderController {
|
|
@Autowired
|
|
private BuyOrderService buyOrderService;
|
|
@Autowired
|
|
private ShopProductService shopProductService;
|
|
@Autowired
|
|
private BuyOrderDetailService buyOrderDetailService;
|
|
@Autowired
|
|
private CouponService couponService;
|
|
@Autowired
|
|
private CouponHistoryService couponHistoryService;
|
|
@Autowired
|
|
private OrderCartService orderCartService;
|
|
@Autowired
|
|
private MyUserService myUserService;
|
|
@Autowired
|
|
private TransactionDetailsService transactionDetailsService;
|
|
@Autowired
|
|
private UserEbookBuyService userEbookBuyService;
|
|
@Autowired
|
|
private WxpayService wxpayService;
|
|
@Autowired
|
|
private RabbitTemplate rabbitTemplate;
|
|
@Autowired
|
|
private ShopProductBookService shopProductBookService;
|
|
@Autowired
|
|
private ExpressOrderService expressOrderService;
|
|
@Autowired
|
|
private UserAddressService userAddressService;
|
|
@Autowired
|
|
private ExpressFeeService expressFeeService;
|
|
@Autowired
|
|
private SysConfigService sysConfigService;
|
|
|
|
@RequestMapping(value = "/decomposeShipment", method = RequestMethod.GET)
|
|
public R decomposeShipment(@RequestParam("userId") Integer userId) {
|
|
Map<Integer, List<String>> result = buyOrderService.decomposeShipment(userId);
|
|
return R.ok().put("result", result);
|
|
}
|
|
|
|
|
|
// TODO 新版本上线后废弃
|
|
@RequestMapping("/list")
|
|
public R list(@RequestParam Map<String, Object> params) throws Exception {
|
|
PageUtils page = buyOrderService.list(params);
|
|
return R.ok().put("page", page);
|
|
}
|
|
|
|
/**
|
|
* 订单列表
|
|
*
|
|
* @param requestVo request value object
|
|
* @return R
|
|
*/
|
|
@RequestMapping(path = "/orderList", method = RequestMethod.POST)
|
|
public R orderList(@RequestBody BuyOrderListRequestVo requestVo) {
|
|
PageUtils page = buyOrderService.orderList(requestVo);
|
|
return R.ok().put("result", page);
|
|
}
|
|
|
|
/**
|
|
* 订单详情
|
|
*
|
|
* @param orderSn 订单号
|
|
* @return R
|
|
*/
|
|
@RequestMapping(path = "/orderDetail", method = RequestMethod.GET)
|
|
public R orderDetail(@RequestParam("orderSn") String orderSn) {
|
|
BuyOrderResponseVo buyOrderResponseVo = buyOrderService.orderDetail(orderSn);
|
|
return R.ok().put("result", buyOrderResponseVo);
|
|
}
|
|
|
|
/**
|
|
* 下单
|
|
*
|
|
* @param buyOrder 订单
|
|
* @return R
|
|
*/
|
|
@RequestMapping("/buySave")
|
|
@Transactional
|
|
public R buySave(@RequestBody BuyOrder buyOrder) throws IOException {
|
|
// 获取订单详情
|
|
List<BuyOrderDetail> buyOrderDetails = buyOrder.getProducts();
|
|
// 订单总金额
|
|
BigDecimal totalPrice = new BigDecimal(0);
|
|
// 遍历商品总价计算
|
|
for (BuyOrderDetail buyOrderDetail : buyOrderDetails) {
|
|
Integer productId = buyOrderDetail.getProductId();
|
|
int quantity = buyOrderDetail.getQuantity();
|
|
ShopProduct product = shopProductService.getById(productId);
|
|
BigDecimal price = getRealPrice(product);
|
|
if (!handleStock(buyOrderDetail, product)) {
|
|
return R.error(500, "库存不足");
|
|
}
|
|
totalPrice = totalPrice.add(price.multiply(BigDecimal.valueOf(quantity)));
|
|
buyOrderDetail.setProductName(product.getProductName());
|
|
buyOrderDetail.setProductPrice(product.getPrice());
|
|
int originWeight = product.getWeight();
|
|
int originWeightIntValue = originWeight / 100;
|
|
int originWeightDecimalValue = originWeightIntValue % 100;
|
|
buyOrderDetail.setWeight(BigDecimal.valueOf(originWeightIntValue).add(BigDecimal.valueOf(originWeightDecimalValue).divide(new BigDecimal(100),
|
|
MathContext.DECIMAL64)));
|
|
buyOrderDetail.setProductUrl(product.getProductImages());
|
|
buyOrderDetail.setOrderStatus(Constants.ORDER_STATUS_TO_BE_PAID);
|
|
}
|
|
|
|
totalPrice = totalPrice.subtract(useCouponAmount(buyOrder));
|
|
totalPrice = totalPrice.add(getShoppingAmount(buyOrder));
|
|
String orderSn = IdWorker.getTimeId().substring(0, 32);
|
|
buyOrder.setOrderSn(orderSn);
|
|
buyOrder.setPaymentDate(new Date());
|
|
QueryWrapper<UserAddress> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq("id", buyOrder.getAddressId());
|
|
UserAddress userAddress = userAddressService.getOne(queryWrapper);
|
|
UserAddressVo vo = new UserAddressVo();
|
|
vo = userAddressService.getAddressName(vo, userAddress.getRegionCode());
|
|
buyOrder.setProvince(vo.getProvince());
|
|
buyOrder.setCity(vo.getCity());
|
|
buyOrder.setDistrict(vo.getCounty());
|
|
buyOrder.setAddress(vo.getDetailAddress());
|
|
buyOrderService.save(buyOrder);
|
|
|
|
for (BuyOrderDetail buyOrderDetail : buyOrderDetails) {
|
|
buyOrderDetail.setOrderId(buyOrder.getOrderId());
|
|
buyOrderDetail.setUserId(buyOrder.getUserId());
|
|
if (Constants.BUY_TYPE_CART.equals(buyOrder.getBuyType())) {
|
|
handleBuyCart(buyOrder, buyOrderDetail);
|
|
}
|
|
}
|
|
buyOrderDetailService.saveBatch(buyOrderDetails);
|
|
// 1. 虚拟币支付
|
|
if (Constants.PAYMENT_METHOD_VIRTUAL.equals(buyOrder.getPaymentMethod())) {
|
|
buyOrder.setOrderStatus(Constants.ORDER_STATUS_TO_BE_SHIPPED);
|
|
MyUserEntity user = this.myUserService.getById(buyOrder.getUserId());
|
|
if (usePeanutCoin(user, totalPrice)) {
|
|
// 更新订单状态
|
|
buyOrderService.updateOrderStatus(user.getId(), buyOrder.getOrderSn(), "0");
|
|
recordTransaction(buyOrder, user, totalPrice);
|
|
addEbookToUser(buyOrderDetails, buyOrder);
|
|
} else {
|
|
return R.error(500, "花生币余额不足！");
|
|
}
|
|
}
|
|
// 2. 微信支付
|
|
if (Constants.PAYMENT_METHOD_WECHAT_PAY.equals(buyOrder.getPaymentMethod())) {
|
|
rabbitTemplate.convertAndSend(
|
|
DelayQueueConfig.ORDER_TO_BE_PAY_EXCHANGE,
|
|
DelayQueueConfig.ORDER_TO_BE_PAY_ROUTING_KEY,
|
|
buyOrder.getOrderId(),
|
|
messagePostProcessor()
|
|
);
|
|
WechatPaymentInfo paymentInfo = new WechatPaymentInfo();
|
|
paymentInfo.setOrderSn(orderSn);
|
|
paymentInfo.setBuyOrderId(buyOrder.getOrderId());
|
|
paymentInfo.setTotalAmount(totalPrice);
|
|
wxpayService.prepay(paymentInfo);
|
|
}
|
|
Map<String, Object> result = new HashMap<>();
|
|
result.put("orderSn", buyOrder.getOrderSn());
|
|
result.put("money", totalPrice);
|
|
return R.ok(result);
|
|
}
|
|
|
|
@RequestMapping(path = "/calculateTransportPrice", method = RequestMethod.POST)
|
|
public R getTransportPrice(@RequestBody ProductTransportVo vo) {
|
|
String regionCode = vo.getRegionCode();
|
|
List<ProductRequestVo> products = vo.getProducts();
|
|
BigDecimal totalWeight = new BigDecimal(0);
|
|
for (ProductRequestVo product : products) {
|
|
ShopProduct shopProduct = shopProductService.getById(product.getProductId());
|
|
BigDecimal weight = BigDecimal.valueOf(Double.valueOf(shopProduct.getWeight()) / 1000.0);
|
|
totalWeight = totalWeight.add(weight.multiply(new BigDecimal(product.getQuantity())));
|
|
}
|
|
totalWeight = totalWeight.setScale(0, RoundingMode.UP);
|
|
QueryWrapper<SysConfigEntity> configQueryWrapper = new QueryWrapper<>();
|
|
configQueryWrapper.eq("param_key", "DEFAULT_EXPRESS");
|
|
SysConfigEntity config = sysConfigService.getOne(configQueryWrapper);
|
|
BigDecimal expressFee = expressFeeService.calculateExpressFee(config.getParamValue(), totalWeight, regionCode);
|
|
return R.ok().put("result", expressFee);
|
|
}
|
|
|
|
/**
|
|
* 列表
|
|
*/
|
|
@RequestMapping("/getMyOrderList")
|
|
public R getMyOrderList(@RequestParam Map<String, Object> params) {
|
|
PageUtils page = buyOrderService.getMyOrderList(params);
|
|
return R.ok().put("page", page);
|
|
}
|
|
|
|
|
|
/**
|
|
* 修改
|
|
*/
|
|
@RequestMapping("/update")
|
|
public R update(@RequestBody BuyOrder buyOrder) {
|
|
buyOrderService.updateById(buyOrder);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 删除
|
|
*/
|
|
@RequestMapping("/delete")
|
|
public R delete(@RequestBody Integer[] orderIds) {
|
|
buyOrderService.removeByIds(Arrays.asList(orderIds));
|
|
return R.ok();
|
|
}
|
|
|
|
|
|
/**
|
|
* app 端 取消订单
|
|
*/
|
|
@RequestMapping("/appDelete")
|
|
@Transactional
|
|
public R appDelete(@RequestParam("orderId") Integer orderId) {
|
|
|
|
//1. 判断订单状态
|
|
BuyOrder byId = buyOrderService.getById(orderId);
|
|
if (byId != null) {
|
|
//2. 判断当前订单是否存在优惠券 进行 回显
|
|
Integer couponId = byId.getCouponId();
|
|
if (couponId != null) {
|
|
|
|
CouponHistoryEntity byId1 = couponHistoryService.getById(couponId);
|
|
byId1.setUseStatus(0);
|
|
couponHistoryService.updateById(byId1);
|
|
}
|
|
// 库存回滚
|
|
List<BuyOrderDetail> buyOrderDetailEntities = buyOrderDetailService.getBaseMapper().selectList(new QueryWrapper<BuyOrderDetail>()
|
|
.eq("order_id", byId.getOrderId()));
|
|
for (BuyOrderDetail buyOrderDetailEntity : buyOrderDetailEntities) {
|
|
Integer productId = buyOrderDetailEntity.getProductId();
|
|
ShopProduct product = shopProductService.getById(productId);
|
|
product.setProductStock(product.getProductStock() + buyOrderDetailEntity.getQuantity());
|
|
shopProductService.updateById(product);
|
|
}
|
|
buyOrderService.removeById(orderId);
|
|
}
|
|
return R.ok();
|
|
}
|
|
|
|
|
|
/**
|
|
* 充值专用订单生成接口
|
|
*/
|
|
@RequestMapping("/rechargeSave")
|
|
@Transactional
|
|
public R rechargeSave(@RequestBody BuyOrder buyOrder) throws IOException {
|
|
String timeId = IdWorker.getTimeId().substring(0, 32);
|
|
buyOrder.setOrderSn(timeId);
|
|
buyOrderService.save(buyOrder);
|
|
//下单微信支付预付款订单
|
|
BuyOrder buyOrderEntity = buyOrderService.getBaseMapper().selectOne(new LambdaQueryWrapper<BuyOrder>().eq(BuyOrder::getOrderSn, timeId));
|
|
WechatPaymentInfo paymentInfo = new WechatPaymentInfo();
|
|
paymentInfo.setOrderSn(buyOrderEntity.getOrderSn());
|
|
paymentInfo.setBuyOrderId(Integer.valueOf(buyOrderEntity.getProductId()));
|
|
paymentInfo.setTotalAmount(buyOrderEntity.getRealMoney());
|
|
wxpayService.prepay(paymentInfo);
|
|
return R.ok().put("orderSn", timeId);
|
|
}
|
|
|
|
/**
|
|
* 获取订单详情
|
|
* TODO 新版本上线后删除
|
|
*
|
|
* @param orderId
|
|
* @return
|
|
*/
|
|
@RequestMapping("/getOrderDetail")
|
|
public R getOrderDetail(@RequestParam Integer orderId) {
|
|
LambdaQueryWrapper<BuyOrder> wrapper = new LambdaQueryWrapper<>();
|
|
wrapper.eq(BuyOrder::getOrderId, orderId);
|
|
BuyOrder one = buyOrderService.getOne(wrapper);
|
|
if (one.equals(null)) {
|
|
return R.error("order error:order is null");
|
|
}
|
|
//添加用户信息
|
|
one.setUser(myUserService.getById(one.getUserId()));
|
|
//添加商品信息
|
|
LambdaQueryWrapper<BuyOrderDetail> wrapper1 = new LambdaQueryWrapper<>();
|
|
wrapper1.eq(BuyOrderDetail::getOrderId, orderId);
|
|
List<BuyOrderDetail> buyOrderDetailEntities = buyOrderDetailService.getBaseMapper().selectList(wrapper1);
|
|
one.setProducts(buyOrderDetailEntities);
|
|
|
|
return R.ok().put("detail", one);
|
|
}
|
|
|
|
/**
|
|
* 获取订单详情
|
|
*
|
|
* @param orderId 订单 ID
|
|
* @return R
|
|
*/
|
|
@RequestMapping(value = "/getOrderInfo", method = RequestMethod.GET)
|
|
public R appGetOrderInfo(@RequestParam("orderId") Integer orderId) {
|
|
BuyOrder buyOrder = buyOrderService.getById(orderId);
|
|
QueryWrapper<BuyOrderDetail> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq("order_id", orderId);
|
|
List<BuyOrderDetail> buyOrderDetailList = buyOrderDetailService.list(queryWrapper);
|
|
|
|
for (BuyOrderDetail buyOrderDetail : buyOrderDetailList) {
|
|
ShopProduct prod = shopProductService.getById(buyOrderDetail.getProductId());
|
|
if (prod != null) {
|
|
buyOrderDetail.setImage(prod.getProductImages());
|
|
}
|
|
}
|
|
return R.ok().put("result", buyOrder);
|
|
}
|
|
|
|
@RequestMapping(value = "/modifyOrderAddress", method = RequestMethod.POST)
|
|
public R modifyOrderAddress(@RequestBody ShippingAddressRequestVo addressRequestVo) {
|
|
BuyOrder buyOrder = buyOrderService.getById(addressRequestVo.getOrderId());
|
|
buyOrder.setProvince(addressRequestVo.getProvince());
|
|
buyOrder.setCity(addressRequestVo.getCity());
|
|
buyOrder.setDistrict(addressRequestVo.getCounty());
|
|
buyOrder.setShippingUser(addressRequestVo.getName());
|
|
buyOrder.setUserPhone(addressRequestVo.getMobile());
|
|
buyOrderService.updateById(buyOrder);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 查询订单快递
|
|
*
|
|
* @param orderId 订单号
|
|
* @return R
|
|
*/
|
|
@RequestMapping(value = "/queryExpress", method = RequestMethod.GET)
|
|
public R queryExpress(@RequestParam("orderId") Integer orderId) {
|
|
QueryWrapper<BuyOrderDetail> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq("order_id", orderId);
|
|
List<BuyOrderDetail> buyOrderDetailList = buyOrderDetailService.list(queryWrapper);
|
|
List<ExpressQueryResponseVo> result = new ArrayList<>();
|
|
for (BuyOrderDetail buyOrderDetail : buyOrderDetailList) {
|
|
ExpressQueryResponseVo vo = new ExpressQueryResponseVo();
|
|
vo.setOrderDetailId(buyOrderDetail.getId());
|
|
ExpressQueryResponse expressQueryResponse = expressOrderService.queryExpressOrder(buyOrderDetail.getExpressCompanyCode(), buyOrderDetail.getExpressBillNo());
|
|
vo.setLogisticCode(expressQueryResponse.getLogisticCode());
|
|
vo.setTraces(expressQueryResponse.getTraces());
|
|
result.add(vo);
|
|
}
|
|
return R.ok().put("result", result);
|
|
}
|
|
|
|
/**
|
|
* 检查可合并的订单信息
|
|
*
|
|
* @return
|
|
*/
|
|
@RequestMapping("/checkOrder")
|
|
public R checkOrder(@RequestParam Map<String, Object> params) {
|
|
Page page = buyOrderService.checkOrder(params);
|
|
return R.ok().put("page", page);
|
|
}
|
|
|
|
/**
|
|
* 检查传来的orderId 是否有可合并的其他订单信息
|
|
*
|
|
* @param orderIds
|
|
* @return
|
|
*/
|
|
@RequestMapping("/checkMerge")
|
|
public R checkMerge(@RequestBody Integer[] orderIds) {
|
|
List list = buyOrderService.checkOrder(orderIds);
|
|
return R.ok().put("list", list);
|
|
}
|
|
|
|
/**
|
|
* 分包发货
|
|
*
|
|
* @param expressCompanyCode 快递公司编码
|
|
* @param buyOrderDetailId 订单详情列表
|
|
* @return R
|
|
*/
|
|
@RequestMapping(value = "/delivery", method = RequestMethod.POST)
|
|
public R delivery(@RequestParam("expressCompanyCode") String expressCompanyCode,
|
|
@RequestBody List<Integer> buyOrderDetailId) throws Exception {
|
|
buyOrderService.delivery(expressCompanyCode, buyOrderDetailId);
|
|
return R.ok();
|
|
|
|
}
|
|
|
|
/**
|
|
* 获取商品实际价格
|
|
*
|
|
* @param product 商品信息
|
|
* @return 商品实际价格
|
|
*/
|
|
private BigDecimal getRealPrice(ShopProduct product) {
|
|
BigDecimal activityPrice = product.getActivityPrice();
|
|
return (activityPrice == null || activityPrice.equals(BigDecimal.ZERO)) ? product.getPrice() : activityPrice;
|
|
}
|
|
|
|
/**
|
|
* 处理商品库存
|
|
*
|
|
* @param buyOrderDetail
|
|
* @param product
|
|
* @return
|
|
*/
|
|
private boolean handleStock(BuyOrderDetail buyOrderDetail, ShopProduct product) {
|
|
int quantity = buyOrderDetail.getQuantity();
|
|
if (product.getProductStock() - quantity < 0) {
|
|
return false;
|
|
}
|
|
product.setProductStock(product.getProductStock() - quantity);
|
|
product.setSumSales(product.getSumSales() + quantity);
|
|
shopProductService.updateById(product);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* 使用优惠券
|
|
*
|
|
* @param buyOrder
|
|
* @return
|
|
*/
|
|
private BigDecimal useCouponAmount(BuyOrder buyOrder) {
|
|
Integer couponId = buyOrder.getCouponId();
|
|
if (couponId != null) {
|
|
CouponHistoryEntity couponHistory = couponHistoryService.getById(couponId);
|
|
couponHistory.setUseStatus(1);
|
|
couponHistory.setUseTime(new Date());
|
|
couponHistory.setOrderId(Long.valueOf(buyOrder.getOrderId()));
|
|
couponHistory.setOrderSn(buyOrder.getOrderSn());
|
|
CouponEntity coupon = couponService.getById(couponHistory.getCouponId());
|
|
|
|
return coupon.getCouponAmount();
|
|
}
|
|
return BigDecimal.ZERO;
|
|
}
|
|
|
|
@RequestMapping("/modifyConsigneeAddress")
|
|
public R modifyConsigneeAddress(@RequestBody ModifyOrderAddressRequestVo requestVo) {
|
|
QueryWrapper<BuyOrder> queryWrapper = new QueryWrapper<>();
|
|
queryWrapper.eq("order_sn", requestVo.getOrderSn());
|
|
BuyOrder buyOrder = buyOrderService.getOne(queryWrapper);
|
|
buyOrder.setShippingUser(requestVo.getConsigneeName());
|
|
buyOrder.setUserPhone(requestVo.getConsigneeMobile());
|
|
buyOrder.setProvince(requestVo.getProvince());
|
|
buyOrder.setCity(requestVo.getCity());
|
|
buyOrder.setDistrict(requestVo.getCounty());
|
|
buyOrder.setAddress(requestVo.getAddress());
|
|
buyOrder.setAddressModified(1);
|
|
buyOrderService.updateById(buyOrder);
|
|
return R.ok();
|
|
}
|
|
|
|
/**
|
|
* 计算运费
|
|
*
|
|
* @param buyOrder
|
|
* @return
|
|
*/
|
|
private BigDecimal getShoppingAmount(BuyOrder buyOrder) {
|
|
return buyOrder.getOrderMoney() == null ? BigDecimal.ZERO : buyOrder.getShippingMoney();
|
|
}
|
|
|
|
/**
|
|
* 使用虚拟币支付
|
|
*
|
|
* @param user
|
|
* @param totalPrice
|
|
* @return
|
|
*/
|
|
private boolean usePeanutCoin(MyUserEntity user, BigDecimal totalPrice) {
|
|
if (user.getPeanutCoin().compareTo(totalPrice) >= 0) {
|
|
user.setPeanutCoin(user.getPeanutCoin().subtract(totalPrice));
|
|
this.myUserService.updateById(user);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* 交易记录
|
|
*
|
|
* @param buyOrder
|
|
* @param user
|
|
* @param totalPrice
|
|
*/
|
|
private void recordTransaction(BuyOrder buyOrder, MyUserEntity user, BigDecimal totalPrice) {
|
|
TransactionDetailsEntity transactionDetailsEntity = new TransactionDetailsEntity();
|
|
transactionDetailsEntity.setRemark("订单编号为 - " + buyOrder.getOrderSn());
|
|
transactionDetailsEntity.setUserId(user.getId());
|
|
transactionDetailsEntity.setUserName(user.getNickname());
|
|
transactionDetailsEntity.setChangeAmount(totalPrice.negate());
|
|
transactionDetailsEntity.setUserBalance(user.getPeanutCoin());
|
|
transactionDetailsEntity.setTel(user.getTel());
|
|
transactionDetailsEntity.setOrderType("购买商品");
|
|
transactionDetailsService.save(transactionDetailsEntity);
|
|
}
|
|
|
|
/**
|
|
* 给用户添加电子书
|
|
*
|
|
* @param products
|
|
* @param buyOrder
|
|
*/
|
|
private void addEbookToUser(List<BuyOrderDetail> products, BuyOrder buyOrder) {
|
|
List<Integer> productIds = products.stream().map(BuyOrderDetail::getProductId).collect(Collectors.toList());
|
|
for (Integer productId : productIds) {
|
|
List<Integer> collect = shopProductBookService.getBaseMapper().selectList(new LambdaQueryWrapper<ShopProductBookEntity>()
|
|
.eq(ShopProductBookEntity::getProductId, productId)
|
|
.eq(ShopProductBookEntity::getDelFlag, 0)).stream().map(ShopProductBookEntity::getBookId).collect(Collectors.toList());
|
|
userEbookBuyService.addBookForUser(buyOrder.getUserId(), collect);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 购物车
|
|
*
|
|
* @param buyOrder
|
|
* @param buyOrderDetail
|
|
*/
|
|
private void handleBuyCart(BuyOrder buyOrder, BuyOrderDetail buyOrderDetail) {
|
|
List<OrderCartEntity> orderCartList = orderCartService.getBaseMapper().selectList(new QueryWrapper<OrderCartEntity>()
|
|
.eq("user_id", buyOrder.getUserId()).eq("product_id", buyOrderDetail.getProductId()));
|
|
if (orderCartList.size() > 0) {
|
|
List<Integer> collect = orderCartList.stream().map(OrderCartEntity::getCartId).collect(Collectors.toList());
|
|
orderCartService.removeByIds(collect);
|
|
}
|
|
}
|
|
|
|
private MessagePostProcessor messagePostProcessor() {
|
|
return message -> {
|
|
//设置有效期30分钟
|
|
message.getMessageProperties().setExpiration(String.valueOf(30 * 60 * 1000));
|
|
return message;
|
|
};
|
|
}
|
|
|
|
}
|