4dkankan-center-user/src/main/java/com/fdkankan/ucenter/service/impl/OrderServiceImpl.java

package com.fdkankan.ucenter.service.impl;

import com.amazonaws.services.codecommit.model.OrderEnum;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.common.constant.TbStatus;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.ucenter.common.PageInfo;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.common.util.NumberUtils;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.ucenter.common.RedisKeyUtil;
import com.fdkankan.ucenter.constant.*;
import com.fdkankan.ucenter.entity.*;
import com.fdkankan.ucenter.mapper.IOrderMapper;
import com.fdkankan.ucenter.pay.alipay.sdk.AlipayService;
import com.fdkankan.ucenter.pay.wx.WXPay;
import com.fdkankan.ucenter.pay.wx.WXPayConstants;
import com.fdkankan.ucenter.pay.wx.WXPayDefaultConfig;
import com.fdkankan.ucenter.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.ucenter.util.DateUserUtil;
import com.fdkankan.ucenter.vo.request.CartParam;
import com.fdkankan.ucenter.vo.request.DownNumParam;
import com.fdkankan.ucenter.vo.request.OrderParam;
import com.fdkankan.ucenter.vo.request.PlaceOrderParam;
import com.fdkankan.ucenter.vo.response.GoodsSkuVo;
import com.fdkankan.ucenter.vo.response.OrderVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 订单表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-07-13
 */
@Service
public class OrderServiceImpl extends ServiceImpl<IOrderMapper, Order> implements IOrderService {

    @Autowired
    IUserService userService;
    @Autowired
    IOrderItemService orderItemService;
    @Autowired
    IInvoiceService invoiceService;
    @Autowired
    IIncrementOrderService incrementOrderService;
    @Autowired
    ICartService cartService;
    @Autowired
    IGoodsService goodsService;
    @Autowired
    IGoodsSkuService goodsSkuService;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    AlipayService alipayService;
    @Autowired
    IDownloadOrderService downloadOrderService;
    @Autowired
    IIncrementTypeService incrementTypeService;

