coupon_fix

src/main/java/com/gogirl/application/market/coupon/CouponService.java

@@ -10,36 +10,6 @@ import java.util.List;
 public interface CouponService extends IService<Coupon> {
 
 
-    /**
-     * 获取统一卡券领取的张数
-     *
-     * @param couponId   couponId
-     * @param customerId customerId
-     * @return count
-     */
-    int countRelevanceNum(Integer couponId, Integer customerId);
-
-
-    /**
-     * 给用户发券 并且修改卡券已领取人数
-     *
-     * @param coupon 卡券类型
-     * @param record 卡券实体
-     * @return true
-     */
-    int insertSelective(Coupon coupon, CouponCustomerRelevance record);
-
-
-
-    /**
-     * 查询是否领过对应卡券
-     *
-     * @param customerId   用户id
-     * @param couponIdList 卡券类型id
-     * @return
-     */
-    List<CouponCustomerRelevance> selectMyNewCustomerCoupon(Integer customerId, List<Integer> couponIdList);
-
 
     /**
      * 是否新人
@@ -58,7 +28,7 @@ public interface CouponService extends IService<Coupon> {
     Coupon sendNewCustomerCouponXcx(Integer customerId);
 
     /**
-     * 发券
+     * 统一发券接口
      *
      * @param couponId   卡券配置id
      * @param customerId 用户id

src/main/java/com/gogirl/application/market/coupon/impl/CouponCustomerRelevanceServiceImpl.java

@@ -44,38 +44,38 @@ public class CouponCustomerRelevanceServiceImpl extends ServiceImpl<CouponCustom
     private CouponMapper couponMapper;
     @Resource
     private MarketService marketService;
-
     @Resource
     private DiscountConfigMapper discountConfigMapper;
 
     @Override
     public List<CouponCustomerRelevance> getOrderCoupon(Integer currentCustomerId, Integer orderId) {
 
+        /*1、查询订单服务和订单*/
         List<OrderServe> orderServeList = orderServeMapper.selectList(new LambdaQueryWrapper<OrderServe>().eq(OrderServe::getOrderId, orderId));
         OrderManage orderManage = orderManageMapper.selectById(orderId);
         return couponCustomerRelevanceMapper
                 .selectList(new LambdaQueryWrapper<CouponCustomerRelevance>()
                         .eq(CouponCustomerRelevance::getCustomerId, currentCustomerId)
-                        //内部券
+                        //只查询内部券
                         .eq(CouponCustomerRelevance::getSourceType, 0)
-                        //卡券状态 正常
+                        //只查询正常状态的卡券
                         .eq(CouponCustomerRelevance::getState, 1))
                 //
                 .stream()
-                //过滤所有可用在服务上的
+                //只返回可以使用的优惠券
                 .filter(couponCustomerRelevance -> {
+                    //卡券作用的服务id
                     List<Integer> canUserServeIds = couponCustomerRelevanceMapper.queryCouponCustomerServeRelevance(couponCustomerRelevance.getCouponId());
-
-                    List<Integer> freeCouponIds = discountConfigMapper.selectList(new LambdaQueryWrapper<>()).stream().map(DiscountConfig::getCouponId).filter(Objects::nonNull).collect(Collectors.toList());
-
-                    canUserServeIds.retainAll(orderServeList.stream()
-                            .map(OrderServe::getServeId)
-                            .collect(Collectors.toList()));
-                    return ListUtil.isNotEmpty(canUserServeIds);
+                    //订单的服务id
+                    List<Integer> orderServeIds = orderServeList.stream().map(OrderServe::getServeId).collect(Collectors.toList());
+                    //retail
+                    List<Integer> retainIds = ListUtil.retainAll(canUserServeIds, orderServeIds);
+                    return ListUtil.isNotEmpty(retainIds);
                 })
                 .peek(couponCustomerRelevance -> {
+                    //卡券作用的服务id (mybatis 缓存)
                     List<Integer> canUserServeIds = couponCustomerRelevanceMapper.queryCouponCustomerServeRelevance(couponCustomerRelevance.getCouponId());
-
+                    //免单券
                     List<Integer> freeCouponIds = discountConfigMapper.selectList(new LambdaQueryWrapper<>()).stream().map(DiscountConfig::getCouponId).filter(Objects::nonNull).collect(Collectors.toList());
                     if (freeCouponIds.contains(couponCustomerRelevance.getCouponId())) {
                         canUserServeIds.retainAll(orderServeList.stream()
@@ -92,11 +92,12 @@ public class CouponCustomerRelevanceServiceImpl extends ServiceImpl<CouponCustom
                                 .map(OrderServe::getServeId)
                                 .collect(Collectors.toList()));
                     }
+                    //满足使用条件但是不满足冲突条件的卡券
                     couponCustomerRelevance.setCanBeUse(ListUtil.isNotEmpty(canUserServeIds));
                 })
-                //过滤可用
+                //返回校验通过的卡券
                 .filter(CouponCustomerRelevance::isValid)
-                //过滤达到可用金额
+                //返回到到使用金额条件的卡券
                 .filter(couponCustomerRelevance -> couponCustomerRelevance.getReachingAmount().compareTo(orderManage.getTotalPrice()) < 0)
                 .collect(Collectors.toList());
     }

