新增积分付款模块

935090232@qq.com

2021-03-21 265a4d7ca3ee0c418a610db52fc862920140cafe

新增积分付款模块

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/action/WXShopOrderAction.java

@@ -2,40 +2,28 @@

import com.matrix.biz.bean.BizUser;
import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.component.tools.WxUtils;
import com.matrix.component.wechat.externalInterface.protocol.paramProtocol.BrandWCPayRequestData;
import com.matrix.component.wechat.externalInterface.weixinUtil.WeixinServiceUtil;
import com.matrix.core.constance.SystemErrorCode;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.constance.AppConstance;
import com.matrix.system.constance.Dictionary;
import com.matrix.system.hive.bean.ShoppingGoods;
import com.matrix.system.hive.dao.ShoppingGoodsDao;
import com.matrix.system.shopXcx.api.pojo.AddShopOrderPOJO;
import com.matrix.system.shopXcx.api.pojo.CreateOrderDto;
import com.matrix.system.shopXcx.api.pojo.OrderInfoQueryPOJO;
import com.matrix.system.shopXcx.api.pojo.ShopOrderDto;
import com.matrix.system.shopXcx.api.service.OrderCouponGroupService;
import com.matrix.system.shopXcx.api.service.ShoppingCartService;
import com.matrix.system.shopXcx.api.service.WXShopOrderService;
import com.matrix.system.shopXcx.api.service.WxShopCouponService;
import com.matrix.system.shopXcx.api.tools.WxShopCouponUtil;
import com.matrix.system.shopXcx.api.tools.WxShopOrderUtil;
import com.matrix.system.shopXcx.api.vo.CouponReceiveInfoVO;
import com.matrix.system.shopXcx.api.vo.ShopCartVo;
import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.bean.ShopOrder;
import com.matrix.system.shopXcx.dao.*;
import com.matrix.system.shopXcx.dto.DiscountExplain;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


/**
@@ -82,105 +70,25 @@
    private ShopOrderDetailsDao shopOrderDetailsDao;

    @Autowired
    OrderCouponGroupService orderCouponGroupService;

    @Autowired
    ShopOrderDao shopOrderDao;

    /**
     * 计算购物车订单价格
     *
     * @param addShopOrderPOJO
     * @param shopOrderDto
     * @return
     * @throws Exception
     */
    @PostMapping(value = "/calculationCartOrder")
    public
    @ResponseBody
    AjaxResult calculationCartOrder(@RequestBody AddShopOrderPOJO addShopOrderPOJO) throws Exception {
        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class); //计算购物车中物品的优惠信息

        List<ShopCartVo> cartList = shoppingCartService.findUserCartList(addShopOrderPOJO.getShopId(),ShopShoppingCart.CAR_TYPE_MICRO);
    AjaxResult calculationCartOrder(@RequestBody ShopOrderDto shopOrderDto) throws Exception {


        //取出购物车中选中的产品
        List<ShopShoppingCart> buyCart = new ArrayList<>();

        //取出购物车中没有参加店铺活动的产品，和参加了店铺活动但是活动没有达到标准的产品，用来计算是否可以使用优惠券
        List<ShopShoppingCart> notCouponuyCart = new ArrayList<>();
        for (ShopCartVo shopCartVo : cartList) {
            for (ShopShoppingCart shopShoppingCart : shopCartVo.getCartList()) {
                if (shopShoppingCart.getIsSelected() == 1) {
                    buyCart.add(shopShoppingCart);
                    if (shopCartVo.getCoupon() == null || !shopCartVo.isSatisfactionCoupon()) {
                        notCouponuyCart.add(shopShoppingCart);
                    }
                }
            }
        }
        //获取当前购物车产品可用的优惠券
        List<CouponReceiveInfoVO> usefulCoupon = wxShopCouponService.getCartVoCouponList(bizUser.getCompanyId(),notCouponuyCart);

        //获取用户使用的优惠券
        CouponReceiveInfoVO shopCoupon = new CouponReceiveInfoVO();
        if (addShopOrderPOJO.getCouponReceiveId() == null) {
            //如果用户没有选择优惠券则默认选优惠金额最高的
            //计算使用优惠券后的价格
            if (CollectionUtils.isNotEmpty(usefulCoupon)) {
                //根据优惠券ID用户ID查询优惠券信息
                shopCoupon = usefulCoupon.get(0);
            }
        } else if (addShopOrderPOJO.getCouponReceiveId() != 1) {
            //用户选择了优惠券
            shopCoupon = shopCouponRecordDao.selectMyCouponByReceiveId(addShopOrderPOJO.getCouponReceiveId());
        } else {
            //用户不使用优惠券
        }


        //计算收货地址：

        ShopReceiveAddress shopReceiveAddress = null;
        if (addShopOrderPOJO.getReceiveAddrId() == null) {
            //如果没有传收货地址则默认收货地址
            shopReceiveAddress = shopReceiveAddressDao.selectDefaultAddress(bizUser.getOpenId());
            if (shopReceiveAddress != null) {
                addShopOrderPOJO.setReceiveAddrId(shopReceiveAddress.getAddrId());
            }
        } else {
            shopReceiveAddress = shopReceiveAddressDao.selectById(addShopOrderPOJO.getReceiveAddrId());
            addShopOrderPOJO.setReceiveAddrId(shopReceiveAddress.getAddrId());

        }


        //得到订单计价说明
        DiscountExplain discountExplain = shopOrderService.buildDiscountExplain(cartList, shopCoupon.getReceiveId(), bizUser.getCompanyId());

        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, buyCart, buyCart.size());
        //结算金额信息
        result.putInMap("discountExplain", discountExplain);


        //用户优惠券
        result.putInMap("usefulCoupon", usefulCoupon);
        //用户选中的优惠券
        result.putInMap("shopCoupon", shopCoupon);


        //默认地址
        String deliverySelect = "立即配送";
        if (shopReceiveAddress != null) {
            if (StringUtils.isNotBlank(shopReceiveAddress.getSchool())) {
                deliverySelect = "立即配送";
            } else {
                deliverySelect = "物流配送";
            }
        }
        result.putInMap("defaultAddress", shopReceiveAddress);
        //配送方式
        result.putInMap("deliverySelect", deliverySelect);


        result.setRows(buyCart);
        return result;
        return shopOrderService.buildDiscountExplain(shopOrderDto);
    }


@@ -190,129 +98,17 @@
    /**
     * 新增订单
     *
     * @param addShopOrderPOJO
     * @param shopOrderDto
     * @return
     */
    @PostMapping(value = "/addShopOrder")
    public
    @ResponseBody
    AjaxResult addShopOrder(@RequestBody AddShopOrderPOJO addShopOrderPOJO) throws Exception {
        return shopOrderService.createShopOrder(addShopOrderPOJO);
    AjaxResult addShopOrder(@RequestBody ShopOrderDto shopOrderDto) throws Exception {
        return shopOrderService.createShopOrder(shopOrderDto);
    }


    /**
     * 新增订单
     * 本方法抛弃，不再使用，本方法是单单个产品购买
     * 在多产品的时候不适合
     * @return
     */
    @Deprecated
    @PostMapping(value = "/addShopOrder2")
    public
    @ResponseBody
    AjaxResult addShopOrder2(@RequestBody CreateOrderDto createOrderDto) throws Exception {


        //校验收货地址
        ShopReceiveAddress shopReceiveAddress = shopReceiveAddressDao.selectById(createOrderDto.getReceiveAddrId());
        if (shopReceiveAddress == null) {
            return new AjaxResult(AjaxResult.STATUS_FAIL, "请选择正确的收获地址");
        }


        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class);
        ShopSku shopSku = shopSkuDao.selectById(createOrderDto.getSkuId());
        ShopProduct shopProduct = shopProductDao.selectById(createOrderDto.getProductId());
        String stokCode = shopSku.getStockCode();

        ShopOrder shopOrder = new ShopOrder();
        //查询绑定的产品是否为家居产品
        if (StringUtils.isNotBlank(stokCode)) {
            ShoppingGoods shoppingGoods = shoppingGoodsDao.selectById(Long.parseLong(stokCode));
            if (shoppingGoods != null) {
                //根据购买的产品设置订单类型
                if (Dictionary.SHOPPING_GOODS_TYPE_JJCP.equals(shoppingGoods.getGoodType())) {
                    shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
                } else {
                    shopOrder.setOrderType(ShopOrder.ORDER_TYPE_SERVICE);
                }
            } else {
                shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
            }
        }

        List<ShopOrderDetails> details = new ArrayList<>();
        Integer cartCount = 0;
        ShopOrderDetails shopOrderDetails = new ShopOrderDetails();
        shopOrderDetails.setCreateBy(AppConstance.SYSTEM_USER);
        shopOrderDetails.setUpdateBy(AppConstance.SYSTEM_USER);
        shopOrderDetails.setpId(createOrderDto.getProductId());
        shopOrderDetails.setsId(createOrderDto.getSkuId());
        shopOrderDetails.setPrice(shopSku.getPrice());
        shopOrderDetails.setCount(createOrderDto.getNumber());
        shopOrderDetails.setsTitle(shopProduct.getTitle() + shopSku.getName());
        shopOrderDetails.setDiscountAmount(BigDecimal.ZERO);
        shopOrderDetails.setTotalPrice(shopOrderDetails.getPrice().multiply(BigDecimal.valueOf(shopOrderDetails.getCount())));
        details.add(shopOrderDetails);
        cartCount += shopOrderDetails.getCount();


        //TODO 更新库存和销量[考虑和erp库存联动]
        wxShopOrderUtil.updateProductAndSkuInfo(details);

        //用户openId
        shopOrder.setUserId(bizUser.getOpenId());
        shopOrder.setCreateBy("微信小程序生成");
        shopOrder.setUpdateBy("微信小程序生成");
        shopOrder.setCommodityPrice(shopOrderDetails.getTotalPrice());
        shopOrder.setPurchaseQuantity(cartCount);
        //购买方式
        shopOrder.setShippingMethod("物流配送");
        //生成订单号
        shopOrder.setOrderNo(WxUtils.getOrderNum());
        //设置支付状态
        shopOrder.setPayStatus(ShopOrder.ORDER_STATUS_WAIT_PAY);
        //设置订单状态
        shopOrder.setOrderStatus(ShopOrder.ORDER_STATUS_WAIT_SEND);

        //设置退款费用(注：下次优化从数据字典表获取)
        shopOrder.setRefundCharge(BigDecimal.ZERO);
        //客户电话
        shopOrder.setUserTel(shopReceiveAddress.getAddrTelephone());
        //客户姓名
        shopOrder.setUserName(shopReceiveAddress.getAddrLiaisonman());
        //备注
        shopOrder.setRemarks(createOrderDto.getRemarks());
        //删除标识
        shopOrder.setDelFlag(AppConstance.DATA_USEABLE);
        //微信订单号
        shopOrder.setWxOrderNo("");
        //微信支付结果
        shopOrder.setPayResult(ShopOrder.ORDER_WX_STATUS_WAIT_PAY);
        //如果没有提交购买方式或配送方式不是物流
        //获取邮费
        shopOrder.setOrderMoney(shopOrderDetails.getTotalPrice());
        shopOrder.setStoreId(createOrderDto.getShopId());

        shopOrderDao.insert(shopOrder);

        wxShopOrderUtil.insertSendPackageInfo(shopOrder, "物流配送", shopReceiveAddress);

        //给订单详情表添加订单ID
        shopOrderDetails.setOrderId(shopOrder.getId());

        shopOrderDetailsDao.insert(shopOrderDetails);


        BrandWCPayRequestData payData = startPayment(shopOrder);
        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, Arrays.asList(payData));
        result.putInMap("orderId", shopOrder.getId());

        return result;


    }

    @Value("${wx_pay_debug_onoff}")
    private boolean isDebug;

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/action/WxShoppingCartAction.java