    @Override
    public PageInfo pageList(OrderParam param) {
        User user = userService.getByUserName(param.getUserName());
        LambdaQueryWrapper<Order> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Order::getUserId,user.getId());
        wrapper.eq(Order::getPaymentStatus,"paid");
        wrapper.orderByDesc(Order::getOrderTime);
        Page<Order> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        List<OrderVo> orderVos = new ArrayList<>();
        for (Order record : page.getRecords()) {
            OrderVo orderVo = new OrderVo();
            BeanUtils.copyProperties(record,orderVo);

            Invoice invoice = invoiceService.getByOrderId(record.getId());
            orderVo.setInvoice(invoice);

            List<OrderItem> itemList = orderItemService.getByOrderId(record.getId());
            orderVo.setOrderItems(itemList);
            orderVos.add(orderVo);
        }
        Page<OrderVo> pageVo = new Page<>(param.getPageNum(),param.getPageSize());
        pageVo.setRecords(orderVos);
        pageVo.setTotal(page.getTotal());
        return PageInfo.PageInfo(pageVo);
    }

    @Override
    public GoodsSkuVo getIncrementOrDownloadPrice(OrderParam param) {
        return incrementOrderService.getDownloadPrice(param);
    }

    @Override
    public void cancel(Long orderId) {
        LambdaUpdateWrapper<Order> wrapper = new LambdaUpdateWrapper<>();
        wrapper.set(Order::getOrderStatus, OrderStatus.invalid)
                .eq(Order::getId,orderId);
        this.update(wrapper);
    }

    @Override
    public void receipt(Long orderId) {
        LambdaUpdateWrapper<Order> wrapper = new LambdaUpdateWrapper<>();
        wrapper.set(Order::getOrderStatus, OrderStatus.completed)
                .set(Order::getShippingStatus, ShippingStatus.received)
                .eq(Order::getId,orderId);
        this.update(wrapper);
    }

    @Override
    public Order placeOrder(PlaceOrderParam param) {
        List<Long> id = param.getGoods().parallelStream().map(CartParam::getId).collect(Collectors.toList());
        List<String> ids = new ArrayList<>();
        for (Long aLong : id) {
            ids.add(String.valueOf(aLong));
        }
        User user = userService.getByUserName(param.getUserName());
        cartService.deleteIds(ids);
        // 下单
        List<OrderItem> orderItemEntities = new ArrayList<>();
        OrderItem orderItemEntity = null;
        int goodsTotalCount = 0;
        BigDecimal goodsAmount = new BigDecimal(0);

        for(CartParam requestCart : param.getGoods()){
            goodsTotalCount += requestCart.getGoodsCount();

            Goods responseGoods = goodsService.getById(requestCart.getGoodsId());
            if (responseGoods == null){
                continue;
            }
            GoodsSku sku = goodsSkuService.getBySku(requestCart.getSkuSn());
            if (sku == null){
                throw new BusinessException(500,LoginConstant.ERROR_MSG);
            }
            orderItemEntity = new OrderItem();
            orderItemEntity.setExpressNum(null);
            orderItemEntity.setGoodsPrice(param.getAbroad().intValue() == 0 ? sku.getPrice() : sku.getDollarPrice());
            orderItemEntity.setGoodsId(requestCart.getGoodsId());
            orderItemEntity.setShippingStatus(ShippingStatus.unshipped.name());
            orderItemEntity.setExpressName("顺丰速运");
            orderItemEntity.setGoodsCount(requestCart.getGoodsCount());
            orderItemEntity.setGoodsName(responseGoods.getName());
            orderItemEntity.setGoodsSn(responseGoods.getGoodsSn());
            orderItemEntity.setRecStatus("A");
            orderItemEntity.setCreateTime(DateUserUtil.getDate(new Date()));
            orderItemEntity.setUpdateTime(DateUserUtil.getDate(new Date()));
            if (StringUtils.isNotEmpty(requestCart.getSkuSn())){
                orderItemEntity.setSkuSn(requestCart.getSkuSn());
            }
            orderItemEntities.add(orderItemEntity);

            goodsAmount = goodsAmount.add(orderItemEntity.getGoodsPrice().multiply(new BigDecimal(orderItemEntity.getGoodsCount())));
        }

        Order orderEntity = new Order();
        orderEntity.setOrderSn(NumberUtils.getOrderSn());
        orderEntity.setOrderTime(new Date());
        orderEntity.setOrderStatus(OrderStatus.unprocessed.name());
        orderEntity.setPaymentStatus(PaymentStatus.unpaid.name());
        orderEntity.setShippingStatus(ShippingStatus.unshipped.name());
        orderEntity.setPaymentTypeName(param.getPayType());
        orderEntity.setUserId(user.getId());
        orderEntity.setGoodsTotalCount(goodsTotalCount);
        orderEntity.setGoodsAmount(goodsAmount);
        orderEntity.setTotalAmount(goodsAmount);
        orderEntity.setPaidAmount(BigDecimal.ZERO);
        orderEntity.setExpressAmount(BigDecimal.ZERO);
        orderEntity.setDeliveryTypeName("快递运输");
        orderEntity.setRecStatus("A");
        orderEntity.setCreateTime(DateUserUtil.getDate(new Date()));
        orderEntity.setUpdateTime(DateUserUtil.getDate(new Date()));

        if (param.getReceiver() != null){
            orderEntity.setShipAddress(param.getReceiver().getShipAddress());
            orderEntity.setShipAreaPath(param.getReceiver().getShipAreaPath());
            orderEntity.setShipMobile(param.getReceiver().getShipMobile());
            orderEntity.setShipName(param.getReceiver().getShipName());
        }
        orderEntity.setAbroad(param.getAbroad());
        this.save(orderEntity);

        for (OrderItem entity : orderItemEntities){
            entity.setOrderId(orderEntity.getId());
        }
        orderItemService.saveBatch(orderItemEntities);

        if(param.getInvoice()!=null && StringUtils.isNotBlank(param.getInvoice().getInvoiceType())){
            param.setOrderId(orderEntity.getId());
            param.getInvoice().setAmount(orderEntity.getTotalAmount().toString());
            invoiceService.saveByOrder(user.getId(),param);
        }
        return orderEntity;
    }

    @Override
    public boolean queryOrderStatus(OrderParam param) throws Exception {
        boolean success = false;
        String orderSn = param.getOrderSn();
        switch (param.getOrderType()){
            case 0:
                orderSn += "_entity";
                break;
            case 1:
                orderSn += "_recharge";
                break;
            case 2:
                orderSn += "_expansion";
                break;
            case 3:
                orderSn += "_commerce";
                break;
            case 4:
                orderSn += "_increment";
                break;
            case 5:
                orderSn += "_download";
                break;
        }
        if(!redisUtil.hasKey(RedisKeyUtil.QRCODE + orderSn)){
            String wxPngPath =  QrCodeFilePath.WEIXIN_QRCODE_FOLDER + orderSn + ".png";
            String aliPngPath =  QrCodeFilePath.ALI_QRCODE_FOLDER + orderSn + ".png";
            FileUtils.deleteFile(wxPngPath);
            FileUtils.deleteFile(aliPngPath);
            throw new BusinessException(LoginConstant.FAILURE_CODE_3035,LoginConstant.FAILURE_MSG_3035);
        }
        switch (param.getPayType()){
            // 微信
            case 0:
                String orderSnE = redisUtil.get(orderSn);
                log.warn("out_trade_no：" + orderSnE);
                if (StringUtils.isNotEmpty(orderSnE)){
                    Map<String, String> data = new HashMap<String, String>();
                    data.put("out_trade_no", orderSnE);
                    WXPayDefaultConfig config = new WXPayDefaultConfig();
                    WXPay wxPay = new WXPay(config);
                    Map<String, String> resp = wxPay.orderQuery(data);
                    if (resp.get("trade_state") != null && resp.get("trade_state").equals(WXPayConstants.SUCCESS)) {
                        redisUtil.del(orderSnE);
                        success = true;
                    }
                }
                break;
            // 支付宝
            case 1:
                log.warn("alipay out_trade_no：" + orderSn);
                String type = alipayService.tradeQuery(orderSn);
                log.warn("alipay type：" + type);
                if ("SUCCESS".equals(type)){
                    success = true;
                }
                break;
            // paypal
            case 2:
                orderSn = orderSn.split("_")[0];
                log.warn("paypal out_trade_no：" + orderSn);
                Order orderEntity = this.getByOrderSn(orderSn);
                if (PaymentStatus.paid.name().equals(orderEntity.getPaymentStatus())){
                    success = true;
                }
                break;
        }
        return success;
    }

    @Override
    public Order getByOrderSn(String orderSn) {
        LambdaQueryWrapper<Order> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Order::getOrderSn,orderSn);
        return this.getOne(wrapper);
    }

    @Override
    public DownloadOrder downloadOrder(DownNumParam param) {
        //支付美金，只能paypal支付
        if(param.getAbroad() == 1 && param.getPayType() != 2){
            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }
        IncrementType incrementType = incrementTypeService.getById(param.getSkuSn());
        if(incrementType == null){
          throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }
//        GoodsSku goodsSku = goodsSkuService.getBySku(param.getSkuSn());
//        if(goodsSku == null){
//            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
//        }
        User user = userService.getByUserName(param.getUserName());
        if(user == null){
            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }

        return downloadOrderService.insertDownloadOrder(user.getId(),param,incrementType.getDownloadPrice());
    }

    @Override
    public IncrementOrder incrementOrder(DownNumParam param) {
        //支付美金，只能paypal支付
        if(param.getAbroad() == 1 && param.getPayType() != 2){
            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }
        User user = userService.getByUserName(param.getUserName());
        if(user == null){
            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }
        IncrementType incrementType = incrementTypeService.getById(param.getIncrementType());
        if(incrementType == null){
            throw new BusinessException(OrderConstant.FAILURE_CODE_8004, OrderConstant.FAILURE_MSG_8004);
        }
        return incrementOrderService.insertIncrementOrder(user.getId(), param,incrementType);
    }

    @Override
    public boolean paySuccessEntityOrder(String orderSn, String tradeNo, int paymentTypeName) {
        LambdaUpdateWrapper<Order> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.set(Order::getPaymentTypeName,paymentTypeName)
                .set(Order::getTradeNum,tradeNo)
                .set(Order::getPaymentStatus, PaymentStatus.paid.name())
                .eq(Order::getOrderSn,orderSn);
        return this.update(updateWrapper);
    }

    @Override
    public OrderVo getOrderDetail(Long orderId) {
        Order order = this.getById(orderId);
        OrderVo responseOrder = new OrderVo();
        if(order == null ){
            return responseOrder;
        }
        BeanUtils.copyProperties(order,responseOrder);

        List<OrderItem> responseOrderItems =orderItemService.getByOrderId(orderId);
        responseOrder.setOrderItems(responseOrderItems);

        Invoice invoice = invoiceService.getByOrderId(orderId);
        if(invoice != null){
            responseOrder.setInvoice(invoice);
        }
        return responseOrder;
    }

    @Override
    public void autoUpdateOrderStatus() {
        this.getBaseMapper().autoUpdateOrderStatus();
    }
}