src/main/java/com/gogirl/application/market/coupon/impl/CouponServiceImpl.java

@@ -12,19 +12,25 @@ import com.gogirl.domain.order.serve.OrderServe;
 import com.gogirl.domain.xcx.GogirlConfig;
 import com.gogirl.infrastructure.common.exception.RRException;
 import com.gogirl.infrastructure.common.util.ListUtil;
+import com.gogirl.infrastructure.common.util.StringUtils;
 import com.gogirl.infrastructure.mapper.market.coupon.CouponCustomerRelevanceMapper;
 import com.gogirl.infrastructure.mapper.market.coupon.CouponMapper;
 import com.gogirl.infrastructure.mapper.order.serve.OrderManageMapper;
 import com.gogirl.infrastructure.mapper.order.serve.OrderServeMapper;
 import com.gogirl.infrastructure.mapper.xcx.GogirlConfigMapper;
+import com.gogirl.infrastructure.util.SessionUtils;
 import com.gogirl.shared.market.command.SetUpOuterCouponCommand;
 import lombok.AllArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
-import java.util.*;
+import java.util.Date;
+import java.util.List;
 import java.util.stream.Collectors;
 
+/**
+ * 卡券配置服务
+ */
 @Service
 @AllArgsConstructor
 @Slf4j
@@ -36,123 +42,43 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
     private final OrderManageMapper orderManageMapper;
     private final GogirlConfigMapper gogirlConfigMapper;
 
-
     private final MarketService marketService;
 