@@ -9,6 +9,7 @@
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.constance.AppConstance;
import com.matrix.system.common.interceptor.HostInterceptor;
import com.matrix.system.shopXcx.api.service.OrderCouponGroupService;
import com.matrix.system.shopXcx.api.service.ShoppingCartService;
import com.matrix.system.shopXcx.api.service.WxShopCouponService;
import com.matrix.system.shopXcx.api.vo.ShopCartBillVo;
@@ -51,7 +52,8 @@
    @Autowired
    ShopSkuDao skuDao;


    @Autowired
    OrderCouponGroupService orderCouponGroupService;

    @ApiOperation(value = "根据ID删除购物车", notes = "")
    @PostMapping("/deleteByCartId/{cartId}")
@@ -69,9 +71,12 @@
    @PostMapping("/findShoppingCart")
    @ResponseBody
    public AjaxResult getShoppingCartByUserId(@RequestBody ShopShoppingCart shoppingCart) {
        List<ShopCartVo> cartList = shoppingCartService.findUserCartList(shoppingCart.getShopId(),ShopShoppingCart.CAR_TYPE_MICRO);
        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, cartList, cartList.size());
        ShopCartBillVo shopCartBill = shoppingCartService.buildShopCartBillVo(cartList);
        BizUser loginUser = redisUserLoginUtils.getLoginUser(BizUser.class);
        String userId = loginUser.getOpenId();
        List<ShopShoppingCart> list = shoppingCartDao.selectByCartUserId(shoppingCart.getShopId(),userId);
        List<ShopCartVo> shopCartVoList = shoppingCartService.buildShopCart(list);
        AjaxResult result = new AjaxResult(AjaxResult.STATUS_SUCCESS, shopCartVoList, shopCartVoList.size());
        ShopCartBillVo shopCartBill = shoppingCartService.buildShopCartBillVo(shopCartVoList);
        result.putInMap("billTotal", shopCartBill.getBillTotal().stripTrailingZeros().toPlainString());
        result.putInMap("selectCount", shopCartBill.getSelectCount());
        result.putInMap("cartCount", shopCartBill.getCartCount());
@@ -119,9 +124,9 @@
    AjaxResult saveShoppingCart(@RequestBody ShopShoppingCart shoppingCart) {

        //查询到sku设置对应的产品id
        ShopSku sku= skuDao.selectById(shoppingCart.getCartSkuId());
        if(sku==null){
            return new AjaxResult(AjaxResult.STATUS_FAIL,"无效的产品id");
        ShopSku sku = skuDao.selectById(shoppingCart.getCartSkuId());
        if (sku == null) {
            return new AjaxResult(AjaxResult.STATUS_FAIL, "无效的产品id");
        }

        shoppingCart.setCartProductId(sku.getpId());
@@ -274,7 +279,7 @@
    public AjaxResult updateCartAllSelected(@PathVariable("isSelected") Integer isSelected,
                                            @PathVariable("shopId") Long shopId) {
        BizUser user = redisUserLoginUtils.getLoginUser(BizUser.class);
        shoppingCartDao.updateAllSelected(user.getOpenId(),shopId, isSelected);
        shoppingCartDao.updateAllSelected(user.getOpenId(), shopId, isSelected);
        return new AjaxResult(AjaxResult.STATUS_SUCCESS, "修改成功");
    }
}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/AddShopOrderPOJO.java

File was deleted

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/CalculatePostagePOJO.java

@@ -19,7 +19,7 @@
    /**
     * 购买规格信息列表
     */
    private List<OrderProductSkuPOJO> skuList;
    private List<OrderItemDto> skuList;


    public Integer getAddrId() {
@@ -38,11 +38,11 @@
        this.couponId = couponId;
    }

    public List<OrderProductSkuPOJO> getSkuList() {
    public List<OrderItemDto> getSkuList() {
        return skuList;
    }

    public void setSkuList(List<OrderProductSkuPOJO> skuList) {
    public void setSkuList(List<OrderItemDto> skuList) {
        this.skuList = skuList;
    }


 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/OrderCouponGroup.java

New file
@@ -0,0 +1,43 @@
package com.matrix.system.shopXcx.api.pojo;

import com.matrix.system.shopXcx.api.vo.CouponReceiveInfoVO;
import com.matrix.system.shopXcx.bean.ShopCoupon;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;

/**
 * 购物车前台展示对象
 */
@Data
public class OrderCouponGroup {

    private ShopCoupon coupon;

    //是否满足优惠
    private boolean satisfactionCoupon;

    private List<OrderItemDto> orderItemDtos;

    //提示语
    private String msg="";

    //优惠小计金额
    private BigDecimal subtotal=BigDecimal.ZERO;

    //原价
    private BigDecimal srcPrice=BigDecimal.ZERO;

    //优惠金额
    private BigDecimal  couponPrice=BigDecimal.ZERO;
    /**
     * 抵用积分
     */
    private BigDecimal scorePay = BigDecimal.ZERO;

    private CouponReceiveInfoVO couponReceiveInfoVO;



}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/OrderItemDto.java

New file
@@ -0,0 +1,47 @@
package com.matrix.system.shopXcx.api.pojo;

import com.matrix.system.shopXcx.bean.ShopCoupon;
import com.matrix.system.shopXcx.bean.ShopProduct;
import com.matrix.system.shopXcx.bean.ShopSku;
import lombok.Data;

import java.util.List;

/**
 * @author jyy
 */
@Data
public class OrderItemDto {
    /**
     * 产品ID
     */
    private Integer  productId;
    /**
     *  产品规格ID
     */
    private Integer skuId;
    
    private ShopProduct shopProduct;

    private ShopSku shopSku;
    
    /**
     *  购买数量
     */
    private Integer count;

    /**
     * 支付方式1 直接购买 2，积分兑换
     */
    private Integer  payType;

    /**
     * 购物车id
     */
    private Integer cartId;


    private List<ShopCoupon> shopCoupons;
    

}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/OrderProductSkuPOJO.java

File was deleted

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/pojo/ShopOrderDto.java

New file
@@ -0,0 +1,52 @@
package com.matrix.system.shopXcx.api.pojo;

import lombok.Data;

import java.util.List;

/**
 * @author jyy
 */
@Data
public class ShopOrderDto {


    public static final Integer JOIN_ACTIVE = 1;
    /**
     *  收货地址ID
     */
    private Integer receiveAddrId;

    /**
     *  配送方式（1=物流，2=门店自取）
     */
    private String deliverySelect;

    /**
     *  配送门店ID
     */
    private Long shopId;

    /**
     *  优惠券记录id
     */
    private Integer couponReceiveId;

    /**
     *  参加店铺活动 1参加 2不参加
     */
    private Integer joinActive;



    /**
     *  订单备注
     */
    private String  remarks;

    /**
     *  购买商品规格列表详情
     */
    private List<OrderItemDto> orderItemList;

}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/OrderCouponGroupService.java

New file
@@ -0,0 +1,282 @@
package com.matrix.system.shopXcx.api.service;

import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.tools.LogUtil;
import com.matrix.system.common.dao.BusParameterSettingsDao;
import com.matrix.system.shopXcx.api.pojo.OrderCouponGroup;
import com.matrix.system.shopXcx.api.pojo.OrderItemDto;
import com.matrix.system.shopXcx.bean.ShopCoupon;
import com.matrix.system.shopXcx.bean.ShopShoppingCart;
import com.matrix.system.shopXcx.dao.ShopProductDao;
import com.matrix.system.shopXcx.dao.ShopShoppingCartDao;
import com.matrix.system.shopXcx.dao.ShopSkuDao;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

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

/**
 * 购物车前台展示对象
 */
@Service
public class OrderCouponGroupService {
    @Autowired
    private ShopShoppingCartDao shoppingCartDao;
    @Autowired
    private RedisUserLoginUtils redisUserLoginUtils;

    @Autowired
    WxShopCouponService shopCouponService;

    @Autowired
    BusParameterSettingsDao busParameterSettingsDao;

    @Autowired
    ShopProductDao shopProductDao;

    @Autowired
    ShopSkuDao shopSkuDao;

    /**
     * 初始化OrderCouponElement
     * @param skuId
     * @param count
     * @param payType
     * @return
     */
    public OrderItemDto buildOrderCouponElement(OrderItemDto orderItemDto){
        orderItemDto.setShopSku(shopSkuDao.selectById(orderItemDto.getSkuId()));
        orderItemDto.setShopProduct(shopProductDao.selectById(orderItemDto.getProductId()));
        return orderItemDto;
    }

    /**
     * 计算用户的产品可以参与的店铺优惠活动分组
     */
    public List<OrderCouponGroup> buildOrderCouponGroupList(List<OrderItemDto> list) {

        //定义购物车优惠分组
        List<OrderCouponGroup> orderCouponGroupList = new ArrayList<>();
        // 1表示没有优惠的默认分组
        OrderCouponGroup def = new OrderCouponGroup();
        def.setSatisfactionCoupon(true);
        def.setMsg("商城");
        def.setOrderItemDtos(new ArrayList<>());
        // 组合默认分组
        orderCouponGroupList.add(def);

        // 记录所有优惠券，一个优惠券（活动）表示一组
        Map<Integer, ShopCoupon> shopCouponMap = new HashMap<>();

        //查询购物车中的产品匹配上的所有优惠活动
        for (OrderItemDto orderItemDto : list) {

            if(orderItemDto.getPayType()== ShopShoppingCart.CAR_TYPE_SCORE){
                // 积分兑换产品不参加优惠
                def.getOrderItemDtos().add(orderItemDto);
            }else{
                List<ShopCoupon> shopCouponList = shopCouponService.getHdListByProductId(orderItemDto.getProductId());
                if (CollectionUtils.isNotEmpty(shopCouponList)) {
                    // 把所有的优惠券和购物车条目先关联一下,后续可以计算优惠升级的情况
                    orderItemDto.setShopCoupons(shopCouponList);
                    for (ShopCoupon shopCoupon : shopCouponList) {
                        shopCouponMap.put(shopCoupon.getId(), shopCoupon);
                    }
                } else {
                    // 该产品没有参加优惠券
                    def.getOrderItemDtos().add(orderItemDto);
                }
            }

        }

        //计算没有优惠组的价格
        countPrice(def);


        /*
         * 计算优惠券分组 1、获取到所有的优惠券，从最高满减开始，找寻合适的产品，找到后加入对应的购物车组
         * 2、计算组内价格
         */
        Set<Integer> keys = shopCouponMap.keySet();
        List<ShopCoupon> allShopCoupons = new ArrayList<>();
        for (Integer key : keys) {
            allShopCoupons.add(shopCouponMap.get(key));
        }

        //根据优惠力度排序，优惠力度大的先参与计算
        Collections.sort(allShopCoupons, new Comparator() {
            @Override
            public int compare(Object o1, Object o2) {
                ShopCoupon e1 = (ShopCoupon) o1;
                ShopCoupon e2 = (ShopCoupon) o2;
                return e2.getMinAmount().compareTo(e1.getMinAmount());
            }
        });


        // 进行购物车和优惠券的匹配，匹配成功的加入到优惠组中，
        for (int i = 0; i < allShopCoupons.size(); i++) {
            ShopCoupon shopCoupon = allShopCoupons.get(i);
            OrderCouponGroup shopCarVo = new OrderCouponGroup();
            shopCarVo.setCoupon(shopCoupon);
            shopCarVo.setOrderItemDtos(new ArrayList<>());
            orderCouponGroupList.add(i, shopCarVo);

            // 获取所有购物车条目
            for (OrderItemDto orderItemDto : list) {
                // 如果匹配到的产品已经出现在其他优惠组中，则需要判断是否移除之前的组
                boolean needRemove = false;

                // 判断当前购物车条目是否已经在合适的组里了
                if (isInGroupAndSatisfaction(orderItemDto, orderCouponGroupList)) {
                    continue;

                } else if (isInGroupNotSatisfaction(orderItemDto, orderCouponGroupList)) {
                    needRemove = true;
                }

                List<ShopCoupon> cartCouons = orderItemDto.getShopCoupons();
                if (cartCouons != null) {
                    // 获取每个购物车条目满足的优惠
                    for (ShopCoupon cartCouon : cartCouons) {
                        if (cartCouon.getId().equals(shopCoupon.getId())) {
                            //匹配成功，加入本组
                            LogUtil.debug("购物车" + orderItemDto.getProductId() + "和优惠券" + cartCouon.getCName() + "匹配");
                            if (needRemove) {
                                removeNotSatisfaction(orderItemDto, orderCouponGroupList);
                            }
                            shopCarVo.getOrderItemDtos().add(orderItemDto);
                            break;
                        }
                    }
                }

            }

            // 计算本组优惠券是否已经满足优惠条件
            countPrice(shopCarVo);
        }


        // 因为有些优惠中可能没有产品，所以要去除cartList中没有产品的分组
        List<OrderCouponGroup> cartListCopy = new ArrayList<>();
        for (OrderCouponGroup orderCouponGroup : orderCouponGroupList) {
            if (CollectionUtils.isNotEmpty(orderCouponGroup.getOrderItemDtos())) {
                cartListCopy.add(orderCouponGroup);
            }
        }
        return cartListCopy;
    }


    /**
     * 购车条目在组中并且组是否已经满足优惠的
     *
     * @param cartList
     * @return
     */
    private boolean isInGroupAndSatisfaction(OrderItemDto orderItemDto, List<OrderCouponGroup> cartList) {
        boolean result = false;
        for (OrderCouponGroup cartVo : cartList) {
            if (cartVo.isSatisfactionCoupon() && cartVo.getOrderItemDtos().contains(orderItemDto)) {
                result = true;
            }
        }
        return result;
    }

    /**
     * 购物车条目在组中，但是组中产品没有达到优惠条件
     * @param cartList
     * @return
     */
    private boolean isInGroupNotSatisfaction(OrderItemDto orderItemDto, List<OrderCouponGroup> cartList) {
        boolean result = false;
        for (OrderCouponGroup cartVo : cartList) {
            if (!cartVo.isSatisfactionCoupon() && cartVo.getOrderItemDtos().contains(orderItemDto)) {
                result = true;
            }
        }
        return result;
    }

    /**
     * 删除购物车条目所在分组中的引用
     *
     * @param cartList
     */
    private void removeNotSatisfaction(OrderItemDto orderItemDto, List<OrderCouponGroup> cartList) {
        for (OrderCouponGroup cartVo : cartList) {
            if (cartVo.getOrderItemDtos().remove(orderItemDto)) {
                LogUtil.debug("删除购物车所在组" + cartVo.getCoupon().getCName() + "," + orderItemDto.getProductId());
            }
        }
    }

    /**
     * 计算购物车价格和优惠信息
     *
     * @author JIANGYOUYAO
     * @email 935090232@qq.com
     * @date 2019年8月27日
     */
    private void countPrice(OrderCouponGroup orderCouponGroup) {
        List<OrderItemDto> orderItemDtoList = orderCouponGroup.getOrderItemDtos();
        // 计算总价
        BigDecimal sum = BigDecimal.ZERO;
        //抵扣总积分
        BigDecimal scoreSum = BigDecimal.ZERO;

        for (OrderItemDto orderCouponElement : orderItemDtoList) {
            if(ShopShoppingCart.CAR_TYPE_MICRO==orderCouponElement.getPayType()){
                //直接购买
                sum = sum.add(orderCouponElement.getShopSku().getPrice().multiply(BigDecimal.valueOf(orderCouponElement.getCount())));

            }else if(ShopShoppingCart.CAR_TYPE_SCORE==orderCouponElement.getPayType()){
                //积分兑换
                sum = sum.add(orderCouponElement.getShopSku().getScorePrice().multiply(BigDecimal.valueOf(orderCouponElement.getCount())));
                scoreSum = scoreSum.add(new BigDecimal(orderCouponElement.getShopSku().getScoreCount() * orderCouponElement.getCount()));
            }else{
                throw new GlobleException("参数错误");
            }
        }

        if (orderCouponGroup.getCoupon() != null) {
            // 存在优惠券
            if (sum.compareTo(orderCouponGroup.getCoupon().getMinAmount()) >= 0) {
                //标记为合理分组
                orderCouponGroup.setSatisfactionCoupon(true);
                if (sum.compareTo(orderCouponGroup.getCoupon().getMinAmount()) >= 0) {
                    orderCouponGroup.setSubtotal(sum.subtract(orderCouponGroup.getCoupon().getOffsetAmount()));
                    orderCouponGroup.setSrcPrice(sum);
                    orderCouponGroup.setCouponPrice(orderCouponGroup.getCoupon().getOffsetAmount());
                    orderCouponGroup.setMsg(orderCouponGroup.getCoupon().getCName() + ",已优惠"
                            + orderCouponGroup.getCoupon().getOffsetAmount().stripTrailingZeros().toPlainString() + "元");
                }
            }
            if (sum.compareTo(orderCouponGroup.getCoupon().getMinAmount()) < 0) {
                orderCouponGroup.setSatisfactionCoupon(false);
                orderCouponGroup.setSubtotal(sum);
                orderCouponGroup.setSrcPrice(sum);
                orderCouponGroup.setMsg(orderCouponGroup.getCoupon().getCName());
                if (sum.doubleValue() > 0) {
                    orderCouponGroup.setMsg(orderCouponGroup.getCoupon().getCName() + ",再买"
                            + (orderCouponGroup.getCoupon().getMinAmount().subtract(sum)).stripTrailingZeros()
                            .toPlainString()
                            + "元立减" + orderCouponGroup.getCoupon().getOffsetAmount().stripTrailingZeros().toPlainString()
                            + "元");
                }
            }
        } else {
            orderCouponGroup.setSubtotal(sum);
            orderCouponGroup.setSrcPrice(sum);
            orderCouponGroup.setSatisfactionCoupon(true);
        }
        orderCouponGroup.setScorePay(scoreSum);
    }

}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/ShoppingCartService.java

@@ -1,8 +1,6 @@
package com.matrix.system.shopXcx.api.service;

import com.matrix.biz.bean.BizUser;
import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.tools.LogUtil;
import com.matrix.system.common.dao.BusParameterSettingsDao;
import com.matrix.system.shopXcx.api.vo.ShopCartBillVo;
@@ -33,7 +31,7 @@
    @Autowired
    BusParameterSettingsDao busParameterSettingsDao;


    //计算购车选中项总价以及优惠金额
    public ShopCartBillVo buildShopCartBillVo(List<ShopCartVo> cartList) {

        ShopCartBillVo shopCartBillVo = new ShopCartBillVo();
@@ -65,23 +63,10 @@
        }
        shopCartBillVo.setCartCount(cartCount);
        shopCartBillVo.setSelectCount(selectCount);

        return shopCartBillVo;
    }

    /**
     * 计算用户的购物车产品优惠分组
     *
     * @return
     * @param shopId
     */
    public List<ShopCartVo> findUserCartList(Long shopId,Integer cartType) {
        BizUser loginUser = redisUserLoginUtils.getLoginUser(BizUser.class);
        String userId = loginUser.getOpenId();
        List<ShopShoppingCart> list = shoppingCartDao.selectByCartUserId(shopId,userId,cartType);
        List<ShopCartVo> cartList = buildShopCart(list);
        return cartList;
    }



    /**
@@ -91,7 +76,7 @@
     * @return
     */
    @SuppressWarnings("unchecked")
    private List<ShopCartVo> buildShopCart(List<ShopShoppingCart> list) {
    public List<ShopCartVo> buildShopCart(List<ShopShoppingCart> list) {


        //定义购物车优惠分组
@@ -112,23 +97,19 @@
        //查询购物车中的产品匹配上的所有优惠活动
        for (ShopShoppingCart shoppingCart : list) {

            if(shoppingCart.getCartType()==ShopShoppingCart.CAR_TYPE_SCORE){
                // 积分兑换产品不参加优惠
                def.getCartList().add(shoppingCart);
            }else{
                List<ShopCoupon> shopCoupons = shopCouponService.getHdListByProductId(shoppingCart.getCartProductId());
                if (CollectionUtils.isNotEmpty(shopCoupons)) {
                    // 把所有的优惠券和购物车条目先关联一下,后续可以计算优惠升级的情况
                    shoppingCart.setShopCoupons(shopCoupons);
                    for (ShopCoupon shopCoupon : shopCoupons) {
                        shopCouponMap.put(shopCoupon.getId(), shopCoupon);
                    }
                } else {
                    // 该产品没有参加优惠券
                    def.getCartList().add(shoppingCart);
                }
            }
            List<ShopCoupon> shopCoupons = shopCouponService.getHdListByProductId(shoppingCart.getCartProductId());

            if (CollectionUtils.isNotEmpty(shopCoupons)) {
                // 把所有的优惠券和购物车条目先关联一下,后续可以计算优惠升级的情况
                shoppingCart.setShopCoupons(shopCoupons);
                for (ShopCoupon shopCoupon : shopCoupons) {
                    shopCouponMap.put(shopCoupon.getId(), shopCoupon);
                }
            } else {
                // 该产品没有参加优惠券
                def.getCartList().add(shoppingCart);

            }
        }

        //计算没有优惠组的价格
@@ -270,28 +251,13 @@
        List<ShopShoppingCart> cartList = shopCartVo.getCartList();
        // 计算总价
        BigDecimal sum = BigDecimal.ZERO;
        //抵扣总积分
        BigDecimal scoreSum = BigDecimal.ZERO;
        // 选中项总价
        BigDecimal selectSum = BigDecimal.ZERO;
        for (ShopShoppingCart shopShoppingCart : cartList) {
            if(ShopShoppingCart.CAR_TYPE_MICRO==shopShoppingCart.getCartType()){
                //直接购买
                sum = sum.add(shopShoppingCart.getPrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
                if (shopShoppingCart.getIsSelected() == 1) {
                    selectSum = selectSum
                            .add(shopShoppingCart.getPrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
                }
            }else if(ShopShoppingCart.CAR_TYPE_SCORE==shopShoppingCart.getCartType()){
                //积分兑换
                sum = sum.add(shopShoppingCart.getScorePrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
                if (shopShoppingCart.getIsSelected() == 1) {
                    selectSum = selectSum
                            .add(shopShoppingCart.getScorePrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
                    scoreSum = scoreSum.add(new BigDecimal(shopShoppingCart.getScoreCount() * shopShoppingCart.getCartNumber()));
                }
            }else{
                throw new GlobleException("参数错误");
            sum = sum.add(shopShoppingCart.getPrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
            if (shopShoppingCart.getIsSelected() == 1) {
                selectSum = selectSum
                        .add(shopShoppingCart.getPrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
            }
        }

@@ -322,10 +288,9 @@
                }
            }
        } else {
                shopCartVo.setSubtotal(selectSum);
                shopCartVo.setSrcPrice(selectSum);
                shopCartVo.setSatisfactionCoupon(true);
            shopCartVo.setSubtotal(selectSum);
            shopCartVo.setSrcPrice(selectSum);
            shopCartVo.setSatisfactionCoupon(true);
        }
        shopCartVo.setScorePay(scoreSum);
    }
}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/WXShopOrderService.java

@@ -1,15 +1,12 @@
package com.matrix.system.shopXcx.api.service;

import com.matrix.core.pojo.AjaxResult;
import com.matrix.component.wechat.externalInterface.protocol.paramProtocol.BrandWCPayRequestData;
import com.matrix.system.shopXcx.bean.ShopOrder;
import com.matrix.system.shopXcx.dto.DiscountExplain;
import com.matrix.system.shopXcx.api.pojo.AddShopOrderPOJO;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.system.shopXcx.api.pojo.OrderInfoQueryPOJO;
import com.matrix.system.shopXcx.api.vo.ShopCartVo;
import com.matrix.system.shopXcx.api.pojo.ShopOrderDto;
import com.matrix.system.shopXcx.bean.ShopOrder;

import java.math.BigDecimal;
import java.util.List;

/**
 * @author jyy
@@ -22,11 +19,11 @@

    /**
     * 创建订单
     * @param addShopOrderPOJO
     * @param shopOrderDto
     * @return
     * @throws Exception
     */
    AjaxResult createShopOrder(AddShopOrderPOJO addShopOrderPOJO) throws Exception;
    AjaxResult createShopOrder(ShopOrderDto shopOrderDto) throws Exception;

    /**
     * 订单结算
@@ -93,5 +90,5 @@
     */
    AjaxResult updateStockAndVolumeById(Integer orderId);

    DiscountExplain buildDiscountExplain(List<ShopCartVo> cartList, Integer id, Long companyId);
    AjaxResult buildDiscountExplain(ShopOrderDto shopOrderDto);
}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/WxShopCouponService.java

@@ -2,9 +2,9 @@

import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.pojo.PaginationVO;
import com.matrix.system.shopXcx.bean.ShopCoupon;
import com.matrix.system.shopXcx.bean.ShopShoppingCart;
import com.matrix.system.shopXcx.api.pojo.OrderItemDto;
import com.matrix.system.shopXcx.api.vo.CouponReceiveInfoVO;
import com.matrix.system.shopXcx.bean.ShopCoupon;

import java.util.List;

@@ -18,7 +18,7 @@
     * 根据购物车选中的产品
     * @return
     */
    public List<CouponReceiveInfoVO> getCartVoCouponList(Long companyId,List<ShopShoppingCart> shopShoppingCarts);
    public List<CouponReceiveInfoVO> getCartVoCouponList(Long companyId,List<OrderItemDto> OrderItemDtos);


    /**

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/impl/WXShopOrderServiceImpl.java

@@ -1,5 +1,6 @@
package com.matrix.system.shopXcx.api.service.impl;

import cn.hutool.core.collection.CollUtil;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.matrix.biz.bean.BizUser;
@@ -11,26 +12,24 @@
import com.matrix.core.exception.GlobleException;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.tools.LogUtil;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.bean.BusParameterSettings;
import com.matrix.system.common.constance.AppConstance;
import com.matrix.system.common.dao.BusParameterSettingsDao;
import com.matrix.system.common.dao.CustomerDataDictionaryDao;
import com.matrix.system.common.interceptor.HostInterceptor;
import com.matrix.system.constance.Dictionary;
import com.matrix.system.hive.bean.ShoppingGoods;
import com.matrix.system.hive.dao.ShoppingGoodsDao;
import com.matrix.system.shopXcx.api.action.PayThreadPool;
import com.matrix.system.shopXcx.api.pojo.AddShopOrderPOJO;
import com.matrix.system.shopXcx.api.pojo.OrderCouponGroup;
import com.matrix.system.shopXcx.api.pojo.OrderInfoQueryPOJO;
import com.matrix.system.shopXcx.api.pojo.OrderItemDto;
import com.matrix.system.shopXcx.api.pojo.ShopOrderDto;
import com.matrix.system.shopXcx.api.service.OrderCouponGroupService;
import com.matrix.system.shopXcx.api.service.ShoppingCartService;
import com.matrix.system.shopXcx.api.service.WXShopOrderService;
import com.matrix.system.shopXcx.api.service.WxShopCouponService;
import com.matrix.system.shopXcx.api.tools.WxShopCouponUtil;
import com.matrix.system.shopXcx.api.tools.WxShopOrderUtil;
import com.matrix.system.shopXcx.api.vo.CouponReceiveInfoVO;
import com.matrix.system.shopXcx.api.vo.ShopCartBillVo;
import com.matrix.system.shopXcx.api.vo.ShopCartVo;
import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.dao.*;
import com.matrix.system.shopXcx.dto.DiscountExplain;
@@ -42,6 +41,7 @@

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

/**
 * @author jyy
@@ -90,6 +90,9 @@
    private ShopActivitiesGroupJoinUserDao shopActivitiesGroupJoinUserDao;

    @Autowired
    OrderCouponGroupService orderCouponGroupService;

    @Autowired
    CustomerDataDictionaryDao dataDictionaryDao;
    @Value("${wx_pay_debug_onoff}")
    private boolean isDebug;
@@ -98,111 +101,84 @@
    private BusParameterSettingsDao busParameterSettingsDao;

    @Override
    public BigDecimal calculationPostage(BigDecimal payPrice,Long companyId) {
    public BigDecimal calculationPostage(BigDecimal payPrice, Long companyId) {
        BigDecimal postage = BigDecimal.ZERO;
        BusParameterSettings yf = busParameterSettingsDao.selectCompanyParamByCode(AppConstance.PACKAGE_PRICE, companyId);
        BusParameterSettings myje = busParameterSettingsDao.selectCompanyParamByCode(AppConstance.FREE_PACKAGE_PRICE, companyId);
        if(yf!=null&&myje!=null){
        if (yf != null && myje != null) {
            if (Double.parseDouble(myje.getParamValue()) > payPrice.doubleValue()) {
                postage = new BigDecimal(yf.getParamValue());
            }
        }

        return postage;
    }




    /**
     * 创建订单
     *
     * @param addShopOrderPOJO
     * @param shopOrderDto
     * @return
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AjaxResult createShopOrder(AddShopOrderPOJO addShopOrderPOJO) throws Exception {
    public AjaxResult createShopOrder(ShopOrderDto shopOrderDto) throws Exception {
        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class);


        //校验收货地址
        ShopReceiveAddress shopReceiveAddress = shopReceiveAddressDao.selectById(addShopOrderPOJO.getReceiveAddrId());
        ShopReceiveAddress shopReceiveAddress = shopReceiveAddressDao.selectById(shopOrderDto.getReceiveAddrId());
        if (shopReceiveAddress == null) {
            return new AjaxResult(AjaxResult.STATUS_FAIL, "请选择正确的收获地址");
        }

        AjaxResult caculateResult= buildDiscountExplain(shopOrderDto);

        List<ShopCartVo> cartList = shoppingCartService.findUserCartList(addShopOrderPOJO.getShopId(),ShopShoppingCart.CAR_TYPE_MICRO);
        //购物车不能为空
        if (CollectionUtils.isEmpty(cartList)) {
            return new AjaxResult(AjaxResult.STATUS_FAIL, "请选择您需要购买的产品");
        }

        //计算订单优惠信息
        DiscountExplain discountExplain= (DiscountExplain) caculateResult.getMapInfo().get("discountExplain");



        //取出购物车中选中的产品
        List<ShopShoppingCart> buyCart = new ArrayList<>();
        //取出购物车中没有参加店铺活动的产品，和参加了店铺活动但是活动没有达到标准的产品，用来计算是否可以使用优惠券
        List<ShopShoppingCart> notCouponuyCart = new ArrayList<>();
        for (ShopCartVo shopCartVo : cartList) {
            for (ShopShoppingCart shopShoppingCart : shopCartVo.getCartList()) {
                if (shopShoppingCart.getIsSelected() == 1) {
                    buyCart.add(shopShoppingCart);
                    if (shopCartVo.getCoupon() == null || !shopCartVo.isSatisfactionCoupon()) {
                        notCouponuyCart.add(shopShoppingCart);
                    }
                }
            }
        }

        //计算订单优惠信息
        DiscountExplain discountExplain = buildDiscountExplain(cartList, addShopOrderPOJO.getCouponReceiveId(), bizUser.getCompanyId());


        ShopOrder shopOrder = new ShopOrder();
        shopOrder.setCompanyId(bizUser.getCompanyId());
        shopOrder.setStoreId(Integer.parseInt(addShopOrderPOJO.getShopId().toString()));
        shopOrder.setStoreId(Integer.parseInt(shopOrderDto.getShopId().toString()));
        //默认设置为产品类型
        shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);

        List<ShopOrderDetails> details = new ArrayList<>();
        Integer cartCount = 0;
        for (ShopShoppingCart shopShoppingCart : buyCart) {
        for (OrderItemDto orderItemDto : shopOrderDto.getOrderItemList()) {
            ShopOrderDetails shopOrderDetails = new ShopOrderDetails();
            shopOrderDetails.setCreateBy(AppConstance.SYSTEM_USER);
            shopOrderDetails.setUpdateBy(AppConstance.SYSTEM_USER);
            shopOrderDetails.setpId(shopShoppingCart.getCartProductId());
            shopOrderDetails.setsId(shopShoppingCart.getCartSkuId());
            shopOrderDetails.setPrice(shopShoppingCart.getPrice());
            shopOrderDetails.setPayType(shopShoppingCart.getCartType());
            shopOrderDetails.setCount(shopShoppingCart.getCartNumber());
            shopOrderDetails.setsTitle(shopShoppingCart.getTitle() + shopShoppingCart.getName());
            shopOrderDetails.setDiscountAmount(BigDecimal.ZERO);
            shopOrderDetails.setpId(orderItemDto.getProductId());
            shopOrderDetails.setsId(orderItemDto.getSkuId());
            shopOrderDetails.setCount(orderItemDto.getCount());
            if(ShopOrderDetails.PAYTYPE_MICRO==orderItemDto.getPayType()){
                shopOrderDetails.setPrice(orderItemDto.getShopSku().getPrice());
            }else{
                shopOrderDetails.setPrice(orderItemDto.getShopSku().getScorePrice());
                shopOrderDetails.setScoreCount(BigDecimal.valueOf(orderItemDto.getShopSku().getScoreCount()));
                shopOrderDetails.setTotalScoreCount(shopOrderDetails.getScoreCount().multiply(BigDecimal.valueOf(shopOrderDetails.getCount())));
            }
            shopOrderDetails.setTotalPrice(shopOrderDetails.getPrice().multiply(BigDecimal.valueOf(shopOrderDetails.getCount())));

            shopOrderDetails.setPayType(orderItemDto.getPayType());

            shopOrderDetails.setsTitle(orderItemDto.getShopProduct().getTitle() + orderItemDto.getShopSku().getName());

            shopOrderDetails.setDiscountAmount(BigDecimal.ZERO);

            details.add(shopOrderDetails);
            cartCount += shopOrderDetails.getCount();

            //查询绑定的产品是否为家居产品,如果已经含家具产品则不再比较
            if (ShopOrder.ORDER_TYPE_GOODS != shopOrder.getOrderType()) {
                ShopSku shopSku = shopSkuDao.selectById(shopShoppingCart.getCartSkuId());
                String stokCode = shopSku.getStockCode();
                if (StringUtils.isNotBlank(stokCode)) {
                    ShoppingGoods shoppingGoods = shoppingGoodsDao.selectById(Long.parseLong(stokCode));
                    if (shoppingGoods != null) {
                        //根据购买的产品设置订单类型
                        if (Dictionary.SHOPPING_GOODS_TYPE_JJCP.equals(shoppingGoods.getGoodType())) {
                            shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
                        } else {

                        }
                    } else {
                        shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
                    }
                }
            }


        }

        //校验商品是否限购
@@ -215,8 +191,9 @@
        shopOrder.setUpdateBy("微信小程序生成");
        shopOrder.setCommodityPrice(discountExplain.getBillPrice());
        shopOrder.setPurchaseQuantity(cartCount);
        shopOrder.setOrderType(ShopOrder.ORDER_TYPE_GOODS);
        //购买方式
        shopOrder.setShippingMethod(addShopOrderPOJO.getDeliverySelect());
        shopOrder.setShippingMethod(shopOrderDto.getDeliverySelect());
        //生成订单号
        shopOrder.setOrderNo(WxUtils.getOrderNum());
        //设置支付状态
@@ -231,7 +208,7 @@
        //客户姓名
        shopOrder.setUserName(shopReceiveAddress.getAddrLiaisonman());
        //备注
        shopOrder.setRemarks(addShopOrderPOJO.getRemarks());
        shopOrder.setRemarks(shopOrderDto.getRemarks());
        //删除标识
        shopOrder.setDelFlag(AppConstance.DATA_USEABLE);
        //微信订单号
@@ -244,11 +221,11 @@
        shopOrder.setOrderMoney(discountExplain.getPayPrice());
        Gson g = new GsonBuilder().create();
        shopOrder.setDiscountExplain(g.toJson(discountExplain));
        shopOrder.setDiscountAmount(discountExplain.getActivity().add(discountExplain.getCoupon()));
        shopOrder.setDiscountAmount(discountExplain.getActivityPrice().add(discountExplain.getCouponPrice()));
        shopOrder.setCompanyId(HostInterceptor.getCompanyId());
        shopOrderDao.insert(shopOrder);

        wxShopOrderUtil.insertSendPackageInfo(shopOrder, addShopOrderPOJO.getDeliverySelect(), shopReceiveAddress);
        wxShopOrderUtil.insertSendPackageInfo(shopOrder, shopOrderDto.getDeliverySelect(), shopReceiveAddress);
        //给订单详情表添加订单ID
        for (ShopOrderDetails shopOrderDetails : details) {
            shopOrderDetails.setOrderId(shopOrder.getId());
@@ -257,11 +234,11 @@
            shopOrderDetailsDao.batchInsert(details);
        }
        //更新使用的优惠券状态
        if (addShopOrderPOJO.getCouponReceiveId() != null) {
        if (shopOrderDto.getCouponReceiveId() != null) {
            ShopCouponRecord record = new ShopCouponRecord();
            record.setIsUsing(AppConstance.MY_COUPON_USE);
            record.setOrderId(shopOrder.getId());
            record.setId(addShopOrderPOJO.getCouponReceiveId());
            record.setId(shopOrderDto.getCouponReceiveId());
            shopCouponRecordDao.updateByModel(record);
        }

@@ -277,28 +254,121 @@
    }

    @Override
    public DiscountExplain buildDiscountExplain(List<ShopCartVo> cartList, Integer receiveId, Long companyId) {
        ShopCartBillVo shopCartBill = shoppingCartService.buildShopCartBillVo(cartList);
        DiscountExplain discountExplain = new DiscountExplain();
        discountExplain.setActivity(shopCartBill.getBillCouponTotal());
        discountExplain.setBillPrice(shopCartBill.getSrcTotal());
        discountExplain.setPayPrice(shopCartBill.getBillTotal());
        //计算优惠券
        if (receiveId != null) {
            CouponReceiveInfoVO couponReceiveInfoVO = shopCouponRecordDao.selectMyCouponByReceiveId(receiveId);
            if (couponReceiveInfoVO != null) {
                BigDecimal payPrice = discountExplain.getPayPrice().subtract(couponReceiveInfoVO.getOffsetAmount());
                payPrice = payPrice.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : payPrice;
                discountExplain.setPayPrice(payPrice);
                discountExplain.setCoupon(couponReceiveInfoVO.getOffsetAmount());
            }
    public AjaxResult buildDiscountExplain(ShopOrderDto shopOrderDto) {

        if(CollUtil.isEmpty(shopOrderDto.getOrderItemList())){
            return AjaxResult.buildFailInstance("请选择购买的明细");
        }

        discountExplain.setPostage(calculationPostage(discountExplain.getPayPrice(),companyId));
        //订单计价说明
        DiscountExplain discountExplain = new DiscountExplain();
        //账单总金额
        BigDecimal billPrice = BigDecimal.ZERO;
        //活动优惠金额
        BigDecimal activityTotal = BigDecimal.ZERO;
        //优惠券惠金额
        BigDecimal couponPrice = BigDecimal.ZERO;
        //支付总积分
        Integer scoreCount=0;

        //计算实际支付
        discountExplain.setPayPrice(discountExplain.getPayPrice().add(discountExplain.getPostage()));
        return discountExplain;
        BizUser bizUser = redisUserLoginUtils.getLoginUser(BizUser.class);

        //计算购物车中物品的优惠信息
        List<OrderItemDto> orderItemDtos = shopOrderDto.getOrderItemList()
                .stream().map(orderItemDto -> {
                    return orderCouponGroupService.buildOrderCouponElement(orderItemDto);
                })
                .collect(Collectors.toList());
        //计算未优惠的总金额
        for (OrderItemDto orderItemDto :orderItemDtos ){
            if(orderItemDto.getPayType()==ShopShoppingCart.CAR_TYPE_MICRO){
                billPrice=billPrice.add(orderItemDto.getShopSku().getPrice().multiply(new BigDecimal(orderItemDto.getCount())));
            }else{
                billPrice=billPrice.add(orderItemDto.getShopSku().getScorePrice().multiply(new BigDecimal(orderItemDto.getCount())));
                scoreCount+=orderItemDto.getShopSku().getScoreCount()*orderItemDto.getCount();
            }
        }
        discountExplain.setScorePay(scoreCount);


        //计算用户的产品可以参与的店铺优惠活动分组
        List<ShopCoupon> shopActiveList = new ArrayList<>();//记录用户可以参与的门店活动
        List<OrderCouponGroup> orderCouponGroupList = new ArrayList<>();
        int conditionsGroupCount = 0;
        if (shopOrderDto.getJoinActive() == ShopOrderDto.JOIN_ACTIVE) {//用户参与优惠活动
            orderCouponGroupList = orderCouponGroupService.buildOrderCouponGroupList(orderItemDtos);
            conditionsGroupCount = orderCouponGroupList.stream().map(orderCouponGroup -> {
                if (orderCouponGroup.isSatisfactionCoupon()&&orderCouponGroup.getCoupon()!=null) {
                    shopActiveList.add(orderCouponGroup.getCoupon());
                    return 1;
                } else {
                    return 0;
                }
            }).mapToInt(Integer::intValue).sum();
        }
        if(CollUtil.isNotEmpty(shopActiveList)){
            activityTotal=shopActiveList.stream().map(ShopCoupon:: getOffsetAmount).reduce(BigDecimal.ZERO,BigDecimal::add);
        }

        //门店活动优惠金额
        discountExplain.setActivityPrice(activityTotal);


        List<CouponReceiveInfoVO> usefulCoupon = new ArrayList<>();
        CouponReceiveInfoVO shopCoupon = new CouponReceiveInfoVO();
        //满足店铺活动的订单不能使用优惠券
        if (conditionsGroupCount > 0) {
            //计算可用优惠券
            usefulCoupon = wxShopCouponService.getCartVoCouponList(bizUser.getCompanyId(), orderItemDtos);
            //获取用户使用的优惠券
            if (shopOrderDto.getCouponReceiveId() == null) {
                //如果用户没有选择优惠券则默认选优惠金额最高的
                //计算使用优惠券后的价格
                if (CollectionUtils.isNotEmpty(usefulCoupon)) {
                    //根据优惠券ID用户ID查询优惠券信息
                    shopCoupon = usefulCoupon.get(0);
                }
            } else if (shopOrderDto.getCouponReceiveId() != 1) {
                //用户选择了优惠券
                shopCoupon = shopCouponRecordDao.selectMyCouponByReceiveId(shopOrderDto.getCouponReceiveId());
            } else {
                //用户不使用优惠券
            }
            //计算优惠券
            if (shopCoupon.getCouponId() != null) {
                couponPrice=shopCoupon.getOffsetAmount();
            }
            //优惠券金额
            discountExplain.setCouponPrice(couponPrice);
        }



        //计算运费
        discountExplain.setPostage(calculationPostage(discountExplain.getPayPrice(), HostInterceptor.getCompanyId()));



        //账单总金额
        discountExplain.setBillPrice(billPrice.add(discountExplain.getPostage()));

        BigDecimal payPrice=discountExplain.getBillPrice().subtract(activityTotal).subtract(couponPrice);
        //应付金额
        discountExplain.setPayPrice(payPrice.doubleValue()>0?payPrice:BigDecimal.ONE);

        AjaxResult result = AjaxResult.buildSuccessInstance("");
        //结算金额信息
        result.putInMap("discountExplain", discountExplain);
        //用户优惠券
        result.putInMap("usefulCoupon", usefulCoupon);
        //用户选中的优惠券
        result.putInMap("shopCoupon", shopCoupon);

        //店铺优惠活动
        result.putInMap("shopActiveList", shopActiveList);

        return result;

    }



 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/impl/WxShopActivitiesGroupServiceImpl.java

@@ -396,8 +396,8 @@
        DiscountExplain discountExplain = new DiscountExplain();
        discountExplain.setPayPrice(payPrice);
        discountExplain.setPostage(postPrice);
        discountExplain.setActivity(BigDecimal.ZERO);
        discountExplain.setCoupon(BigDecimal.ZERO);
        discountExplain.setActivityPrice(BigDecimal.ZERO);
        discountExplain.setCouponPrice(BigDecimal.ZERO);
        discountExplain.setBillPrice(payPrice);
        Gson g = new GsonBuilder().create();
        shopOrder.setDiscountExplain(g.toJson(discountExplain));

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/impl/WxShopActivitiesSecKillServiceImpl.java

@@ -210,8 +210,8 @@
        DiscountExplain discountExplain = new DiscountExplain();
        discountExplain.setPayPrice(payPrice);
        discountExplain.setPostage(postPrice);
        discountExplain.setActivity(BigDecimal.ZERO);
        discountExplain.setCoupon(BigDecimal.ZERO);
        discountExplain.setActivityPrice(BigDecimal.ZERO);
        discountExplain.setCouponPrice(BigDecimal.ZERO);
        discountExplain.setBillPrice(payPrice);
        Gson g = new GsonBuilder().create();
        shopOrder.setDiscountExplain(g.toJson(discountExplain));

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/service/impl/WxShopCouponServiceImpl.java

@@ -1,20 +1,20 @@
package com.matrix.system.shopXcx.api.service.impl;

import com.matrix.biz.bean.BizUser;
import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.core.pojo.AjaxResult;
import com.matrix.core.pojo.PaginationVO;
import com.matrix.core.tools.LogUtil;
import com.matrix.core.tools.StringUtils;
import com.matrix.biz.bean.BizUser;
import com.matrix.component.redis.RedisUserLoginUtils;
import com.matrix.system.common.constance.AppConstance;

import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.dao.*;
import com.matrix.system.shopXcx.api.pojo.OrderCouponGroup;
import com.matrix.system.shopXcx.api.pojo.OrderItemDto;
import com.matrix.system.shopXcx.api.service.WxShopCouponService;
import com.matrix.system.shopXcx.api.tools.WxShopCouponUtil;
import com.matrix.system.shopXcx.api.tools.WxShopOrderUtil;
import com.matrix.system.shopXcx.api.vo.CouponReceiveInfoVO;
import com.matrix.system.shopXcx.api.vo.ShopCartVo;
import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.dao.*;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@@ -54,9 +54,10 @@
     *
     * @return
     */
    public List<CouponReceiveInfoVO> getCartVoCouponList(Long companyId,List<ShopShoppingCart> shopShoppingCarts) {
    public List<CouponReceiveInfoVO> getCartVoCouponList(Long companyId,List<OrderItemDto> OrderItemDtos){

        //可用优惠券列表

    //可用优惠券列表
        List<CouponReceiveInfoVO> shopCoupons = new ArrayList<>();


@@ -77,7 +78,7 @@


            //定义购物车优惠分组
            List<ShopCartVo> cartList = new ArrayList<>();
            List<OrderCouponGroup> cartList = new ArrayList<>();

            // 记录所有优惠券，一个优惠券（活动）表示一组
            Map<Integer, ShopCoupon> shopCouponMap = new HashMap<>();
@@ -86,24 +87,24 @@
            for (int i = 0; i < userAllCoupon.size(); i++) {

                CouponReceiveInfoVO couponReceiveInfoVO = userAllCoupon.get(i);
                ShopCartVo shopCarVo = new ShopCartVo();
                OrderCouponGroup shopCarVo = new OrderCouponGroup();
                shopCarVo.setCouponReceiveInfoVO(couponReceiveInfoVO);
                shopCarVo.setCartList(new ArrayList<>());
                shopCarVo.setOrderItemDtos(new ArrayList<>());
                cartList.add(i, shopCarVo);


                for (ShopShoppingCart shoppingCart : shopShoppingCarts) {
                for (OrderItemDto orderItemDto : OrderItemDtos) {

                    // 如果匹配到的产品已经出现在其他优惠组中，则需要判断是否移除之前的组
                    boolean needRemove = false;


                    //找到产品所有的优惠券
                    List<ShopCoupon> productShopCoupons = getCouponListByProductId(shoppingCart.getCartProductId());
                    List<ShopCoupon> productShopCoupons = getCouponListByProductId(orderItemDto.getProductId());
                    for (ShopCoupon productShopCoupon : productShopCoupons) {
                        if (couponReceiveInfoVO.getCouponId().equals(productShopCoupon.getId())) {
                            LogUtil.debug("购物车" + shoppingCart.getName() + "和优惠券" + couponReceiveInfoVO.getcName() + "匹配");
                            shopCarVo.getCartList().add(shoppingCart);
                            LogUtil.debug("购物车" + orderItemDto.getProductId() + "和优惠券" + couponReceiveInfoVO.getcName() + "匹配");
                            shopCarVo.getOrderItemDtos().add(orderItemDto);
                            break;
                        }
                    }
@@ -113,9 +114,9 @@
            }

            //3.计算各组的金额是否满足，把满足的优惠券全部返回
            for (ShopCartVo shopCartVo : cartList) {
                if (shopCartVo.isSatisfactionCoupon() && CollectionUtils.isNotEmpty(shopCartVo.getCartList())) {
                    shopCoupons.add(shopCartVo.getCouponReceiveInfoVO());
            for (OrderCouponGroup orderCouponGroup : cartList) {
                if (orderCouponGroup.isSatisfactionCoupon() && CollectionUtils.isNotEmpty(orderCouponGroup.getOrderItemDtos())) {
                    shopCoupons.add(orderCouponGroup.getCouponReceiveInfoVO());
                }
            }
        }
@@ -125,19 +126,19 @@



    private void countPrice(ShopCartVo shopCartVo) {
        List<ShopShoppingCart> cartList = shopCartVo.getCartList();
    private void countPrice(OrderCouponGroup orderCouponGroup) {
        List<OrderItemDto> orderItemDtoList = orderCouponGroup.getOrderItemDtos();
        // 计算总价
        BigDecimal sum = BigDecimal.ZERO;
        for (ShopShoppingCart shopShoppingCart : cartList) {
            sum = sum.add(shopShoppingCart.getPrice().multiply(BigDecimal.valueOf(shopShoppingCart.getCartNumber())));
        for (OrderItemDto orderItemDto : orderItemDtoList) {
            sum = sum.add(orderItemDto.getShopSku().getPrice().multiply(BigDecimal.valueOf(orderItemDto.getCount())));
        }
        // 存在优惠券
        if (sum.compareTo(shopCartVo.getCouponReceiveInfoVO().getMinAmount()) >= 0) {
        if (sum.compareTo(orderCouponGroup.getCouponReceiveInfoVO().getMinAmount()) >= 0) {
            //标记为合理分组
            shopCartVo.setSatisfactionCoupon(true);
            orderCouponGroup.setSatisfactionCoupon(true);
        } else {
            shopCartVo.setSatisfactionCoupon(false);
            orderCouponGroup.setSatisfactionCoupon(false);
        }
    }

@@ -299,7 +300,6 @@
     * 通过优惠券标签获取优惠券列表
     *
     * @param tag 标签名称
     * @param shopId
     * @return
     */
    @Override

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/tools/WxShopOrderUtil.java

@@ -1,16 +1,15 @@
package com.matrix.system.shopXcx.api.tools;

import com.matrix.system.common.bean.CustomerDataDictionary;
import com.matrix.system.common.dao.CustomerDataDictionaryDao;
import com.matrix.biz.service.BizUserService;
import com.matrix.component.tools.WxTempLateMsgUtil;
import com.matrix.core.exception.GlobleException;
import com.matrix.core.tools.LogUtil;
import com.matrix.core.tools.StringUtils;
import com.matrix.system.common.constance.AppConstance;
import com.matrix.system.shopXcx.api.pojo.AddShopOrderPOJO;
import com.matrix.system.shopXcx.api.pojo.ShopOrderDto;
import com.matrix.system.shopXcx.api.pojo.OrderPostageInfoPOJO;
import com.matrix.system.shopXcx.api.pojo.OrderProductSkuPOJO;
import com.matrix.system.shopXcx.api.pojo.OrderItemDto;
import com.matrix.system.shopXcx.api.service.WxShopMemberDayService;
import com.matrix.system.shopXcx.bean.*;
import com.matrix.system.shopXcx.dao.*;
@@ -95,12 +94,12 @@

    /**
     * 处理产品规格信息
     * @param addShopOrderPOJO
     * @param shopOrderDto
     */
    public List<ShopOrderDetails> processProductSkuInfo(ShopOrder shopOrder, AddShopOrderPOJO addShopOrderPOJO,
    public List<ShopOrderDetails> processProductSkuInfo(ShopOrder shopOrder, ShopOrderDto shopOrderDto,
                                                        ShopCoupon shopCoupon) {
        List<ShopOrderDetails> resList = new ArrayList<>();
        List<OrderProductSkuPOJO> skuList = addShopOrderPOJO.getSkuList();
        List<OrderItemDto> skuList = shopOrderDto.getOrderItemList();
        if (CollectionUtils.isEmpty(skuList)) {
            return resList;
        }
@@ -108,9 +107,9 @@
        //设置购买数量
        int total = 0;
        BigDecimal commodityMoney = new BigDecimal("0");
        for (OrderProductSkuPOJO orderProductSkuPOJO : skuList) {
            ids.add(orderProductSkuPOJO.getSkuId());
            total += orderProductSkuPOJO.getCount();
        for (OrderItemDto orderItemDto : skuList) {
            ids.add(orderItemDto.getSkuId());
            total += orderItemDto.getCount();
        }
        shopOrder.setPurchaseQuantity(total);
        List<ShopSku> contrastList = shopSkuDao.selectByIds(ids);
@@ -131,10 +130,10 @@

        BigDecimal couponTotalMoney = new BigDecimal("0");
        Double discountRate = wxShopMemberDayService.getMemberDay();
        for (OrderProductSkuPOJO orderProductSkuPOJO : skuList) {
        for (OrderItemDto orderItemDto : skuList) {
            boolean isExist = false;
            for (ShopSku shopSku : contrastList) {
                if (shopSku.getId().equals(orderProductSkuPOJO.getSkuId())) {
                if (shopSku.getId().equals(orderItemDto.getSkuId())) {
                    isExist = true;
                    ShopOrderDetails shopOrderDetails = new ShopOrderDetails();
                    shopOrderDetails.setCreateBy(AppConstance.SYSTEM_USER);
@@ -142,9 +141,9 @@
                    shopOrderDetails.setpId(shopSku.getPId());
                    shopOrderDetails.setsId(shopSku.getId());
                    shopOrderDetails.setPrice(shopSku.getPrice());
                    shopOrderDetails.setCount(orderProductSkuPOJO.getCount());
                    shopOrderDetails.setCount(orderItemDto.getCount());
                    BigDecimal price = new BigDecimal(shopSku.getPrice().toString());
                    BigDecimal count = new BigDecimal(orderProductSkuPOJO.getCount().toString());
                    BigDecimal count = new BigDecimal(orderItemDto.getCount().toString());
                    shopOrderDetails.setsTitle(shopSku.getName());
                    resList.add(shopOrderDetails);


 zq-erp/src/main/java/com/matrix/system/shopXcx/api/vo/ShopCartGroupVo.java

New file
@@ -0,0 +1,46 @@
package com.matrix.system.shopXcx.api.vo;

import com.matrix.system.shopXcx.bean.ShopCoupon;
import com.matrix.system.shopXcx.bean.ShopShoppingCart;
import lombok.Data;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

/**
 * 购物车前台展示对象
 */
@Data
public class ShopCartGroupVo {

    private ShopCoupon coupon;

    //是否满足优惠
    private boolean satisfactionCoupon;


    private List<ShopShoppingCart> cartList=new ArrayList<>();


    //提示语
    private String msg="";

    //优惠小计金额
    private BigDecimal subtotal=BigDecimal.ZERO;

    //原价
    private BigDecimal srcPrice=BigDecimal.ZERO;

    //优惠金额
    private BigDecimal  couponPrice=BigDecimal.ZERO;
    /**
     * 抵用积分
     */
    private BigDecimal scorePay = BigDecimal.ZERO;

    private CouponReceiveInfoVO couponReceiveInfoVO;



}

 zq-erp/src/main/java/com/matrix/system/shopXcx/api/vo/ShopCartVo.java

@@ -2,6 +2,7 @@

import com.matrix.system.shopXcx.bean.ShopCoupon;
import com.matrix.system.shopXcx.bean.ShopShoppingCart;
import lombok.Data;

import java.math.BigDecimal;
import java.util.List;
@@ -9,102 +10,33 @@
/**
 * 购物车前台展示对象
 */
@Data
public class ShopCartVo {

    private ShopCoupon coupon;
    private ShopCoupon coupon;

    private CouponReceiveInfoVO couponReceiveInfoVO;
    private CouponReceiveInfoVO couponReceiveInfoVO;

    public CouponReceiveInfoVO getCouponReceiveInfoVO() {
        return couponReceiveInfoVO;
    }

    public void setCouponReceiveInfoVO(CouponReceiveInfoVO couponReceiveInfoVO) {
        this.couponReceiveInfoVO = couponReceiveInfoVO;
    }
    //是否满足优惠
    private boolean satisfactionCoupon;

    //是否满足优惠
    private boolean satisfactionCoupon;
    private List<ShopShoppingCart> cartList;

    private List<ShopShoppingCart> cartList;
    //提示语
    private String msg = "";

    //提示语
    private String msg="";
    //优惠小计金额
    private BigDecimal subtotal = BigDecimal.ZERO;

    //优惠小计金额
    private BigDecimal subtotal=BigDecimal.ZERO;
    //原价
    private BigDecimal srcPrice = BigDecimal.ZERO;

    //原价
    private BigDecimal srcPrice=BigDecimal.ZERO;
    //优惠金额
    private BigDecimal couponPrice = BigDecimal.ZERO;
    /**
     * 抵用积分
     */
    private BigDecimal scorePay = BigDecimal.ZERO;

    //优惠金额
    private BigDecimal  couponPrice=BigDecimal.ZERO;
    /**
     * 抵用积分
     */
    private BigDecimal scorePay = BigDecimal.ZERO;

    public ShopCoupon getCoupon() {
        return coupon;
    }

    public void setCoupon(ShopCoupon coupon) {
        this.coupon = coupon;
    }

    public boolean isSatisfactionCoupon() {
        return satisfactionCoupon;
    }

    public void setSatisfactionCoupon(boolean satisfactionCoupon) {
        this.satisfactionCoupon = satisfactionCoupon;
    }

    public List<ShopShoppingCart> getCartList() {
        return cartList;
    }

    public void setCartList(List<ShopShoppingCart> cartList) {
        this.cartList = cartList;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public BigDecimal getSubtotal() {
        return subtotal;
    }

    public void setSubtotal(BigDecimal subtotal) {
        this.subtotal = subtotal;
    }

    public BigDecimal getSrcPrice() {
        return srcPrice;
    }

    public void setSrcPrice(BigDecimal srcPrice) {
        this.srcPrice = srcPrice;
    }

    public BigDecimal getCouponPrice() {
        return couponPrice;
    }

    public BigDecimal getScorePay() {
        return scorePay;
    }

    public void setScorePay(BigDecimal scorePay) {
        this.scorePay = scorePay;
    }

    public void setCouponPrice(BigDecimal couponPrice) {
        this.couponPrice = couponPrice;
    }
}

 zq-erp/src/main/java/com/matrix/system/shopXcx/dao/ShopShoppingCartDao.java

@@ -36,7 +36,7 @@
    
    public ShopShoppingCart  selectById(Integer cartId);

    public List<ShopShoppingCart> selectByCartUserId(@Param("shopId")Long shopId, @Param("cartUserId") String cartUserId,@Param("cartType") Integer cartType);
    public List<ShopShoppingCart> selectByCartUserId(@Param("shopId")Long shopId, @Param("cartUserId") String cartUserId);
    
    public ShopShoppingCart  selectForUpdate(Integer cartId);


 zq-erp/src/main/java/com/matrix/system/shopXcx/dto/DiscountExplain.java

@@ -1,10 +1,13 @@
package com.matrix.system.shopXcx.dto;

import lombok.Data;

import java.math.BigDecimal;

/**
 * 订单优惠说明
 */
@Data
public class DiscountExplain {

    /**
@@ -15,13 +18,13 @@
    /**
     * 优惠券金额
     */
    private  BigDecimal coupon=BigDecimal.ZERO;
    private  BigDecimal couponPrice =BigDecimal.ZERO;


    /**
     * 活动满减金额
     */
    private BigDecimal activity=BigDecimal.ZERO;
    private BigDecimal activityPrice =BigDecimal.ZERO;

    /**
     * 运费
@@ -32,44 +35,9 @@
     * 最终支付金额
     */
    private BigDecimal payPrice=BigDecimal.ZERO;
    /**
     * 最终支付积分
     */
    private Integer scorePay;

    public BigDecimal getBillPrice() {
        return billPrice;
    }

    public void setBillPrice(BigDecimal billPrice) {
        this.billPrice = billPrice;
    }

    public BigDecimal getCoupon() {
        return coupon;
    }

    public void setCoupon(BigDecimal coupon) {
        this.coupon = coupon;
    }

    public BigDecimal getActivity() {
        return activity;
    }

    public void setActivity(BigDecimal activity) {
        this.activity = activity;
    }

    public BigDecimal getPostage() {
        return postage;
    }

    public void setPostage(BigDecimal postage) {
        this.postage = postage;
    }

    public BigDecimal getPayPrice() {
        return payPrice;
    }

    public void setPayPrice(BigDecimal payPrice) {
        this.payPrice = payPrice;
    }
}

 zq-erp/src/main/resources/mybatis/mapper/xcxShop/ShopOrderDetailsDao.xml

@@ -50,9 +50,7 @@
        <!--规格信息-->
        <association property="shopSku" column="s_id"
            select="com.matrix.system.shopXcx.dao.ShopSkuDao.selectById"/>
        <!--查询生产企业-->
        <association property="productionEnterprise" column="{pId=p_id}"
                     select="selectProductionEnterpriseByPid"/>

    </resultMap>