-    @Override
-    public int countRelevanceNum(Integer couponId, Integer customerId) {
-        return couponCustomerRelevanceMapper.countRelevanceNum(couponId, customerId);
-    }
-
-    @Override
-    public int insertSelective(Coupon coupon, CouponCustomerRelevance record) {
-        if (record.getState() == null) {
-            record.setState(1);
-        }
-        if (record.getReceiveTime() == null) {
-            record.setReceiveTime(new Date());
-        }
-        if ((record.getValidStartTime() == null || record.getValidEndTime() == null) && coupon != null) {
-            if (coupon.getValidType() == 1) {
-                //优惠券原有开始和结束时间
-                record.setValidStartTime(coupon.getValidStartTime());
-                record.setValidEndTime(coupon.getValidEndTime());
-            } else if (coupon.getValidType() == 2) {
-                long today = new Date().getTime();
-                long day7 = today + 86400000L * coupon.getValidDate();
-                //从现在开始
-                record.setValidStartTime(new Date(today));
-                //七天后过期
-                record.setValidEndTime(new Date(day7));
-            }
-        }
-
-        //修改已领取人数
-        Coupon c = couponMapper.selectById(record.getCouponId());
-        c.setReceiveQuantity(c.getReceiveQuantity() + 1);
-        couponMapper.updateById(c);
-
-
-        couponCustomerRelevanceMapper.insert(record);
-        return record.getId();
-    }
-
-
-    @Override
-    public List<CouponCustomerRelevance> selectMyNewCustomerCoupon(Integer customerId, List<Integer> couponIdList) {
-
-        List<CouponCustomerRelevance> couponCustomerRelevanceList = couponCustomerRelevanceMapper.selectList(
-                new LambdaQueryWrapper<CouponCustomerRelevance>().eq(CouponCustomerRelevance::getCustomerId, couponIdList)
-                        .in(CouponCustomerRelevance::getCouponId, couponIdList)
-        );
-        this.joinCouponCustomerRelevanceMapper(couponCustomerRelevanceList);
-        return couponCustomerRelevanceList;
-    }
-
 
     @Override
     public Coupon checkNewCustomer(Integer customerId) {
         //新用户配置
         GogirlConfig gogirlConfig = gogirlConfigMapper.selectByPrimaryKey(2);
 
-        if (gogirlConfig == null
-                || gogirlConfig.getValue() == null
-                || gogirlConfig.getValue().isEmpty()) {
-            throw new RRException("请联系管理员配置发放哪张新人优惠券");
-
-        }
-        List<Integer> couponIdList = Arrays.stream(gogirlConfig.getValue().split(",")).map(Integer::valueOf).collect(Collectors.toList());
-        if (ListUtil.isEmpty(couponIdList)) {
+        if (gogirlConfig == null || StringUtils.isEmpty(gogirlConfig.getValue())) {
             throw new RRException("请联系管理员配置发放哪张新人优惠券");
         }
+        //新人券id
+        Integer couponId = Integer.valueOf(gogirlConfig.getValue());
 
-
-        //判断是否有领过相关的优惠券
+        //用户的新人券
         List<CouponCustomerRelevance> list = couponCustomerRelevanceMapper.selectList(new LambdaQueryWrapper<CouponCustomerRelevance>()
                 .eq(CouponCustomerRelevance::getCustomerId, customerId)
-                .in(CouponCustomerRelevance::getCouponId, couponIdList));
-
-        if (list.size() > 0) {
-            return null;
-        }
+                .eq(CouponCustomerRelevance::getCouponId, couponId));
+        //用户的订单
         Integer orderTimes = orderManageMapper.countOrderTimes(customerId);
 
-        //没有订单,确认是新人,发券
-        if (orderTimes == null || orderTimes == 0) {
-            return this.getById(couponIdList.get(0));
+        //不是新人返回null
+        if (list.size() > 0 || orderTimes > 0) {
+            return null;
         }
-        return null;
+        //新人返回券新人券配置
+        return this.getById(couponId);
     }
 
     @Override
     public Coupon sendNewCustomerCouponXcx(Integer customerId) {
         GogirlConfig gogirlConfig = gogirlConfigMapper.selectByPrimaryKey(2);
-        if (gogirlConfig == null || gogirlConfig.getValue() == null || gogirlConfig.getValue().isEmpty()) {
-            throw new RRException("请联系管理员配置发放哪张新人优惠券");
-        }
-        String[] couponIds = gogirlConfig.getValue().split(",");
-        Integer couponId = null;
 
-        List<Integer> coupontIdList = new ArrayList<>();
-        for (int i = 0; i < couponIds.length; i++) {
-            if (couponIds[i] != null && !couponIds[i].isEmpty()) {
-                Integer itemId = Integer.parseInt(couponIds[0]);
-                if (i == 0) {
-                    couponId = itemId;
-                }
-                coupontIdList.add(itemId);
-            }
-        }
-        if (coupontIdList.size() > 0) {//判断是否有领过相关的优惠券
-            List<CouponCustomerRelevance> list = this.selectMyNewCustomerCoupon(customerId, coupontIdList);
-            if (list.size() > 0) {
-                throw new RRException("您曾经领取过新人优惠券");
-            }
+        if (gogirlConfig == null || StringUtils.isEmpty(gogirlConfig.getValue())) {
+            throw new RRException("请联系管理员配置发放哪张新人优惠券");
         }
-        log.info("发放优惠券customerId:" + customerId.toString());
-        log.info("发放优惠券couponId:" + couponId.toString());
-
-        //返回消息
+        Integer couponId = Integer.valueOf(gogirlConfig.getValue());
         return sendCoupon(couponId, customerId);
     }
 
@@ -167,42 +93,65 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
         if (coupon.getAllQuantity() <= coupon.getReceiveQuantity()) {
             throw new RRException("优惠券已经领完");
         }
-        //判断该用户是否限领,null过,0过,有但限制不过,不限制过
-        int row = this.countRelevanceNum(couponId, customerId);
-        if (coupon.getLimitQuantity() != null && coupon.getLimitQuantity() != 0 && coupon.getLimitQuantity() <= row) {
-            throw new RRException("抱歉,该优惠券最多可领取" + coupon.getLimitQuantity() + "张,你已有" + row + "张该优惠券.");
+
+        //判断该用户是否到达领取限制
+        int receiveCouponNam = couponCustomerRelevanceMapper.countRelevanceNum(couponId, customerId);
+        if (coupon.getLimitQuantity() != null && coupon.getLimitQuantity() != 0 && coupon.getLimitQuantity() <= receiveCouponNam) {
+            throw new RRException("抱歉,该优惠券最多可领取" + coupon.getLimitQuantity() + "张,你已有" + receiveCouponNam + "张该优惠券.");
         }
 
         CouponCustomerRelevance couponCustomerRelevance = new CouponCustomerRelevance();
+        //用户id
         couponCustomerRelevance.setCustomerId(customerId);
+        //卡券配置id
         couponCustomerRelevance.setCouponId(couponId);
+        //状态 1-正常
         couponCustomerRelevance.setState(1);
+        //领券时间
         couponCustomerRelevance.setReceiveTime(new Date());
 
-        //冗字段
+        /*冗余字段*/
+        //卡券名字
         couponCustomerRelevance.setCouponName(coupon.getName());
+        //卡券折扣金额
         couponCustomerRelevance.setDiscountAmount(coupon.getDiscountAmount());
+        //卡券可使用金额
         couponCustomerRelevance.setReachingAmount(coupon.getReachingAmount());
+        //卡券折扣百分比
         couponCustomerRelevance.setDiscountPercent(coupon.getDiscountPercent());
+        //卡券类型
         couponCustomerRelevance.setType(coupon.getType());
+        //卡券来源
         couponCustomerRelevance.setSourceType(coupon.getSourceType());
+        //卡券叠加条件
         couponCustomerRelevance.setCondition1(coupon.getCondition1());
+        //卡券实际支付金额
         couponCustomerRelevance.setPayAmount(coupon.getPayAmount());
-        couponCustomerRelevance.setSourceType(coupon.getSourceType());
-        couponCustomerRelevance.setSourceFrom("新人券");
+        //卡券来源
+        couponCustomerRelevance.setSourceFrom(SessionUtils.getSourceFrom() + "小程序发券");
 
+        //卡券时间计算：配置的开始时间和结束时间
         if (coupon.getValidType() == 1) {
             couponCustomerRelevance.setValidStartTime(coupon.getValidStartTime());//优惠券原有开始和结束时间
             couponCustomerRelevance.setValidEndTime(coupon.getValidEndTime());
-        } else if (coupon.getValidType() == 2) {
-            long today = new Date().getTime();
-            long day7 = today + 86400000L * coupon.getValidDate();
-            couponCustomerRelevance.setValidStartTime(new Date(today));//从现在开始
-            couponCustomerRelevance.setValidEndTime(new Date(day7));//七天后过期
         }
-        int id = this.insertSelective(coupon, couponCustomerRelevance);
+        //卡券有效类型：天数
+        else if (coupon.getValidType() == 2) {
+            long validStartTime = new Date().getTime();
+            long validEndTime = validStartTime + 86400000L * coupon.getValidDate();
+            //从现在开始
+            couponCustomerRelevance.setValidStartTime(new Date(validStartTime));
+            //7天后结束
+            couponCustomerRelevance.setValidEndTime(new Date(validEndTime));
+        }
+        /*发放卡券*/
+        couponCustomerRelevanceMapper.insert(couponCustomerRelevance);
 
+        /*修改卡券配置已领取人数*/
+        coupon.setReceiveQuantity(coupon.getReceiveQuantity() + 1);
+        couponMapper.updateById(coupon);
 
+        //todo
         coupon.setValidStartTime(couponCustomerRelevance.getValidStartTime());
         coupon.setValidEndTime(couponCustomerRelevance.getValidEndTime());
         return coupon;
@@ -251,17 +200,4 @@ public class CouponServiceImpl extends ServiceImpl<CouponMapper, Coupon> impleme
         marketService.setterOrder(orderId);
     }
 
-
-    private void joinCouponCustomerRelevanceMapper(List<CouponCustomerRelevance> couponCustomerRelevanceList) {
-        List<Integer> ids = couponCustomerRelevanceList.stream().map(CouponCustomerRelevance::getCouponId).collect(Collectors.toList());
-        List<Coupon> couponList = couponMapper.selectList(
-                new LambdaQueryWrapper<Coupon>().in(Coupon::getId, ids)
-        );
-        Map<Integer, List<Coupon>> couponMap = couponList.stream().collect(Collectors.groupingBy(Coupon::getId));
-        couponCustomerRelevanceList.forEach(couponCustomerRelevance -> {
-            if (ListUtil.isNotEmpty(couponMap.get(couponCustomerRelevance.getCouponId()))) {
-                couponCustomerRelevance.setCoupon(couponMap.get(couponCustomerRelevance.getCouponId()).stream().findAny().orElse(null));
-            }
-        });
-    }
 }

src/main/java/com/gogirl/application/market/coupon/impl/MarketServiceImpl.java

@@ -487,18 +487,16 @@ public class MarketServiceImpl implements MarketService {
                 if (!total.setScale(2, BigDecimal.ROUND_HALF_UP).equals(BigDecimal.ZERO.setScale(2, BigDecimal.ROUND_HALF_UP))) {
                     //卡券的总折扣金额
                     BigDecimal totalCouponDiscount = couponCustomerRelevance.getDiscountAmount();
-//                    //折扣券
-//                    if (couponCustomerRelevance.getType().equals(CouponCustomerRelevance.TYPE_DISCOUNT)) {
-//                        totalCouponDiscount = orderManage.getTotalPaymentAmount().multiply(couponCustomerRelevance.getDiscountPercent());
-//                    }
-
+                    //折扣券
+                    if (couponCustomerRelevance.getType().equals(CouponCustomerRelevance.TYPE_DISCOUNT)) {
+                        totalCouponDiscount = orderManage.getTotalPaymentAmount().multiply(couponCustomerRelevance.getDiscountPercent());
+                    }
                     //卡券总支付金额
                     BigDecimal totalCouponPay = couponCustomerRelevance.getPayAmount();
                     //计算参数（最后一个订单服务的折扣金额要用总折扣金额减 防止除法计算精度问题）
                     BigDecimal discountCalc = BigDecimal.ZERO;
                     //计算参数（最后一个订单服务的实际支付要用总实际支付金额减 防止除法计算精度问题）
                     BigDecimal payCalc = BigDecimal.ZERO;
-
                     for (OrderServe orderServe : canUserOrderServeList) {
 
                         //每个服务的内部券抵扣金额
@@ -586,9 +584,13 @@ public class MarketServiceImpl implements MarketService {
                     .filter(couponCustomerRelevance -> couponCustomerRelevance.getType().equals(CouponCustomerRelevance.TYPE_DISCOUNT))
                     .collect(Collectors.toList());
             discountInnerCouponCustomerRelevanceServiceList.forEach(couponCustomerRelevanceConsumer);
-            if (normalInnerCouponCustomerRelevanceServiceList.size() > 1) {
+
+            if (normalInnerCouponCustomerRelevanceServiceList.size() + discountInnerCouponCustomerRelevanceServiceList.size() > 1) {
                 throw new RRException("普通内部券只能用一张");
             }
+            if (freeInnerCouponCustomerRelevanceServiceList.size() > 1) {
+                throw new RRException("免单券券只能用一张");
+            }
         }
 
         orderManageMapper.updateById(orderManage);
@@ -685,6 +687,7 @@ public class MarketServiceImpl implements MarketService {
                     .filter(orderServe -> serveIds.contains(orderServe.getServeId()))
                     .filter(orderServe -> !orderServe.isActivity())
                     .filter(orderServe -> orderServe.getBindTimesCard() == 2)
+                    .filter(orderServe -> orderServe.getBindInnerCoupon() == 2)
                     .filter(orderServe -> orderServe.getBindOuterCoupon() == 2)
                     .collect(Collectors.toList());
         }

src/main/java/com/gogirl/infrastructure/common/util/ListUtil.java

 package com.gogirl.infrastructure.common.util;
 
+import org.apache.commons.collections.ListUtils;
+
 import java.util.Collection;
 import java.util.Optional;
 import java.util.function.Function;
@@ -10,7 +12,7 @@ import java.util.stream.Collectors;
  *
  * @author Dxd
  */
-public class ListUtil {
+public class ListUtil extends ListUtils {
 
     /**
      * 校验集合是否为空