caojiahao/dev_caojiahao
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/qiuqiu'

Browse Source 
合并砍价/积分相关

# Conflicts:
#	consumer/src/main/java/cn/lili/event/impl/MemberPointExecute.java
#	update-sql/version4.2to4.3.sql
This commit is contained in:
Chopper 2021-07-30 15:50:36 +08:00
commit 829472c6a3
57 changed files with 2363 additions and 285 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
buyer-api/src/main/java/cn/lili/controller/member/PointsHistoryBuyerController.java
View File

@ -37,7 +37,7 @@ public class PointsHistoryBuyerController {
LambdaQueryWrapper<MemberPointsHistory> queryWrapper = Wrappers.lambdaQuery();
queryWrapper.eq(MemberPointsHistory::getMemberId, UserContext.getCurrentUser().getId());
queryWrapper.orderByDesc(MemberPointsHistory::getCreateTime);
return ResultUtil.data(memberPointsHistoryService.page(PageUtil.initPage(page), queryWrapper));
}

107
buyer-api/src/main/java/cn/lili/controller/promotion/KanjiaGoodsActivityBuyerController.java Normal file
View File

@ -0,0 +1,107 @@
package cn.lili.controller.promotion;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.enums.ResultUtil;
import cn.lili.common.security.context.UserContext;
import cn.lili.common.vo.PageVO;
import cn.lili.common.vo.ResultMessage;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import cn.lili.modules.promotion.entity.dto.KanJiaActivityLogQuery;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityQuery;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import cn.lili.modules.promotion.entity.vos.kanjia.*;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import cn.lili.modules.promotion.service.KanjiaActivityLogService;
import cn.lili.modules.promotion.service.KanjiaActivityService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* 买家端,砍价活动商品
*
* @author qiuqiu
* @date 2021/7/12
**/
@RestController
@Api(tags = "买家端,砍价商品接口")
@RequestMapping("/buyer/promotion/kanjiaGoods")
public class KanjiaGoodsActivityBuyerController {
/**
* 砍价活动商品
*/
@Autowired
private KanjiaActivityGoodsService kanJiaActivityGoodsService;
/**
* 帮砍记录
*/
@Autowired
private KanjiaActivityLogService kanJiaActivityLogService;
/**
* 砍价活动
*/
@Autowired
private KanjiaActivityService kanJiaActivityService;
@GetMapping
@ApiOperation(value = "分页获取砍价商品")
public ResultMessage<IPage<KanjiaActivityGoodsListVO>> kanjiaActivityGoodsPage(KanjiaActivityGoodsParams kanjiaActivityGoodsParams, PageVO page) {
// 会员端查询到的肯定是已经开始的活动商品
kanjiaActivityGoodsParams.setPromotionStatus(PromotionStatusEnum.START.name());
return ResultUtil.data(kanJiaActivityGoodsService.kanjiaGoodsVOPage(kanjiaActivityGoodsParams, page));
}
@GetMapping("/{id}")
@ApiOperation(value = "获取砍价活动商品")
@ApiImplicitParam(name = "id", value = "砍价活动商品ID", required = true, paramType = "path")
public ResultMessage<KanjiaActivityGoodsVO> getKanjiaActivityGoods(@PathVariable String id) {
return ResultUtil.data(kanJiaActivityGoodsService.getKanJiaGoodsVO(id));
}
@GetMapping("/getKanjiaActivity/logs")
@ApiOperation(value = "分页获取砍价活动-帮砍记录")
public ResultMessage<IPage<KanjiaActivityLog>> getKanjiaActivityLog(KanJiaActivityLogQuery kanJiaActivityLogQuery, PageVO page) {
return ResultUtil.data(kanJiaActivityLogService.getForPage(kanJiaActivityLogQuery, page));
}
@PostMapping("/getKanjiaActivity")
@ApiOperation(value = "获取砍价活动")
public ResultMessage<KanjiaActivityVO> getKanJiaActivity(KanjiaActivitySearchParams kanjiaActivitySearchParams) {
//如果是非被邀请关系则填写会员ID
if (StrUtil.isEmpty(kanjiaActivitySearchParams.getKanjiaActivityId())) {
kanjiaActivitySearchParams.setMemberId(UserContext.getCurrentUser().getId());
}
return ResultUtil.data(kanJiaActivityService.getKanjiaActivityVO(kanjiaActivitySearchParams));
}
@PostMapping
@ApiImplicitParam(name = "id", value = "砍价活动商品ID", required = true, paramType = "path")
@ApiOperation(value = "发起砍价活动")
public ResultMessage<KanjiaActivityLog> launchKanJiaActivity(String id) {
KanjiaActivityLog kanjiaActivityLog = kanJiaActivityService.add(id);
return ResultUtil.data(kanjiaActivityLog);
}
@PostMapping("/help/{kanjiaActivityId}")
@ApiImplicitParam(name = "kanJiaActivityId", value = "砍价活动ID", required = true, paramType = "path")
@ApiOperation(value = "帮砍一刀")
public ResultMessage<KanjiaActivityLog> helpKanJia(@PathVariable String kanjiaActivityId) {
KanjiaActivityLog kanjiaActivityLog = kanJiaActivityService.helpKanJia(kanjiaActivityId);
return ResultUtil.data(kanjiaActivityLog);
}
@GetMapping("/kanjiaActivity/mine/")
@ApiOperation(value = "分页获取已参与的砍价活动")
public ResultMessage<IPage<KanjiaActivity>> getPointsGoodsPage(KanjiaActivityQuery kanjiaActivityQuery, PageVO page) {
// 会员端查询到的肯定是已经开始的活动商品
kanjiaActivityQuery.setMemberId(UserContext.getCurrentUser().getId());
IPage<KanjiaActivity> kanjiaActivity = kanJiaActivityService.getForPage(kanjiaActivityQuery, page);
return ResultUtil.data(kanjiaActivity);
}
}

9
buyer-api/src/main/java/cn/lili/controller/promotion/PointsGoodsBuyerController.java
View File

@ -10,9 +10,11 @@ import cn.lili.modules.promotion.service.PointsGoodsCategoryService;
import cn.lili.modules.promotion.service.PointsGoodsService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@ -44,4 +46,11 @@ public class PointsGoodsBuyerController {
return ResultUtil.data(pointsGoodsCategoryService.getCategoryByPage(name, page));
}
@GetMapping("/{id}")
@ApiOperation(value = "获取积分活动商品")
@ApiImplicitParam(name = "id", value = "积分商品ID", required = true, paramType = "path")
public ResultMessage<PointsGoodsVO> getPointsGoodsPage(@PathVariable String id) {
return ResultUtil.data(pointsGoodsService.getPointsGoodsDetail(id));
}
}

3
config/application.yml
View File

@ -37,9 +37,6 @@ spring:
# replica-set-name: mongoreplset
cache:
type: redis
#amqp
# rabbitmq:
# host: 192.168.0.116
jpa:
# 自动生成表结构
generate-ddl: true

11
consumer/src/main/java/cn/lili/event/impl/MemberPointExecute.java
View File

@ -1,6 +1,7 @@
package cn.lili.event.impl;
import cn.hutool.core.convert.Convert;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.common.utils.StringUtils;
import cn.lili.event.AfterSaleStatusChangeEvent;
@ -87,7 +88,7 @@ public class MemberPointExecute implements MemberRegisterEvent, GoodsCommentComp
if (orderMessage.getNewStatus().equals(OrderStatusEnum.COMPLETED)) {
Order order = orderService.getBySn(orderMessage.getOrderSn());
//根据订单编号获取订单数据,如果订单促销类型不为空，并且订单促销类型为积分订单 则直接返回
if (StringUtils.isNotEmpty(order.getOrderPromotionType()) && order.getOrderPromotionType().equals(OrderPromotionTypeEnum.POINT.name())) {
if (StringUtils.isNotEmpty(order.getOrderPromotionType()) && order.getOrderPromotionType().equals(OrderPromotionTypeEnum.POINTS.name())) {
return;
}
//获取积分设置
@ -96,7 +97,13 @@ public class MemberPointExecute implements MemberRegisterEvent, GoodsCommentComp
Double point = CurrencyUtil.mul(pointSetting.getMoney(), order.getFlowPrice(), 0);
//赠送会员积分
memberService.updateMemberPoint(point.longValue(), true, order.getMemberId(), "会员下单，赠送积分" + point + "分");
//取消订单恢复积分
} else if (orderMessage.getNewStatus().equals(OrderStatusEnum.CANCELLED)) {
//根据订单编号获取订单数据,如果为积分订单则跳回
Order order = orderService.getBySn(orderMessage.getOrderSn());
if (order.getOrderPromotionType().equals(OrderPromotionTypeEnum.POINTS.name()) && order.getPriceDetailDTO().getPayPoint() != null) {
memberService.updateMemberPoint(Convert.toLong(order.getPriceDetailDTO().getPayPoint()), true, order.getMemberId(), "订单取消,恢复积分:" + order.getPriceDetailDTO().getPayPoint() + "分");
}
}
}

3
framework/src/main/java/cn/lili/common/enums/PromotionTypeEnum.java
View File

@ -16,13 +16,14 @@ public enum PromotionTypeEnum {
COUPON("优惠券"),
FULL_DISCOUNT("满减"),
POINTS_GOODS("积分商品"),
KANJIA("砍价"),
COUPON_ACTIVITY("优惠券活动")
;
/**
* 拼团秒杀拥有独立库存，如果其他促销也有独立库存涉及库存扣减的，请添加在下方
*/
static PromotionTypeEnum[] haveStockPromotion = new PromotionTypeEnum[]{PINTUAN, SECKILL};
static PromotionTypeEnum[] haveStockPromotion = new PromotionTypeEnum[]{PINTUAN, SECKILL, KANJIA};
private final String description;

22
framework/src/main/java/cn/lili/common/enums/ResultCode.java
View File

@ -125,6 +125,7 @@ public enum ResultCode {
USER_OVERDUE_CONNECT_ERROR(20022, "授权信息已过期，请重新授权/登录"),
USER_CONNECT_BANDING_ERROR(20023, "当前联合登陆方式，已绑定其他账号，需进行解绑操作"),
USER_CONNECT_NOT_EXIST_ERROR(20024, "暂无联合登陆信息，无法实现一键注册功能，请点击第三方登录进行授权"),
USER_POINTS_ERROR(20024, "用户积分不足"),
/**
* 权限
@ -241,6 +242,9 @@ public enum ResultCode {
PROMOTION_GOODS_ERROR(40006,"请选择要参与活动的商品"),
PROMOTION_STATUS_END(40007,"当前活动已停止"),
PROMOTION_UPDATE_ERROR(40008,"当前活动已开始/结束，无法编辑！"),
PROMOTION_ACTIVITY_GOODS_ERROR(40009,"当前活动已经开始无法添加商品"),
PROMOTION_ACTIVITY_ERROR(40009,"当前促销活动不存在"),
PROMOTION_LOG_EXIST(40010,"活动已参加，已发重复参加"),
/**
* 优惠券
@ -325,7 +329,23 @@ public enum ResultCode {
* 其他促销
*/
MEMBER_SIGN_REPEAT(47001, "请勿重复签到"),
POINT_GOODS_ACTIVE_STOCK_ERROR(47002, "活动库存数量不能高于商品库存"),
POINT_GOODS_ACTIVE_STOCK_ERROR(47002, "最低金额不能高于商品金额"),
/**
* 砍价活动
*/
KANJIA_GOODS_ACTIVE_STOCK_ERROR(48001, "活动库存数量不能高于商品库存"),
KANJIA_GOODS_ACTIVE_PRICE_ERROR(48002, "最低购买金额不能高于商品金额"),
KANJIA_GOODS_ACTIVE_HIGHEST_PRICE_ERROR(48003, "最高砍价金额不能为0且不能超过商品金额"),
KANJIA_GOODS_ACTIVE_LOWEST_PRICE_ERROR(48004, "最低砍价金额不能为0且不能超过商品金额"),
KANJIA_GOODS_ACTIVE_HIGHEST_LOWEST_PRICE_ERROR(48005, "最低砍价金额不能高于最高砍价金额"),
KANJIA_GOODS_ACTIVE_SETTLEMENT_PRICE_ERROR(48006, "结算金额不能高于商品金额"),
KANJIA_GOODS_DELETE_ERROR(48007, "删除砍价商品异常"),
KANJIA_ACTIVITY_NOT_FOUND_ERROR(48008, "砍价记录不存在"),
KANJIA_ACTIVITY_LOG_MEMBER_ERROR(48009, "当前会员已经帮砍"),
KANJIA_ACTIVITY_MEMBER_ERROR(48010, "当前会员已经发起此砍价商品活动"),
KANJIA_ACTIVITY_NOT_PASS_ERROR(48011, "当前砍价未满足条件，不能进行购买"),
KANJIA_NUM_BUY_ERROR(48012, "砍价商品购买数量不正确"),
/**
* 店铺
*/

8
framework/src/main/java/cn/lili/modules/order/cart/entity/enums/CartTypeEnum.java
View File

@ -16,6 +16,10 @@ public enum CartTypeEnum {
* 立即购买
*/
BUY_NOW,
/**
* 虚拟商品
*/
VIRTUAL,
/**
* 拼团
*/
@ -25,8 +29,8 @@ public enum CartTypeEnum {
*/
POINTS,
/**
* 虚拟商品
* 砍价商品
*/
VIRTUAL;
KANJIA;
}

3
framework/src/main/java/cn/lili/modules/order/cart/entity/vo/CartSkuVO.java
View File

@ -66,8 +66,7 @@ public class CartSkuVO extends CartBase implements Serializable {
@ApiModelProperty(value = "是否可配送")
private Boolean isShip;
@ApiModelProperty(value =
"拼团id 如果是拼团购买 此值为拼团活动id，" +
@ApiModelProperty(value = "拼团id 如果是拼团购买 此值为拼团活动id，" +
"当pintuanId为空，则表示普通购买（或者拼团商品，单独购买）")
private String pintuanId;

17
framework/src/main/java/cn/lili/modules/order/cart/render/TradeBuilder.java
View File

@ -48,12 +48,18 @@ public class TradeBuilder {
*/
int[] defaultRender = {0, 1, 2, 4, 5, 6, 7};
/**
* 单个商品优惠，不需要渲染满减优惠
*/
int[] singleRender = {0, 2, 4, 5, 6, 7};
/**
* 购物车购物车渲染
* 0-> 校验商品， 1-》 满优惠渲染， 2->渲染优惠， 5->计算价格
*/
int[] cartRender = {0, 1, 2, 5};
/**
* 构造购物车
* 购物车与结算信息不一致的地方主要是优惠券计算和运费计算，其他规则都是一致都
@ -98,6 +104,7 @@ public class TradeBuilder {
//将购物车到sku未选择信息过滤
List<CartSkuVO> collect = tradeDTO.getSkuList().parallelStream().filter(i -> Boolean.TRUE.equals(i.getChecked())).collect(Collectors.toList());
tradeDTO.setSkuList(collect);
if (checkedWay.equals(CartTypeEnum.CART) || checkedWay.equals(CartTypeEnum.BUY_NOW) || checkedWay.equals(CartTypeEnum.VIRTUAL)) {
//按照计划进行渲染
for (int index : defaultRender) {
try {
@ -106,6 +113,16 @@ public class TradeBuilder {
log.error("购物车{}渲染异常：", cartRenderSteps.get(index).getClass(), e);
}
}
} else {
//按照计划进行渲染
for (int index : singleRender) {
try {
cartRenderSteps.get(index).render(tradeDTO);
} catch (Exception e) {
log.error("购物车{}渲染异常：", cartRenderSteps.get(index).getClass(), e);
}
}
}
//购物车信息接受

45
framework/src/main/java/cn/lili/modules/order/cart/render/impl/CartPriceRender.java
View File

@ -1,13 +1,18 @@
package cn.lili.modules.order.cart.render.impl;
import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.modules.goods.service.CategoryService;
import cn.lili.modules.order.cart.entity.dto.TradeDTO;
import cn.lili.modules.order.cart.entity.enums.CartTypeEnum;
import cn.lili.modules.order.cart.entity.vo.CartSkuVO;
import cn.lili.modules.order.cart.entity.vo.CartVO;
import cn.lili.modules.order.cart.render.CartRenderStep;
import cn.lili.modules.order.order.entity.dto.PriceDetailDTO;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.vos.PointsGoodsVO;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import cn.lili.modules.promotion.service.PointsGoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
@ -33,6 +38,16 @@ public class CartPriceRender implements CartRenderStep {
*/
@Autowired
private CategoryService categoryService;
/**
* 积分商品
*/
@Autowired
private PointsGoodsService pointsGoodsService;
/**
* 砍价商品
*/
@Autowired
private KanjiaActivityGoodsService kanjiaActivityGoodsService;
@Override
public void render(TradeDTO tradeDTO) {
@ -97,21 +112,43 @@ public class CartPriceRender implements CartRenderStep {
if (Boolean.TRUE.equals(cartSkuVO.getChecked())) {
PriceDetailDTO priceDetailDTO = cartSkuVO.getPriceDetailDTO();
//流水金额(入账 出帐金额) = goodsPrice + freight - discountPrice - couponPrice
double flowPrice = CurrencyUtil.sub(CurrencyUtil.add(priceDetailDTO.getGoodsPrice(), priceDetailDTO.getFreightPrice()), CurrencyUtil.add(priceDetailDTO.getDiscountPrice(), priceDetailDTO.getCouponPrice() != null ? priceDetailDTO.getCouponPrice() : 0));
double flowPrice = CurrencyUtil.sub(
CurrencyUtil.add(priceDetailDTO.getGoodsPrice(), priceDetailDTO.getFreightPrice()),
CurrencyUtil.add(priceDetailDTO.getDiscountPrice(),
priceDetailDTO.getCouponPrice() != null ? priceDetailDTO.getCouponPrice() : 0));
priceDetailDTO.setFlowPrice(flowPrice);
//最终结算金额 = flowPrice - platFormCommission - distributionCommission
//如果是普通订单最终结算金额 = flowPrice - platFormCommission - distributionCommission
//砍价、积分订单按照商品的结算价进行结算
if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.CART)
|| tradeDTO.getCartTypeEnum().equals(CartTypeEnum.BUY_NOW)
|| tradeDTO.getCartTypeEnum().equals(CartTypeEnum.VIRTUAL)) {
double billPrice = CurrencyUtil.sub(CurrencyUtil.sub(flowPrice, priceDetailDTO.getPlatFormCommission()), priceDetailDTO.getDistributionCommission());
priceDetailDTO.setBillPrice(billPrice);
} else if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.POINTS)) {
PointsGoodsVO pointsGoodsVO = pointsGoodsService.getPointsGoodsVOByMongo(cartSkuVO.getGoodsSku().getId());
priceDetailDTO.setBillPrice(pointsGoodsVO.getSettlementPrice());
priceDetailDTO.setSettlementPrice(pointsGoodsVO.getSettlementPrice());
} else if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.KANJIA)) {
KanjiaActivityGoodsDTO kanjiaActivityGoodsDTO = kanjiaActivityGoodsService.getKanJiaGoodsBySku(cartSkuVO.getGoodsSku().getId());
priceDetailDTO.setBillPrice(kanjiaActivityGoodsDTO.getSettlementPrice());
priceDetailDTO.setSettlementPrice(kanjiaActivityGoodsDTO.getSettlementPrice());
}
//填写结算价格
//平台佣金
String categoryId = cartSkuVO.getGoodsSku().getCategoryPath().substring(
cartSkuVO.getGoodsSku().getCategoryPath().lastIndexOf(",") + 1
);
if (CharSequenceUtil.isNotEmpty(categoryId)) {
//平台佣金=订单金额 * 分类佣金百分比
if (StrUtil.isNotEmpty(categoryId)) {
Double platFormCommission = CurrencyUtil.div(CurrencyUtil.mul(flowPrice, categoryService.getById(categoryId).getCommissionRate()), 100);
priceDetailDTO.setPlatFormCommission(platFormCommission);
}
priceDetailDTOS.add(priceDetailDTO);
}
}

57
framework/src/main/java/cn/lili/modules/order/cart/render/impl/CheckDataRender.java
View File

@ -1,6 +1,7 @@
package cn.lili.modules.order.cart.render.impl;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.context.UserContext;
@ -9,12 +10,20 @@ import cn.lili.modules.goods.entity.dos.GoodsSku;
import cn.lili.modules.goods.entity.enums.GoodsAuthEnum;
import cn.lili.modules.goods.entity.enums.GoodsStatusEnum;
import cn.lili.modules.goods.service.GoodsSkuService;
import cn.lili.modules.member.entity.dos.Member;
import cn.lili.modules.member.service.MemberService;
import cn.lili.modules.order.cart.entity.dto.TradeDTO;
import cn.lili.modules.order.cart.entity.enums.CartTypeEnum;
import cn.lili.modules.order.cart.entity.enums.DeliveryMethodEnum;
import cn.lili.modules.order.cart.entity.vo.CartSkuVO;
import cn.lili.modules.order.cart.entity.vo.CartVO;
import cn.lili.modules.order.cart.render.CartRenderStep;
import cn.lili.modules.order.order.service.OrderService;
import cn.lili.modules.promotion.entity.dos.Pintuan;
import cn.lili.modules.promotion.entity.dos.PromotionGoods;
import cn.lili.modules.promotion.entity.vos.PointsGoodsVO;
import cn.lili.modules.promotion.service.PintuanService;
import cn.lili.modules.promotion.service.PointsGoodsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Service;
@ -22,6 +31,7 @@ import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
/**
@ -40,15 +50,26 @@ public class CheckDataRender implements CartRenderStep {
@Autowired
private OrderService orderService;
@Autowired
private PintuanService pintuanService;
@Autowired
private MemberService memberService;
@Autowired
private PointsGoodsService pointsGoodsService;
@Override
public void render(TradeDTO tradeDTO) {
//校验商品有效性
checkData(tradeDTO);
//店铺分组数据初始化
groupStore(tradeDTO);
//预校验
preCalibration(tradeDTO);
//校验商品有效性
checkData(tradeDTO);
//店铺分组数据初始化
groupStore(tradeDTO);
}
/**
@ -125,6 +146,9 @@ public class CheckDataRender implements CartRenderStep {
* @param tradeDTO
*/
private void preCalibration(TradeDTO tradeDTO) {
//拼团订单预校验
if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.PINTUAN)) {
//拼团判定，不能参与自己创建的拼团
if (tradeDTO.getParentOrderSn() != null) {
//订单接受
@ -134,6 +158,31 @@ public class CheckDataRender implements CartRenderStep {
throw new ServiceException(ResultCode.PINTUAN_JOIN_ERROR);
}
}
//判断拼团商品的限购数量
Optional<String> pintuanId = tradeDTO.getSkuList().get(0).getPromotions().stream().filter(i -> i.getPromotionType().equals(PromotionTypeEnum.PINTUAN.name())).map(PromotionGoods::getPromotionId).findFirst();
if (pintuanId.isPresent()) {
Pintuan pintuan = pintuanService.getPintuanById(pintuanId.get());
Integer limitNum = pintuan.getLimitNum();
for (CartSkuVO cartSkuVO : tradeDTO.getSkuList()) {
if (limitNum != 0 && cartSkuVO.getNum() > limitNum) {
throw new ServiceException(ResultCode.PINTUAN_LIMIT_NUM_ERROR);
}
}
}
//积分商品，判断用户积分是否满足
} else if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.POINTS)) {
String skuId = tradeDTO.getSkuList().get(0).getGoodsSku().getId();
//获取积分商品VO
PointsGoodsVO pointsGoodsVO = pointsGoodsService.getPointsGoodsVOByMongo(skuId);
if(pointsGoodsVO==null){
throw new ServiceException(ResultCode.POINT_GOODS_ERROR);
}
Member member = memberService.getUserInfo();
if (member.getPoint() < pointsGoodsVO.getPoints()) {
throw new ServiceException(ResultCode.USER_POINTS_ERROR);
}
}
}
}

126
framework/src/main/java/cn/lili/modules/order/cart/render/impl/SkuPromotionRender.java
View File

@ -1,8 +1,6 @@
package cn.lili.modules.order.cart.render.impl;
import cn.hutool.core.date.DateUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.modules.order.cart.entity.dto.MemberCouponDTO;
import cn.lili.modules.order.cart.entity.dto.TradeDTO;
@ -14,14 +12,10 @@ import cn.lili.modules.order.cart.entity.vo.PriceDetailVO;
import cn.lili.modules.order.cart.render.CartRenderStep;
import cn.lili.modules.order.order.entity.dto.PriceDetailDTO;
import cn.lili.modules.promotion.entity.dos.MemberCoupon;
import cn.lili.modules.promotion.entity.dos.Pintuan;
import cn.lili.modules.promotion.entity.dos.PromotionGoods;
import cn.lili.modules.promotion.entity.dto.GoodsSkuPromotionPriceDTO;
import cn.lili.modules.promotion.entity.dto.PromotionPriceDTO;
import cn.lili.modules.promotion.entity.dto.PromotionPriceParamDTO;
import cn.lili.modules.promotion.entity.dto.StorePromotionPriceDTO;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.modules.promotion.service.PintuanService;
import cn.lili.modules.promotion.service.PromotionGoodsService;
import cn.lili.modules.promotion.service.PromotionPriceService;
import org.springframework.beans.factory.annotation.Autowired;
@ -53,46 +47,31 @@ public class SkuPromotionRender implements CartRenderStep {
*/
@Autowired
private PromotionGoodsService promotionGoodsService;
/**
* 拼团
*/
@Autowired
private PintuanService pintuanService;
@Override
public void render(TradeDTO tradeDTO) {
//主要渲染各个优惠的价格
this.renderSkuPromotion(tradeDTO);
//渲染促销价格
this.renderPromotionPrice(tradeDTO);
this.checkPromotionLimit(tradeDTO);
//获取商品促销
renderSkuPromotion(tradeDTO);
}
/**
* 渲染单品优惠 积分/拼团/秒杀
* 渲染单品优惠 积分/拼团/秒杀/砍价
*
* @param tradeDTO 购物车视图
*/
private void renderSkuPromotion(TradeDTO tradeDTO) {
//渲染促销价格
this.renderPromotionPrice(tradeDTO);
//拼团和积分购买需要特殊处理，这里优先特殊处理
if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.POINTS)) {
List<CartSkuVO> cartSkuVOList = tradeDTO.getSkuList();
for (CartSkuVO cartSku : cartSkuVOList) {
PriceDetailDTO priceDetailDTO = cartSku.getPriceDetailDTO();
//需要支付的积分
priceDetailDTO.setPayPoint(
CurrencyUtil.mul(
cartSku.getPoint(), cartSku.getNum()).intValue());
}
} else {
//非积分商品、拼团、砍价商品可渲染满优惠活动
//这里普通购物车也只渲染满优惠，其他优惠都是商品级别的，都写在商品属性里
if (!tradeDTO.getCartTypeEnum().equals(CartTypeEnum.POINTS)
&& !tradeDTO.getCartTypeEnum().equals(CartTypeEnum.PINTUAN)
&& !tradeDTO.getCartTypeEnum().equals(CartTypeEnum.KANJIA)) {
List<CartVO> cartVOS = tradeDTO.getCartList();
for (CartVO cartVO : cartVOS) {
if (isFull(cartVO)) {
this.renderFullMinus(cartVO);
@ -101,16 +80,61 @@ public class SkuPromotionRender implements CartRenderStep {
promotionGoodsService.getCartSkuPromotion(cartSkuVO);
}
}
}
}
/**
* 渲染购物车视图的促销价格
* 1.获取购物车商品列表
* 2.获取用户的优惠券
* 3.调用价格计算模块，返回价格计算结果
* 4.分配计算后的促销
*
* @param tradeDTO 购物车视图
*/
private void renderPromotionPrice(TradeDTO tradeDTO) {
//获取购物车商品列表
List<PromotionPriceParamDTO> promotionPriceParamList = this.getPromotionPriceParamList(tradeDTO);
//店铺优惠券集合
List<MemberCoupon> memberCoupons = this.getMemberCoupons(tradeDTO);
//调用价格计算模块，返回价格计算结果
PromotionPriceDTO promotionPrice = promotionPriceService.calculationPromotionPrice(promotionPriceParamList, memberCoupons,tradeDTO.getCartTypeEnum());
// 分配计算后的促销
this.distributionPromotionPrice(tradeDTO, promotionPrice);
}
/**
* 获取用户优惠券列表
*
* @param tradeDTO 交易DTO
* @return 用户优惠券列表
*/
private List<MemberCoupon> getMemberCoupons(TradeDTO tradeDTO) {
//店铺优惠券集合
List<MemberCoupon> memberCoupons = new ArrayList<>();
if (tradeDTO.getStoreCoupons() != null) {
memberCoupons.addAll(tradeDTO.getStoreCoupons().values().parallelStream().map(MemberCouponDTO::getMemberCoupon).collect(Collectors.toList()));
}
//平台优惠券
if (tradeDTO.getPlatformCoupon() != null && tradeDTO.getPlatformCoupon().getMemberCoupon() != null) {
memberCoupons.add(tradeDTO.getPlatformCoupon().getMemberCoupon());
}
//清除过期优惠券
long now = DateUtil.date().getTime();
memberCoupons.removeIf(memberCoupon -> memberCoupon.getEndTime().getTime() < now);
return memberCoupons;
}
/**
* 获取促销价格DTO列表
*
* @param tradeDTO 交易DTO
* @return 促销价格DTO列表
*/
private List<PromotionPriceParamDTO> getPromotionPriceParamList(TradeDTO tradeDTO) {
List<PromotionPriceParamDTO> promotionPriceParamList = new ArrayList<>();
List<CartVO> cartList = tradeDTO.getCartList();
for (CartVO cartVO : cartList) {
@ -130,30 +154,7 @@ public class SkuPromotionRender implements CartRenderStep {
}
}
}
//如果包含促销规则
if (!promotionPriceParamList.isEmpty()) {
//店铺优惠券集合
List<MemberCoupon> memberCoupons = new ArrayList<>();
if (tradeDTO.getStoreCoupons() != null) {
memberCoupons.addAll(tradeDTO.getStoreCoupons().values().parallelStream().map(MemberCouponDTO::getMemberCoupon).collect(Collectors.toList()));
}
//平台优惠券
if (tradeDTO.getPlatformCoupon() != null && tradeDTO.getPlatformCoupon().getMemberCoupon() != null) {
memberCoupons.add(tradeDTO.getPlatformCoupon().getMemberCoupon());
}
//检查优惠券集合中是否存在过期优惠券
this.checkMemberCoupons(memberCoupons);
//调用价格计算模块，返回价格计算结果
PromotionPriceDTO promotionPrice = promotionPriceService.calculationPromotionPrice(promotionPriceParamList, memberCoupons);
// 分配计算后的促销
this.distributionPromotionPrice(tradeDTO, promotionPrice);
}
}
private void checkMemberCoupons(List<MemberCoupon> memberCoupons) {
long now = DateUtil.date().getTime();
memberCoupons.removeIf(memberCoupon -> memberCoupon.getEndTime().getTime() < now);
return promotionPriceParamList;
}
/**
@ -284,19 +285,4 @@ public class SkuPromotionRender implements CartRenderStep {
return false;
}
private void checkPromotionLimit(TradeDTO tradeDTO) {
if (tradeDTO.getCartTypeEnum().equals(CartTypeEnum.PINTUAN)) {
//如果为拼团订单，则获取拼团活动ID
Optional<String> pintuanId = tradeDTO.getSkuList().get(0).getPromotions().stream().filter(i -> i.getPromotionType().equals(PromotionTypeEnum.PINTUAN.name())).map(PromotionGoods::getPromotionId).findFirst();
if (pintuanId.isPresent()) {
Pintuan pintuan = pintuanService.getPintuanById(pintuanId.get());
Integer limitNum = pintuan.getLimitNum();
for (CartSkuVO cartSkuVO : tradeDTO.getSkuList()) {
if (limitNum != 0 && cartSkuVO.getNum() > limitNum) {
throw new ServiceException(ResultCode.PINTUAN_LIMIT_NUM_ERROR);
}
}
}
}
}
}

90
framework/src/main/java/cn/lili/modules/order/cart/service/CartServiceImpl.java
View File

@ -2,6 +2,7 @@ package cn.lili.modules.order.cart.service;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.cache.Cache;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.AuthUser;
@ -23,16 +24,16 @@ import cn.lili.modules.order.cart.entity.vo.TradeParams;
import cn.lili.modules.order.cart.render.TradeBuilder;
import cn.lili.modules.order.order.entity.dos.Trade;
import cn.lili.modules.order.order.entity.vo.ReceiptVO;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import cn.lili.modules.promotion.entity.dos.MemberCoupon;
import cn.lili.modules.promotion.entity.dos.Pintuan;
import cn.lili.modules.promotion.entity.dos.PromotionGoods;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.enums.CouponScopeTypeEnum;
import cn.lili.modules.promotion.entity.enums.KanJiaStatusEnum;
import cn.lili.modules.promotion.entity.enums.MemberCouponStatusEnum;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.modules.promotion.service.MemberAddressService;
import cn.lili.modules.promotion.service.MemberCouponService;
import cn.lili.modules.promotion.service.PintuanService;
import cn.lili.modules.promotion.service.PromotionGoodsService;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivitySearchParams;
import cn.lili.modules.promotion.service.*;
import cn.lili.modules.search.entity.dos.EsGoodsIndex;
import cn.lili.modules.search.service.EsGoodsSearchService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@ -93,6 +94,13 @@ public class CartServiceImpl implements CartService {
*/
@Autowired
private PintuanService pintuanService;
/**
* 砍价
*/
@Autowired
private KanjiaActivityService kanjiaActivityService;
@Autowired
private KanjiaActivityGoodsService kanjiaActivityGoodsService;
/**
* 交易
*/
@ -147,32 +155,26 @@ public class CartServiceImpl implements CartService {
CartSkuVO cartSkuVO = new CartSkuVO(dataSku);
cartSkuVO.setCartType(cartTypeEnum);
promotionGoodsService.updatePromotion(cartSkuVO);
//再设置加入购物车的数量
this.checkSetGoodsQuantity(cartSkuVO, skuId, num);
//拼团判定
checkPintuan(cartTypeEnum, cartSkuVO);
//检测购物车数据
checkCart(cartTypeEnum, cartSkuVO, skuId, num);
//计算购物车小计
cartSkuVO.setSubTotal(CurrencyUtil.mul(cartSkuVO.getPurchasePrice(), cartSkuVO.getNum()));
cartSkuVOS.add(cartSkuVO);
}
tradeDTO.setCartTypeEnum(cartTypeEnum);
//如购物车发生更改，则重置优惠券
tradeDTO.setStoreCoupons(null);
tradeDTO.setPlatformCoupon(null);
this.resetTradeDTO(tradeDTO);
} catch (ServiceException se) {
throw se;
} catch (ServiceException serviceException) {
throw serviceException;
} catch (Exception e) {
log.error("购物车渲染异常", e);
throw new ServiceException(errorMessage);
}
}
@Override
public void updateNum(String skuId, int num) {
try {
@ -637,15 +639,35 @@ public class CartServiceImpl implements CartService {
}
/**
* 校验拼团信息
* 检测购物车
*
* @param cartTypeEnum 购物车枚举
* @param cartSkuVO SKUVO
* @param skuId SkuId
* @param num 数量
*/
private void checkCart(CartTypeEnum cartTypeEnum, CartSkuVO cartSkuVO, String skuId, Integer num) {
//拼团判定
if (cartTypeEnum.equals(CartTypeEnum.PINTUAN)) {
checkPintuan(cartSkuVO);
//砍价判定
} else if (cartTypeEnum.equals(CartTypeEnum.KANJIA)) {
checkKanjia(cartSkuVO);
//检测购物车的数量
} else {
this.checkSetGoodsQuantity(cartSkuVO, skuId, num);
}
}
/**
* 校验拼团信息
*
* @param cartSkuVO 购物车信息
*/
private void checkPintuan(CartTypeEnum cartTypeEnum, CartSkuVO cartSkuVO) {
private void checkPintuan(CartSkuVO cartSkuVO) {
//拼团活动的话，需要对限购数量进行判定
if (cartTypeEnum.equals(CartTypeEnum.PINTUAN)) {
//拼团活动，需要对限购数量进行判定
//获取拼团信息
List<PromotionGoods> currentPromotion = cartSkuVO.getPromotions().stream().filter(
promotionGoods -> (promotionGoods.getPromotionType().equals(PromotionTypeEnum.PINTUAN.name())))
@ -657,12 +679,40 @@ public class CartServiceImpl implements CartService {
} else {
throw new ServiceException(ResultCode.CART_PINTUAN_NOT_EXIST_ERROR);
}
//检测拼团限购数量
Pintuan pintuan = pintuanService.getPintuanById(cartSkuVO.getPintuanId());
Integer limitNum = pintuan.getLimitNum();
if (limitNum != 0 && cartSkuVO.getNum() > limitNum) {
throw new ServiceException(ResultCode.CART_PINTUAN_LIMIT_ERROR);
}
}
/**
* 校验砍价信息
*
* @param cartSkuVO 购物车信息
*/
private void checkKanjia(CartSkuVO cartSkuVO) {
//根据skuId获取砍价商品
KanjiaActivityGoodsDTO kanjiaActivityGoodsDTO=kanjiaActivityGoodsService.getKanjiaGoodsBySkuId(cartSkuVO.getGoodsSku().getId());
//查找当前会员的砍价商品活动
KanjiaActivitySearchParams kanjiaActivitySearchParams = new KanjiaActivitySearchParams();
kanjiaActivitySearchParams.setKanjiaActivityGoodsId(kanjiaActivityGoodsDTO.getId());
kanjiaActivitySearchParams.setMemberId(UserContext.getCurrentUser().getId());
kanjiaActivitySearchParams.setStatus(KanJiaStatusEnum.SUCCESS.name());
KanjiaActivity kanjiaActivity = kanjiaActivityService.getKanjiaActivity(kanjiaActivitySearchParams);
//校验砍价活动是否满足条件
//判断发起砍价活动
if (kanjiaActivity == null) {
throw new ServiceException(ResultCode.KANJIA_ACTIVITY_NOT_FOUND_ERROR);
//判断砍价活动是否已满足条件
} else if (!KanJiaStatusEnum.SUCCESS.name().equals(kanjiaActivity.getStatus())) {
throw new ServiceException(ResultCode.KANJIA_ACTIVITY_NOT_PASS_ERROR);
}
//砍价商品默认一件货物
cartSkuVO.setNum(1);
}
}

7
framework/src/main/java/cn/lili/modules/order/order/entity/dos/Order.java
View File

@ -1,5 +1,6 @@
package cn.lili.modules.order.order.entity.dos;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import cn.lili.mybatis.BaseEntity;
import cn.lili.common.utils.BeanUtil;
@ -253,6 +254,7 @@ public class Order extends BaseEntity {
* 2.普通订单进行区分：实物订单、虚拟订单
* 3.促销订单判断货物进行区分实物、虚拟商品。
* 4.拼团订单需要填写父订单ID
*
* @param cartVO 购物车VO
* @param tradeDTO 交易DTO
*/
@ -266,7 +268,7 @@ public class Order extends BaseEntity {
} else {
//促销订单（拼团、积分）-判断购买的是虚拟商品还是实物商品
String goodsType = cartVO.getSkuList().get(0).getGoodsSku().getGoodsType();
if(goodsType.equals(GoodsTypeEnum.PHYSICAL_GOODS.name())){
if (StrUtil.isEmpty(goodsType) || goodsType.equals(GoodsTypeEnum.PHYSICAL_GOODS.name())) {
this.setOrderType(OrderTypeEnum.NORMAL.name());
} else {
this.setOrderType(OrderTypeEnum.VIRTUAL.name());
@ -276,7 +278,8 @@ public class Order extends BaseEntity {
//判断是否为拼团订单，如果为拼团订单获取拼团ID，判断是否为主订单
if (tradeDTO.getCartTypeEnum().name().equals(PromotionTypeEnum.PINTUAN.name())) {
Optional<String> pintuanId = cartVO.getSkuList().get(0).getPromotions().stream().filter(i -> i.getPromotionType().equals(PromotionTypeEnum.PINTUAN.name())).map(PromotionGoods::getPromotionId).findFirst();
Optional<String> pintuanId = cartVO.getSkuList().get(0).getPromotions().stream()
.filter(i -> i.getPromotionType().equals(PromotionTypeEnum.PINTUAN.name())).map(PromotionGoods::getPromotionId).findFirst();
promotionId = pintuanId.get();
}
}

11
framework/src/main/java/cn/lili/modules/order/order/entity/dos/StoreFlow.java
View File

@ -91,6 +91,17 @@ public class StoreFlow {
@ApiModelProperty(value = "流水类型：PAY/REFUND 支付/退款", allowableValues = "PAY,REFUND")
private String flowType;
/**
* @see cn.lili.modules.order.order.entity.enums.OrderPromotionTypeEnum
*/
@ApiModelProperty(value = "订单促销类型")
private String orderPromotionType;
@ApiModelProperty(value = "积分活动商品结算价格")
private Double pointSettlementPrice;
@ApiModelProperty(value = "砍价活动商品结算价格")
private Double kanjiaSettlementPrice;
@ApiModelProperty(value = "平台优惠券 使用金额")
private Double siteCouponPrice;

3
framework/src/main/java/cn/lili/modules/order/order/entity/dto/PriceDetailDTO.java
View File

@ -81,6 +81,9 @@ public class PriceDetailDTO implements Serializable {
@ApiModelProperty(value = "流水金额(入账 出帐金额) = goodsPrice + freight - discountPrice - couponPrice + updatePrice")
private Double flowPrice;
@ApiModelProperty(value = "结算价格 与 商家/供应商 结算价格（例如积分商品/砍价商品）")
private Double settlementPrice;
@ApiModelProperty(value = "最终结算金额 = flowPrice - platFormCommission - distributionCommission")
private Double billPrice;

10
framework/src/main/java/cn/lili/modules/order/order/entity/enums/OrderPromotionTypeEnum.java
View File

@ -8,6 +8,10 @@ package cn.lili.modules.order.order.entity.enums;
*/
public enum OrderPromotionTypeEnum {
/**
* 普通订单
*/
NORMAL,
/**
* 赠品订单
*/
@ -19,6 +23,10 @@ public enum OrderPromotionTypeEnum {
/**
* 积分订单
*/
POINT
POINTS,
/**
* 砍价订单
*/
KANJIA
}

21
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/StoreFlowServiceImpl.java
View File

@ -7,6 +7,7 @@ import cn.lili.modules.order.order.entity.dos.Order;
import cn.lili.modules.order.order.entity.dos.OrderItem;
import cn.lili.modules.order.order.entity.dos.StoreFlow;
import cn.lili.modules.order.order.entity.enums.FlowTypeEnum;
import cn.lili.modules.order.order.entity.enums.OrderPromotionTypeEnum;
import cn.lili.modules.order.order.entity.enums.PayStatusEnum;
import cn.lili.modules.order.order.mapper.StoreFlowMapper;
import cn.lili.modules.order.order.service.OrderItemService;
@ -25,7 +26,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
@ -63,14 +63,13 @@ public class StoreFlowServiceImpl extends ServiceImpl<StoreFlowMapper, StoreFlow
//根据订单编号获取订单数据
Order order = orderService.getBySn(orderSn);
List<String> sns = new ArrayList<>();
sns.add(order.getSn());
sns.add(order.getTradeSn());
//如果查询到多条支付记录，打印日志
if (order.getPayStatus().equals(PayStatusEnum.PAID.name())) {
log.error("订单[{}]检测到重复付款，请处理", orderSn);
}
//获取订单促销类型,如果为促销订单则获取促销商品并获取结算价
String orderPromotionType = order.getOrderPromotionType();
//循环子订单记录流水
for (OrderItem item : orderItems) {
StoreFlow storeFlow = new StoreFlow();
@ -93,6 +92,18 @@ public class StoreFlowServiceImpl extends ServiceImpl<StoreFlowMapper, StoreFlow
storeFlow.setCommissionPrice(item.getPriceDetailDTO().getPlatFormCommission());
storeFlow.setDistributionRebate(item.getPriceDetailDTO().getDistributionCommission());
storeFlow.setBillPrice(item.getPriceDetailDTO().getBillPrice());
//兼容为空，以及普通订单操作
if (StringUtils.isNotEmpty(orderPromotionType) || orderPromotionType.equals(OrderPromotionTypeEnum.NORMAL.name())) {
//普通订单操作
}
//如果为砍价活动，填写砍价结算价
else if (orderPromotionType.equals(OrderPromotionTypeEnum.KANJIA.name())) {
storeFlow.setKanjiaSettlementPrice(item.getPriceDetailDTO().getSettlementPrice());
}
//如果为砍价活动，填写砍价结算价
else if (orderPromotionType.equals(OrderPromotionTypeEnum.POINTS.name())) {
storeFlow.setPointSettlementPrice(item.getPriceDetailDTO().getSettlementPrice());
}
//添加支付方式
storeFlow.setPaymentName(order.getPaymentMethod());

2
framework/src/main/java/cn/lili/modules/order/order/serviceimpl/TradeServiceImpl.java
View File

File diff suppressed because one or more lines are too long

60
framework/src/main/java/cn/lili/modules/promotion/entity/dos/KanjiaActivity.java Normal file
View File

@ -0,0 +1,60 @@
package cn.lili.modules.promotion.entity.dos;
import cn.lili.modules.promotion.entity.enums.KanJiaStatusEnum;
import cn.lili.mybatis.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
* 砍价活动参与实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@Entity
@Table(name = "li_kanjia_activity")
@TableName("li_kanjia_activity")
@ApiModel(value = "砍价活动参与对象")
public class KanjiaActivity extends BaseEntity {
private static final long serialVersionUID = -1583030890805926292L;
@ApiModelProperty(value = "砍价商品id")
private String kanjiaActivityGoodsId;
@ApiModelProperty(value = "发起砍价活动会员id")
private String memberId;
@ApiModelProperty(value = "发起砍价活动会员名称")
private String memberName;
@ApiModelProperty(value = "剩余购买金额")
private Double surplusPrice;
@ApiModelProperty(value = "砍价最低购买金额")
private Double purchasePrice;
@ApiModelProperty(value = "砍价商品skuId")
private String skuId;
@ApiModelProperty(value = "货品名称")
private String goodsName;
@ApiModelProperty(value = "缩略图")
private String thumbnail;
/**
* @see KanJiaStatusEnum
*/
@ApiModelProperty(value = "砍价活动状态")
private String status;
}

60
framework/src/main/java/cn/lili/modules/promotion/entity/dos/KanjiaActivityGoods.java Normal file
View File

@ -0,0 +1,60 @@
package cn.lili.modules.promotion.entity.dos;
import cn.lili.modules.promotion.entity.dto.BasePromotion;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.Table;
import javax.validation.constraints.NotEmpty;
/**
* 砍价活动商品实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@Entity
@Table(name = "li_kanjia_activity_goods")
@TableName("li_kanjia_activity_goods")
@ApiModel(value = "砍价活动商品对象")
public class KanjiaActivityGoods extends BasePromotion {
private static final long serialVersionUID = 6694714877345423488L;
@ApiModelProperty(value = "结算价格")
@NotEmpty(message = "结算价格不能为空")
private Double settlementPrice;
@ApiModelProperty(value = "商品原价")
private Double originalPrice;
@ApiModelProperty(value = "最低购买金额")
@NotEmpty(message = "最低购买金额不能为空")
private Double purchasePrice;
@ApiModelProperty(value = "货品id")
@NotEmpty(message = "货品id不能为空")
private String skuId;
@ApiModelProperty(value = "货品名称")
private String goodsName;
@ApiModelProperty(value = "缩略图")
private String thumbnail;
@ApiModelProperty(value = "活动库存")
@NotEmpty(message = "活动库存不能为空")
private Integer stock;
@ApiModelProperty(value = "每人最低砍价金额")
@NotEmpty(message = "每人最低砍价金额不能为空")
private Double lowestPrice;
@ApiModelProperty(value = "每人最高砍价金额")
@NotEmpty(message = "每人最高砍价金额不能为空")
private Double highestPrice;
}

47
framework/src/main/java/cn/lili/modules/promotion/entity/dos/KanjiaActivityLog.java Normal file
View File

@ -0,0 +1,47 @@
package cn.lili.modules.promotion.entity.dos;
import cn.lili.mybatis.BaseEntity;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.Table;
/**
* 砍价活动商品实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@Entity
@Table(name = "li_kanjia_activity_log")
@TableName("li_kanjia_activity_log")
@ApiModel(value = "砍价活动日志对象")
public class KanjiaActivityLog extends BaseEntity {
private static final long serialVersionUID = 3977352717995562783L;
@ApiModelProperty(value = "砍价活动参与记录id")
private String kanjiaActivityId;
@ApiModelProperty(value = "砍价会员id")
private String kanjiaMemberId;
@ApiModelProperty(value = "砍价会员名称")
private String kanjiaMemberName;
@ApiModelProperty(value = "砍价会员头像")
private String kanjiaMemberFace;
@ApiModelProperty(value = "砍价金额")
private Double kanjiaPrice;
@ApiModelProperty(value = "剩余购买金额")
private Double surplusPrice;
}

7
framework/src/main/java/cn/lili/modules/promotion/entity/dto/GoodsSkuPromotionPriceDTO.java
View File

@ -53,8 +53,8 @@ public class GoodsSkuPromotionPriceDTO implements Serializable {
@ApiModelProperty(value = "单个商品积分购买数量")
private Double points;
@ApiModelProperty(value = "商品购买总数量 = 单个商品积分购买数量 * 数量")
private Double totalPoints;
@ApiModelProperty(value = "商品购买积分总数量 = 单个商品积分购买数量 * 数量")
private Long totalPoints;
@ApiModelProperty(value = "单个优惠的所占总优惠金额比例")
private Double discountPriceRate;
@ -102,8 +102,9 @@ public class GoodsSkuPromotionPriceDTO implements Serializable {
this.setOriginalPrice(sku.getPrice());
this.setCouponPrice(0D);
this.setPoints(0d);
this.setTotalPoints(0d);
this.setTotalPoints(0L);
this.setFinalePrice(sku.getPrice());
this.setJoinPromotion(new ArrayList<>());
}
}

37
framework/src/main/java/cn/lili/modules/promotion/entity/dto/KanJiaActivityLogQuery.java Normal file
View File

@ -0,0 +1,37 @@
package cn.lili.modules.promotion.entity.dto;
import cn.hutool.core.text.CharSequenceUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价活动参与实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@ApiModel(value = "砍价活动参与记录查询对象")
public class KanJiaActivityLogQuery {
private static final long serialVersionUID = -1583030890805926292L;
@ApiModelProperty(value = "砍价发起活动id")
private String kanJiaActivityId;
public <T> QueryWrapper<T> wrapper() {
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(kanJiaActivityId)) {
queryWrapper.like("kanjia_activity_id", kanJiaActivityId);
}
queryWrapper.eq("delete_flag", false);
queryWrapper.orderByDesc("create_time");
return queryWrapper;
}
}

23
framework/src/main/java/cn/lili/modules/promotion/entity/dto/KanjiaActivityDTO.java Normal file
View File

@ -0,0 +1,23 @@
package cn.lili.modules.promotion.entity.dto;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价活动参与实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@ApiModel(value = "砍价活动参与记录对象")
public class KanjiaActivityDTO extends KanjiaActivityLog {
@ApiModelProperty(value = "砍价商品Id")
private String kanjiaActivityGoodsId;
}

26
framework/src/main/java/cn/lili/modules/promotion/entity/dto/KanjiaActivityGoodsDTO.java Normal file
View File

@ -0,0 +1,26 @@
package cn.lili.modules.promotion.entity.dto;
import cn.lili.modules.goods.entity.dos.GoodsSku;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* 砍价活动商品DTO
*
* @author qiuqiu
* @date 2020/8/21
**/
@Data
public class KanjiaActivityGoodsDTO extends KanjiaActivityGoods implements Serializable {
private static final long serialVersionUID = 1969340823809319805L;
@ApiModelProperty(value = "商品规格详细信息")
private GoodsSku goodsSku;
}

38
framework/src/main/java/cn/lili/modules/promotion/entity/dto/KanjiaActivityGoodsOperationDTO.java Normal file
View File

@ -0,0 +1,38 @@
package cn.lili.modules.promotion.entity.dto;
import com.fasterxml.jackson.annotation.JsonFormat;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.Min;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 砍价活动商品操作DTO
*
* @author qiuqiu
* @date 2020/8/21
**/
@Data
public class KanjiaActivityGoodsOperationDTO implements Serializable {
private static final long serialVersionUID = -1378599087650538592L;
@Min(message = "活动开始时间不能为空", value = 0)
@ApiModelProperty(value = "活动开始时间", required = true)
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
private Date startTime;
@Min(message = "活动结束时间不能为空", value = 0)
@ApiModelProperty(value = "活动结束时间", required = true)
@JsonFormat(timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
private Date endTime;
@ApiModelProperty(value = "砍价活动商品列表")
List<KanjiaActivityGoodsDTO> promotionGoodsList;
}

44
framework/src/main/java/cn/lili/modules/promotion/entity/dto/KanjiaActivityQuery.java Normal file
View File

@ -0,0 +1,44 @@
package cn.lili.modules.promotion.entity.dto;
import cn.hutool.core.text.CharSequenceUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.util.Date;
/**
* 砍价活动参与实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@ApiModel(value = "砍价活动参与记录查询对象")
public class KanjiaActivityQuery {
private static final long serialVersionUID = -1583030890805926292L;
@ApiModelProperty(value = "货品名称")
private String goodsName;
@ApiModelProperty(value = "会员id", hidden = true)
private String memberId;
public <T> QueryWrapper<T> wrapper() {
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(goodsName)) {
queryWrapper.like("goods_name", goodsName);
}
if (memberId != null) {
queryWrapper.eq("member_id", memberId);
}
queryWrapper.eq("delete_flag", false);
queryWrapper.orderByDesc("create_time");
return queryWrapper;
}
}

6
framework/src/main/java/cn/lili/modules/promotion/entity/dto/PromotionPriceParamDTO.java
View File

@ -20,4 +20,10 @@ public class PromotionPriceParamDTO {
@ApiModelProperty(value = "拼团id 如果是拼团购买 此值为拼团活动id，当pintuanId为空，则表示普通购买（或者拼团商品，单独购买）")
private String pintuanId;
@ApiModelProperty(value = "砍价ID")
private String kanjiaId;
@ApiModelProperty(value = "积分ID")
private String pointsId;
}

38
framework/src/main/java/cn/lili/modules/promotion/entity/enums/KanJiaStatusEnum.java Normal file
View File

@ -0,0 +1,38 @@
package cn.lili.modules.promotion.entity.enums;
/**
* 砍价活动状态状态枚举
*
* @author Chopper
* @date 2020-03-19 3:53 下午
*/
public enum KanJiaStatusEnum {
/**
* 已开始
*/
START("开始"),
/**
* 砍价失败
*/
FAIL("失败"),
/**
* 砍价成功
*/
SUCCESS("成功"),
/**
* 砍价活动结束
* 已购买、超时未购买都是这个状态
*/
END("已结束");
private final String description;
KanJiaStatusEnum(String str) {
this.description = str;
}
public String description() {
return description;
}
}

30
framework/src/main/java/cn/lili/modules/promotion/entity/vos/kanjia/KanjiaActivityGoodsListVO.java Normal file
View File

@ -0,0 +1,30 @@
package cn.lili.modules.promotion.entity.vos.kanjia;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价商品视图对象
*
* @author paulG
* @date 2021/1/13
**/
@Data
public class KanjiaActivityGoodsListVO {
@ApiModelProperty(value = "砍价活动商品id")
private String id;
@ApiModelProperty(value = "货品名称")
private String goodsName;
@ApiModelProperty(value = "缩略图")
private String thumbnail;
@ApiModelProperty(value = "最低购买金额")
private Double purchasePrice;
@ApiModelProperty(value = "活动库存")
private Integer stock;
}

93
framework/src/main/java/cn/lili/modules/promotion/entity/vos/kanjia/KanjiaActivityGoodsParams.java Normal file
View File

@ -0,0 +1,93 @@
package cn.lili.modules.promotion.entity.vos.kanjia;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import java.io.Serializable;
import java.util.Date;
import java.util.regex.Pattern;
/**
* 砍价活动商品查询通用类
*
* @author qiuqiu
* @date 2020/8/21
**/
@Data
public class KanjiaActivityGoodsParams implements Serializable {
private static final long serialVersionUID = 1344104067705714289L;
@ApiModelProperty(value = "活动商品")
private String goodsName;
@ApiModelProperty(value = "活动开始时间")
private Long startTime;
@ApiModelProperty(value = "活动结束时间")
private Long endTime;
@ApiModelProperty(value = "skuId")
private String skuId;
/**
* @see PromotionStatusEnum
*/
@ApiModelProperty(value = "活动状态")
private String promotionStatus;
public <T> QueryWrapper<T> wrapper() {
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
if (CharSequenceUtil.isNotEmpty(goodsName)) {
queryWrapper.like("goods_name", goodsName);
}
if (promotionStatus != null) {
queryWrapper.eq("promotion_status", promotionStatus);
}
if (startTime != null) {
queryWrapper.ge("start_time", new Date(startTime));
}
if (endTime != null) {
queryWrapper.le("end_time", new Date(endTime));
}
queryWrapper.eq("delete_flag", false);
return queryWrapper;
}
public Query mongoQuery() {
Query query = new Query();
if (CharSequenceUtil.isNotEmpty(goodsName)) {
Pattern pattern = Pattern.compile("^.*" + goodsName + ".*$", Pattern.CASE_INSENSITIVE);
query.addCriteria(Criteria.where("goodsSku.goodsName").regex(pattern));
}
if (CharSequenceUtil.isNotEmpty(promotionStatus)) {
query.addCriteria(Criteria.where("promotionStatus").is(promotionStatus));
}
if (CharSequenceUtil.isNotEmpty(skuId)) {
query.addCriteria(Criteria.where("skuId").is(skuId));
}
if (startTime != null && endTime != null) {
Criteria fromTime = Criteria.where("startTime").gte(new Date(startTime));
Criteria toTime = Criteria.where("endTime").lte(new Date(endTime));
query.addCriteria(fromTime);
query.addCriteria(toTime);
}
query.addCriteria(Criteria.where("deleteFlag").is(false));
Sort.Order order = new Sort.Order(Sort.Direction.DESC, "createTime");
query.with(Sort.by(order));
return query;
}
}

25
framework/src/main/java/cn/lili/modules/promotion/entity/vos/kanjia/KanjiaActivityGoodsVO.java Normal file
View File

@ -0,0 +1,25 @@
package cn.lili.modules.promotion.entity.vos.kanjia;
import cn.lili.modules.goods.entity.dos.GoodsSku;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价商品视图对象
*
* @author paulG
* @date 2021/1/13
**/
@Data
public class KanjiaActivityGoodsVO {
@ApiModelProperty(value = "商品规格详细信息")
private GoodsSku goodsSku;
@ApiModelProperty(value = "最低购买金额")
private Double purchasePrice;
@ApiModelProperty(value = "活动库存")
private Integer stock;
}

42
framework/src/main/java/cn/lili/modules/promotion/entity/vos/kanjia/KanjiaActivitySearchParams.java Normal file
View File

@ -0,0 +1,42 @@
package cn.lili.modules.promotion.entity.vos.kanjia;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价活动搜索参数
*
* @author Bulbasaur
* @date: 2021/7/13 2:41 下午
*/
@Data
public class KanjiaActivitySearchParams {
@ApiModelProperty(value = "砍价活动ID")
private String id;
@ApiModelProperty(value = "砍价商品SkuID")
private String kanjiaActivityGoodsId;
@ApiModelProperty(value = "会员ID" ,hidden = true)
private String memberId;
@ApiModelProperty(value = "状态")
private String status;
@ApiModelProperty(value = "邀请活动ID，有值说明是被邀请人")
private String kanjiaActivityId;
public <T> QueryWrapper<T> wrapper() {
QueryWrapper<T> queryWrapper = new QueryWrapper<>();
queryWrapper.eq(StrUtil.isNotEmpty(id), "id", id);
queryWrapper.eq(StrUtil.isNotEmpty(kanjiaActivityId), "id", kanjiaActivityId);
queryWrapper.eq(StrUtil.isNotEmpty(kanjiaActivityGoodsId), "kanjia_activity_goods_id", kanjiaActivityGoodsId);
queryWrapper.eq(StrUtil.isNotEmpty(memberId), "member_id", memberId);
queryWrapper.eq(StrUtil.isNotEmpty(status), "status", status);
return queryWrapper;
}
}

33
framework/src/main/java/cn/lili/modules/promotion/entity/vos/kanjia/KanjiaActivityVO.java Normal file
View File

@ -0,0 +1,33 @@
package cn.lili.modules.promotion.entity.vos.kanjia;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
/**
* 砍价活动参与实体类
*
* @author qiuqiu
* @date 2020-7-1 10:44 上午
*/
@Data
@ApiModel(value = "砍价活动VO")
public class KanjiaActivityVO extends KanjiaActivity {
@ApiModelProperty(value = "是否可以砍价")
private Boolean help;
@ApiModelProperty(value = "是否已发起砍价")
private Boolean launch;
@ApiModelProperty(value = "是否可购买")
private Boolean pass;
public KanjiaActivityVO() {
this.setHelp(false);
this.setLaunch(false);
this.setPass(false);
}
}

30
framework/src/main/java/cn/lili/modules/promotion/mapper/KanJiaActivityGoodsMapper.java Normal file
View File

@ -0,0 +1,30 @@
package cn.lili.modules.promotion.mapper;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsListVO;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
/**
*
* 砍价活动商品数据处理层
*
* @author qiuqiu
* @date 2021/7/1
*/
public interface KanJiaActivityGoodsMapper extends BaseMapper<KanjiaActivityGoods> {
/**
* 获取砍价商品VO分页
* @param page 分页
* @param queryWrapper 查询条件
* @return 砍价商品VO分页
*/
@Select("SELECT * FROM li_kanjia_activity_goods ${ew.customSqlSegment}")
IPage<KanjiaActivityGoodsListVO> kanjiaActivityGoodsVOPage(IPage<KanjiaActivityGoods> page, @Param(Constants.WRAPPER) Wrapper<KanjiaActivityGoods> queryWrapper);
}

15
framework/src/main/java/cn/lili/modules/promotion/mapper/KanJiaActivityLogMapper.java Normal file
View File

@ -0,0 +1,15 @@
package cn.lili.modules.promotion.mapper;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
*
* 砍价活动日志数据处理层
*
* @author qiuqiu
* @date 2021/7/1
*/
public interface KanJiaActivityLogMapper extends BaseMapper<KanjiaActivityLog> {
}

15
framework/src/main/java/cn/lili/modules/promotion/mapper/KanJiaActivityMapper.java Normal file
View File

@ -0,0 +1,15 @@
package cn.lili.modules.promotion.mapper;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
*
* 砍价活动参与记录 数据处理层
*
* @author qiuqiu
* @date 2021/7/1
*/
public interface KanJiaActivityMapper extends BaseMapper<KanjiaActivity> {
}

98
framework/src/main/java/cn/lili/modules/promotion/service/KanjiaActivityGoodsService.java Normal file
View File

@ -0,0 +1,98 @@
package cn.lili.modules.promotion.service;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsOperationDTO;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsListVO;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsParams;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsVO;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* 砍价业务层
*
* @author qiuqiu
* @date 2021/7/1 9:45 上午
*/
public interface KanjiaActivityGoodsService extends IService<KanjiaActivityGoods> {
/**
* 添加砍价活动商品
*
* @param kanJiaActivityGoodsDTOS 砍价商品
* @return 是否添加成功
*/
Boolean add(KanjiaActivityGoodsOperationDTO kanJiaActivityGoodsDTOS);
/**
* 查询砍价活动商品分页信息
*
* @param kanJiaActivityGoodsParams 砍价活动商品
* @param pageVO 分页信息
* @return 砍价商品
*/
IPage<KanjiaActivityGoodsDTO> getForPage(KanjiaActivityGoodsParams kanJiaActivityGoodsParams, PageVO pageVO);
/**
* 查询砍价活动商品分页信息
*
* @param kanJiaActivityGoodsParams 砍价活动商品
* @param pageVO 分页信息
* @return 砍价商品
*/
IPage<KanjiaActivityGoodsListVO> kanjiaGoodsVOPage(KanjiaActivityGoodsParams kanJiaActivityGoodsParams, PageVO pageVO);
/**
* 查询砍价活动商品
*
* @param goodsId 砍价活动商品id
* @return 砍价活动商品信息
*/
KanjiaActivityGoodsDTO getKanjiaGoodsDetail(String goodsId);
/**
* 根据SkuId获取正在进行中的砍价商品
* @param skuId 商品规格Id
* @return 砍价商品
*/
KanjiaActivityGoodsDTO getKanjiaGoodsBySkuId(String skuId);
/**
* 查询砍价活动商品VO
* @param id 砍价活动商品ID
* @return 砍价活动商品
*/
KanjiaActivityGoodsVO getKanJiaGoodsVO(String id);
/**
* 修改看见商品信息
*
* @param kanjiaActivityGoodsDTO 砍价商品信息
* @return 是否修改成功
*/
boolean updateKanjiaActivityGoods(KanjiaActivityGoodsDTO kanjiaActivityGoodsDTO);
/**
* 删除砍价商品
*
* @param ids 砍价商品ids
* @return 是否删除成功
*/
boolean deleteKanJiaGoods(List<String> ids);
/**
* 根据skuID查询当前进行的砍价商品信息
*
* @param skuId 商品skuId
* @return
*/
KanjiaActivityGoodsDTO getKanJiaGoodsBySku(String skuId);
}

36
framework/src/main/java/cn/lili/modules/promotion/service/KanjiaActivityLogService.java Normal file
View File

@ -0,0 +1,36 @@
package cn.lili.modules.promotion.service;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityDTO;
import cn.lili.modules.promotion.entity.dto.KanJiaActivityLogQuery;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* 砍价活动日志业务层
*
* @author qiuqiu
* @date 2021/7/1 9:45 上午
*/
public interface KanjiaActivityLogService extends IService<KanjiaActivityLog> {
/**
* 根据砍价参与记录id查询砍价记录
*
* @param kanJiaActivityLogQuery 砍价活动帮砍信息
* @param pageVO 分页信息
* @return 砍价日志
*/
IPage<KanjiaActivityLog> getForPage(KanJiaActivityLogQuery kanJiaActivityLogQuery, PageVO pageVO);
/**
* 砍一刀
*
* @param kanJiaActivityDTO 砍价记录
* @return
*/
KanjiaActivityLog addKanJiaActivityLog(KanjiaActivityDTO kanJiaActivityDTO);
}

67
framework/src/main/java/cn/lili/modules/promotion/service/KanjiaActivityService.java Normal file
View File

@ -0,0 +1,67 @@
package cn.lili.modules.promotion.service;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityQuery;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivitySearchParams;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityVO;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
/**
* 砍价活动参与记录业务层
*
* @author qiuqiu
* @date 2021/7/1 9:45 上午
*/
public interface KanjiaActivityService extends IService<KanjiaActivity> {
/**
* 获取砍价活动
*
* @param kanJiaActivitySearchParams 砍价活动搜索参数
* @return 砍价活动
*/
KanjiaActivity getKanjiaActivity(KanjiaActivitySearchParams kanJiaActivitySearchParams);
/**
* 获取砍价活动
* <p>
* 有值说明是已参加的砍价活动
* 没有值说明是未参加的砍价活动
*
* @param kanJiaActivitySearchParams 砍价活动搜索参数
* @return 砍价活动
*/
KanjiaActivityVO getKanjiaActivityVO(KanjiaActivitySearchParams kanJiaActivitySearchParams);
/**
* 发起人发起砍价活动
*
* @param id 活动ID
* @return
*/
KanjiaActivityLog add(String id);
/**
* 帮砍
*
* @param kanJiaActivityId 活动id
* @return 砍价详细
*/
KanjiaActivityLog helpKanJia(String kanJiaActivityId);
/**
* 根据条件查询我参与的砍价活动
*
* @param kanJiaActivityQuery 砍价活动查询条件
* @param page 分页对象
* @return 我参与的砍价活动信息
*/
IPage<KanjiaActivity> getForPage(KanjiaActivityQuery kanJiaActivityQuery, PageVO page);
}

6
framework/src/main/java/cn/lili/modules/promotion/service/PointsGoodsService.java
View File

@ -59,12 +59,12 @@ public interface PointsGoodsService extends IService<PointsGoods> {
PointsGoodsVO getPointsGoodsDetail(String id);
/**
* 根据SkuID获取积分商品信息
* 根据ID获取积分详情
*
* @param skuId 商品skuId
* @param skuId 商品SkuId
* @return 积分详情
*/
PointsGoods getPointsGoodsDetailBySkuId(String skuId);
PointsGoodsVO getPointsGoodsVOByMongo(String skuId);
/**
* 根据条件查询积分商品

4
framework/src/main/java/cn/lili/modules/promotion/service/PromotionPriceService.java
View File

@ -1,5 +1,6 @@
package cn.lili.modules.promotion.service;
import cn.lili.modules.order.cart.entity.enums.CartTypeEnum;
import cn.lili.modules.promotion.entity.dos.MemberCoupon;
import cn.lili.modules.promotion.entity.dto.PromotionPriceDTO;
import cn.lili.modules.promotion.entity.dto.PromotionPriceParamDTO;
@ -19,8 +20,9 @@ public interface PromotionPriceService {
*
* @param tradeSkuList 促销计算参数
* @param memberCouponList 使用的优惠券
* @param cartTypeEnum 购物车类型
* @return 促销计算结果
*/
PromotionPriceDTO calculationPromotionPrice(List<PromotionPriceParamDTO> tradeSkuList, List<MemberCoupon> memberCouponList);
PromotionPriceDTO calculationPromotionPrice(List<PromotionPriceParamDTO> tradeSkuList, List<MemberCoupon> memberCouponList, CartTypeEnum cartTypeEnum);
}

336
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/KanjiaActivityGoodsServiceImpl.java Normal file
View File

@ -0,0 +1,336 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.util.StrUtil;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.properties.RocketmqCustomProperties;
import cn.lili.common.utils.DateUtil;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.goods.entity.dos.GoodsSku;
import cn.lili.modules.goods.entity.enums.GoodsStatusEnum;
import cn.lili.modules.goods.service.GoodsSkuService;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsOperationDTO;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsListVO;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsParams;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsVO;
import cn.lili.modules.promotion.mapper.KanJiaActivityGoodsMapper;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import cn.lili.modules.promotion.tools.PromotionTools;
import cn.lili.mybatis.util.PageUtil;
import cn.lili.trigger.enums.DelayTypeEnums;
import cn.lili.trigger.interfaces.TimeTrigger;
import cn.lili.trigger.message.PromotionMessage;
import cn.lili.trigger.model.TimeExecuteConstant;
import cn.lili.trigger.model.TimeTriggerMsg;
import cn.lili.trigger.util.DelayQueueTools;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.ArrayList;
import java.util.List;
/**
* 砍价业务层实现
*
* @author qiuqiu
* @date 2021/7/1
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class KanjiaActivityGoodsServiceImpl extends ServiceImpl<KanJiaActivityGoodsMapper, KanjiaActivityGoods> implements KanjiaActivityGoodsService {
//规格商品
@Autowired
private GoodsSkuService goodsSkuService;
//Rocketmq
@Autowired
private RocketmqCustomProperties rocketmqCustomProperties;
//延时任务
@Autowired
private TimeTrigger timeTrigger;
//Mongo
@Autowired
private MongoTemplate mongoTemplate;
@Override
public Boolean add(KanjiaActivityGoodsOperationDTO kanJiaActivityGoodsOperationDTO) {
List<KanjiaActivityGoods> kanjiaActivityGoodsList = new ArrayList<>();
for (KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO : kanJiaActivityGoodsOperationDTO.getPromotionGoodsList()) {
//根据skuId查询商品信息
GoodsSku goodsSku = this.checkSkuExist(kanJiaActivityGoodsDTO.getSkuId());
//参数检测
this.checkParam(kanJiaActivityGoodsDTO, goodsSku);
//检测同一时间段是否存在相同的商品
PromotionTools.checkPromotionTime(kanJiaActivityGoodsOperationDTO.getStartTime().getTime(), kanJiaActivityGoodsOperationDTO.getEndTime().getTime());
kanJiaActivityGoodsDTO.setStartTime(kanJiaActivityGoodsOperationDTO.getStartTime());
kanJiaActivityGoodsDTO.setEndTime(kanJiaActivityGoodsOperationDTO.getEndTime());
//检测同一时间段不能允许添加相同的商品
if (this.checkSkuDuplicate(goodsSku.getId(), kanJiaActivityGoodsDTO) != null) {
throw new ServiceException("商品id为" + goodsSku.getId() + "的商品已参加砍价商品活动！");
}
kanJiaActivityGoodsDTO.setGoodsSku(goodsSku);
kanJiaActivityGoodsDTO.setSkuId(kanJiaActivityGoodsDTO.getSkuId());
kanJiaActivityGoodsDTO.setThumbnail(goodsSku.getThumbnail());
kanJiaActivityGoodsDTO.setGoodsName(goodsSku.getGoodsName());
kanJiaActivityGoodsDTO.setPromotionStatus(PromotionStatusEnum.NEW.name());
kanJiaActivityGoodsDTO.setOriginalPrice(kanJiaActivityGoodsDTO.getGoodsSku().getPrice());
kanjiaActivityGoodsList.add(kanJiaActivityGoodsDTO);
}
Boolean result = this.saveBatch(kanjiaActivityGoodsList);
if (result) {
//发送砍价延迟任务消息
for (KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO : kanJiaActivityGoodsOperationDTO.getPromotionGoodsList()) {
this.mongoTemplate.save(kanJiaActivityGoodsDTO);
this.addKanJiaGoodsPromotionTask(kanJiaActivityGoodsDTO);
}
}
return result;
}
/**
* 添加砍价商品mq任务
*
* @param kanJiaActivityGoods 砍价商品信息
*/
private void addKanJiaGoodsPromotionTask(KanjiaActivityGoodsDTO kanJiaActivityGoods) {
PromotionMessage promotionMessage = new PromotionMessage(kanJiaActivityGoods.getId(), PromotionTypeEnum.KANJIA.name(),
PromotionStatusEnum.START.name(),
kanJiaActivityGoods.getStartTime(), kanJiaActivityGoods.getEndTime());
TimeTriggerMsg timeTriggerMsg = new TimeTriggerMsg(TimeExecuteConstant.PROMOTION_EXECUTOR,
promotionMessage.getStartTime().getTime(),
promotionMessage,
DelayQueueTools.wrapperUniqueKey(DelayTypeEnums.PROMOTION, (promotionMessage.getPromotionType() + promotionMessage.getPromotionId())),
rocketmqCustomProperties.getPromotionTopic());
//发送促销活动开始的延时任务
this.timeTrigger.addDelay(timeTriggerMsg);
}
@Override
public IPage<KanjiaActivityGoodsDTO> getForPage(KanjiaActivityGoodsParams kanJiaActivityGoodsParams, PageVO pageVO) {
IPage<KanjiaActivityGoodsDTO> kanJiaActivityGoodsDTOIPage = new Page<>();
Query query = kanJiaActivityGoodsParams.mongoQuery();
if (pageVO != null) {
PromotionTools.mongoQueryPageParam(query, pageVO);
kanJiaActivityGoodsDTOIPage.setSize(pageVO.getPageSize());
kanJiaActivityGoodsDTOIPage.setCurrent(pageVO.getPageNumber());
}
List<KanjiaActivityGoodsDTO> kanJiaActivityGoodsDTOS = this.mongoTemplate.find(query, KanjiaActivityGoodsDTO.class);
kanJiaActivityGoodsDTOIPage.setRecords(kanJiaActivityGoodsDTOS);
kanJiaActivityGoodsDTOIPage.setTotal(this.mongoTemplate.count(kanJiaActivityGoodsParams.mongoQuery(), KanjiaActivityGoodsDTO.class));
return kanJiaActivityGoodsDTOIPage;
}
@Override
public IPage<KanjiaActivityGoodsListVO> kanjiaGoodsVOPage(KanjiaActivityGoodsParams kanjiaActivityGoodsParams, PageVO pageVO) {
return this.baseMapper.kanjiaActivityGoodsVOPage(PageUtil.initPage(pageVO),kanjiaActivityGoodsParams.wrapper());
}
/**
* 检查商品Sku是否存
*
* @param skuId skuId
* @return 商品sku
*/
private GoodsSku checkSkuExist(String skuId) {
GoodsSku goodsSku = this.goodsSkuService.getGoodsSkuByIdFromCache(skuId);
if (goodsSku == null) {
log.error("商品ID为" + skuId + "的商品不存在！");
throw new ServiceException();
}
return goodsSku;
}
/**
* 检查参与砍价商品参数
*
* @param kanJiaActivityGoodsDTO 砍价商品信息
* @param goodsSku 商品sku信息
*/
private void checkParam(KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO, GoodsSku goodsSku) {
//校验商品是否存在
if (goodsSku == null) {
throw new ServiceException(ResultCode.PROMOTION_GOODS_NOT_EXIT);
}
//校验商品状态
if (goodsSku.getMarketEnable().equals(GoodsStatusEnum.DOWN.name())) {
throw new ServiceException(ResultCode.GOODS_NOT_EXIST);
}
//校验活动库存是否超出此sku的库存
if (goodsSku.getQuantity() < kanJiaActivityGoodsDTO.getStock()) {
throw new ServiceException(ResultCode.POINT_GOODS_ACTIVE_STOCK_ERROR);
}
//校验最低购买金额不能高于商品金额
if (goodsSku.getPrice() < kanJiaActivityGoodsDTO.getPurchasePrice()) {
throw new ServiceException(ResultCode.KANJIA_GOODS_ACTIVE_PRICE_ERROR);
}
//校验结算价格不能超过商品金额
if (goodsSku.getPrice() < kanJiaActivityGoodsDTO.getSettlementPrice()) {
throw new ServiceException(ResultCode.KANJIA_GOODS_ACTIVE_SETTLEMENT_PRICE_ERROR);
}
//校验最高砍价金额
if (kanJiaActivityGoodsDTO.getHighestPrice() > goodsSku.getPrice() || kanJiaActivityGoodsDTO.getHighestPrice() <= 0) {
throw new ServiceException(ResultCode.KANJIA_GOODS_ACTIVE_HIGHEST_PRICE_ERROR);
}
//校验最低砍价金额
if (kanJiaActivityGoodsDTO.getLowestPrice() > goodsSku.getPrice() || kanJiaActivityGoodsDTO.getLowestPrice() <= 0) {
throw new ServiceException(ResultCode.KANJIA_GOODS_ACTIVE_LOWEST_PRICE_ERROR);
}
//校验最低砍价金额不能高与最低砍价金额
if (kanJiaActivityGoodsDTO.getLowestPrice() > kanJiaActivityGoodsDTO.getHighestPrice()) {
throw new ServiceException(ResultCode.KANJIA_GOODS_ACTIVE_LOWEST_PRICE_ERROR);
}
}
/**
* 检查砍价商品是否重复存在
*
* @param skuId 商品SkuId
* @param kanJiaActivityGoodsDTO 砍价商品
* @return 积分商品信息
*/
private KanjiaActivityGoods checkSkuDuplicate(String skuId, KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO) {
LambdaQueryWrapper<KanjiaActivityGoods> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(KanjiaActivityGoods::getSkuId, skuId);
if (kanJiaActivityGoodsDTO != null && StrUtil.isNotEmpty(kanJiaActivityGoodsDTO.getId())) {
queryWrapper.ne(KanjiaActivityGoods::getId, kanJiaActivityGoodsDTO.getId());
}
queryWrapper.ne(KanjiaActivityGoods::getPromotionStatus, PromotionStatusEnum.END.name());
queryWrapper.ge(KanjiaActivityGoods::getStartTime, kanJiaActivityGoodsDTO.getStartTime());
queryWrapper.le(KanjiaActivityGoods::getEndTime, kanJiaActivityGoodsDTO.getEndTime());
return this.getOne(queryWrapper);
}
@Override
public KanjiaActivityGoodsDTO getKanjiaGoodsDetail(String goodsId) {
KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO = this.mongoTemplate.findById(goodsId, KanjiaActivityGoodsDTO.class);
if (kanJiaActivityGoodsDTO == null) {
log.error("id为" + goodsId + "的砍价商品不存在！");
throw new ServiceException();
}
return kanJiaActivityGoodsDTO;
}
@Override
public KanjiaActivityGoodsDTO getKanjiaGoodsBySkuId(String skuId) {
Query query = new Query();
query.addCriteria(Criteria.where("promotionStatus").is(PromotionStatusEnum.START.name()));
query.addCriteria(Criteria.where("skuId").is(skuId));
List<KanjiaActivityGoodsDTO> kanjiaActivityGoodsDTOS = this.mongoTemplate.find(query, KanjiaActivityGoodsDTO.class);
return kanjiaActivityGoodsDTOS.get(0);
}
@Override
public KanjiaActivityGoodsVO getKanJiaGoodsVO(String id) {
KanjiaActivityGoodsVO kanJiaActivityGoodsVO = new KanjiaActivityGoodsVO();
//获取砍价商品
KanjiaActivityGoods kanJiaActivityGoods=this.getById(id);
//获取商品SKU
GoodsSku goodsSku = this.goodsSkuService.getGoodsSkuByIdFromCache(kanJiaActivityGoods.getSkuId());
//填写活动商品价格、剩余数量
kanJiaActivityGoodsVO.setGoodsSku(goodsSku);
kanJiaActivityGoodsVO.setStock(kanJiaActivityGoods.getStock());
kanJiaActivityGoodsVO.setPurchasePrice(kanJiaActivityGoods.getPurchasePrice());
//返回商品数据
return kanJiaActivityGoodsVO;
}
@Override
public boolean updateKanjiaActivityGoods(KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO) {
//校验砍价商品是否存在
KanjiaActivityGoodsDTO dbKanJiaActivityGoods = this.getKanjiaGoodsDetail(kanJiaActivityGoodsDTO.getId());
//校验当前活动是否已经开始,只有新建的未开始的活动可以编辑
if (!dbKanJiaActivityGoods.getPromotionStatus().equals(PromotionStatusEnum.NEW.name())) {
throw new ServiceException(ResultCode.PROMOTION_UPDATE_ERROR);
}
//获取当前sku信息
GoodsSku goodsSku = this.checkSkuExist(kanJiaActivityGoodsDTO.getSkuId());
//校验商品状态
if (goodsSku.getMarketEnable().equals(GoodsStatusEnum.DOWN.name())) {
throw new ServiceException(ResultCode.GOODS_NOT_EXIST);
}
//常规校验砍价商品参数
this.checkParam(kanJiaActivityGoodsDTO, goodsSku);
//检测开始结束时间是否正确
PromotionTools.checkPromotionTime(kanJiaActivityGoodsDTO.getStartTime().getTime(), kanJiaActivityGoodsDTO.getEndTime().getTime());
//检测同一时间段不能允许添加相同的商品
if (this.checkSkuDuplicate(goodsSku.getId(), kanJiaActivityGoodsDTO) != null) {
throw new ServiceException("商品id为" + goodsSku.getId() + "的商品已参加砍价商品活动！");
}
//修改数据库
boolean result = this.updateById(kanJiaActivityGoodsDTO);
//如果校验成功则发送修改延迟任务消息
if (result) {
this.mongoTemplate.save(kanJiaActivityGoodsDTO);
if (dbKanJiaActivityGoods.getStartTime().getTime() != kanJiaActivityGoodsDTO.getStartTime().getTime()) {
PromotionMessage promotionMessage = new PromotionMessage(kanJiaActivityGoodsDTO.getId(), PromotionTypeEnum.KANJIA.name(), PromotionStatusEnum.START.name(), kanJiaActivityGoodsDTO.getStartTime(), kanJiaActivityGoodsDTO.getEndTime());
//更新延时任务
this.timeTrigger.edit(TimeExecuteConstant.PROMOTION_EXECUTOR,
promotionMessage,
kanJiaActivityGoodsDTO.getStartTime().getTime(),
kanJiaActivityGoodsDTO.getStartTime().getTime(),
DelayQueueTools.wrapperUniqueKey(DelayTypeEnums.PROMOTION, (promotionMessage.getPromotionType() + promotionMessage.getPromotionId())),
DateUtil.getDelayTime(kanJiaActivityGoodsDTO.getStartTime().getTime()),
rocketmqCustomProperties.getPromotionTopic());
}
}
return result;
}
@Override
public boolean deleteKanJiaGoods(List<String> ids) {
List<String> skuIds = new ArrayList<>();
for (String id : ids) {
KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO = this.getKanjiaGoodsDetail(id);
this.timeTrigger.delete(TimeExecuteConstant.PROMOTION_EXECUTOR,
kanJiaActivityGoodsDTO.getStartTime().getTime(),
DelayQueueTools.wrapperUniqueKey(DelayTypeEnums.PROMOTION, (PromotionTypeEnum.KANJIA.name() + kanJiaActivityGoodsDTO.getId())),
rocketmqCustomProperties.getPromotionTopic());
skuIds.add(kanJiaActivityGoodsDTO.getSkuId());
}
boolean result = this.removeByIds(ids);
if (result) {
Query query = new Query();
query.addCriteria(new Criteria("id").in(ids));
this.mongoTemplate.remove(query, KanjiaActivityGoodsDTO.class);
}
return result;
}
@Override
public KanjiaActivityGoodsDTO getKanJiaGoodsBySku(String skuId) {
//mongo查询条件
Query query = new Query();
query.addCriteria(Criteria.where("skuId").is(skuId))
.addCriteria(Criteria.where("promotionStatus").is(PromotionStatusEnum.START.name()));
List<KanjiaActivityGoodsDTO> kanjiaActivityGoodsDTOList=this.mongoTemplate.find(query, KanjiaActivityGoodsDTO.class);
return kanjiaActivityGoodsDTOList.get(0);
}
}

82
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/KanjiaActivityLogServiceImpl.java Normal file
View File

@ -0,0 +1,82 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.context.UserContext;
import cn.lili.common.utils.BeanUtil;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import cn.lili.modules.promotion.entity.dto.KanJiaActivityLogQuery;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityDTO;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import cn.lili.modules.promotion.mapper.KanJiaActivityLogMapper;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import cn.lili.modules.promotion.service.KanjiaActivityLogService;
import cn.lili.modules.promotion.service.KanjiaActivityService;
import cn.lili.mybatis.util.PageUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* 砍价活动日志业务层实现
*
* @author qiuqiu
* @date 2021/7/1
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class KanjiaActivityLogServiceImpl extends ServiceImpl<KanJiaActivityLogMapper, KanjiaActivityLog> implements KanjiaActivityLogService {
@Autowired
private KanjiaActivityGoodsService kanJiaActivityGoodsService;
@Autowired
private KanjiaActivityService kanJiaActivityService;
@Override
public IPage<KanjiaActivityLog> getForPage(KanJiaActivityLogQuery kanJiaActivityLogQuery, PageVO pageVO) {
QueryWrapper<KanjiaActivityLog> queryWrapper = kanJiaActivityLogQuery.wrapper();
return this.page(PageUtil.initPage(pageVO), queryWrapper);
}
@Override
public KanjiaActivityLog addKanJiaActivityLog(KanjiaActivityDTO kanjiaActivityDTO) {
//校验当前会员是否已经参与过此次砍价
LambdaQueryWrapper<KanjiaActivityLog> queryWrapper = new LambdaQueryWrapper<KanjiaActivityLog>();
queryWrapper.eq(kanjiaActivityDTO.getKanjiaActivityId() != null, KanjiaActivityLog::getKanjiaActivityId, kanjiaActivityDTO.getKanjiaActivityId());
queryWrapper.eq( KanjiaActivityLog::getKanjiaMemberId, UserContext.getCurrentUser().getId());
Integer count = this.baseMapper.selectCount(queryWrapper);
if (count > 0) {
throw new ServiceException(ResultCode.KANJIA_ACTIVITY_LOG_MEMBER_ERROR);
}
//校验当前砍价商品是否有效
KanjiaActivityGoods kanjiaActivityGoods = kanJiaActivityGoodsService.getById(kanjiaActivityDTO.getKanjiaActivityGoodsId());
//如果当前活动不为空且还在活动时间内 才可以参与砍价活动
if (kanjiaActivityGoods != null && kanjiaActivityGoods.getPromotionStatus().equals(PromotionStatusEnum.START.name())) {
//获取砍价参与者记录
KanjiaActivity kanjiaActivity = kanJiaActivityService.getById(kanjiaActivityDTO.getKanjiaActivityId());
if (kanjiaActivity != null) {
KanjiaActivityLog kanJiaActivityLog = new KanjiaActivityLog();
kanJiaActivityLog.setKanjiaActivityId(kanjiaActivity.getId());
BeanUtil.copyProperties(kanjiaActivityDTO, kanJiaActivityLog);
boolean result = this.save(kanJiaActivityLog);
if (result) {
return kanJiaActivityLog;
}
}
throw new ServiceException(ResultCode.KANJIA_ACTIVITY_NOT_FOUND_ERROR);
}
throw new ServiceException(ResultCode.PROMOTION_STATUS_END);
}
}

221
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/KanjiaActivityServiceImpl.java Normal file
View File

@ -0,0 +1,221 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.util.RandomUtil;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.security.context.UserContext;
import cn.lili.common.utils.BeanUtil;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.goods.entity.dos.GoodsSku;
import cn.lili.modules.goods.service.GoodsSkuService;
import cn.lili.modules.member.entity.dos.Member;
import cn.lili.modules.member.service.MemberService;
import cn.lili.modules.promotion.entity.dos.KanjiaActivity;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityGoods;
import cn.lili.modules.promotion.entity.dos.KanjiaActivityLog;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityDTO;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityQuery;
import cn.lili.modules.promotion.entity.enums.KanJiaStatusEnum;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivitySearchParams;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityVO;
import cn.lili.modules.promotion.mapper.KanJiaActivityMapper;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import cn.lili.modules.promotion.service.KanjiaActivityLogService;
import cn.lili.modules.promotion.service.KanjiaActivityService;
import cn.lili.mybatis.util.PageUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
/**
* 砍价活动参与记录业务层实现
*
* @author qiuqiu
* @date 2021/7/1
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class KanjiaActivityServiceImpl extends ServiceImpl<KanJiaActivityMapper, KanjiaActivity> implements KanjiaActivityService {
@Autowired
private KanjiaActivityGoodsService kanjiaActivityGoodsService;
@Autowired
private KanjiaActivityLogService kanjiaActivityLogService;
@Autowired
private MemberService memberService;
@Autowired
private GoodsSkuService goodsSkuService;
@Override
public KanjiaActivity getKanjiaActivity(KanjiaActivitySearchParams kanJiaActivitySearchParams) {
return this.getOne(kanJiaActivitySearchParams.wrapper());
}
@Override
public KanjiaActivityVO getKanjiaActivityVO(KanjiaActivitySearchParams kanJiaActivitySearchParams) {
KanjiaActivity kanjiaActivity = this.getKanjiaActivity(kanJiaActivitySearchParams);
KanjiaActivityVO kanjiaActivityVO = new KanjiaActivityVO();
//判断是否参与活动
if (kanjiaActivity == null) {
return kanjiaActivityVO;
}
BeanUtil.copyProperties(kanjiaActivity, kanjiaActivityVO);
//判断是否发起了砍价活动,如果发起可参与活动
if (kanjiaActivity != null) {
kanjiaActivityVO.setLaunch(true);
//如果已发起砍价判断用户是否可以砍价
KanjiaActivityLog kanjiaActivityLog = kanjiaActivityLogService.getOne(new LambdaQueryWrapper<KanjiaActivityLog>()
.eq(KanjiaActivityLog::getKanjiaActivityId, kanjiaActivity.getId())
.eq(KanjiaActivityLog::getKanjiaMemberId, UserContext.getCurrentUser().getId()));
if (kanjiaActivityLog == null) {
kanjiaActivityVO.setHelp(true);
}
//判断活动已通过并且是当前用户发起的砍价则可以进行购买
if (kanjiaActivity.getStatus().equals(KanJiaStatusEnum.SUCCESS.name()) &&
kanjiaActivity.getMemberId().equals(UserContext.getCurrentUser().getId())) {
kanjiaActivityVO.setPass(true);
}
}
return kanjiaActivityVO;
}
@Override
public KanjiaActivityLog add(String id) {
//根据skuId查询当前sku是否参与活动并且是在活动进行中
KanjiaActivityGoods kanJiaActivityGoods = kanjiaActivityGoodsService.getById(id);
//只有砍价商品存在且已经开始的活动才可以发起砍价
if (kanJiaActivityGoods == null || !kanJiaActivityGoods.getPromotionStatus().equals(PromotionStatusEnum.START.name())) {
throw new ServiceException(ResultCode.PROMOTION_STATUS_END);
}
KanjiaActivityLog kanjiaActivityLog = new KanjiaActivityLog();
//获取会员信息
Member member = memberService.getById(UserContext.getCurrentUser().getId());
//校验此活动是否已经发起过
QueryWrapper<KanjiaActivity> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("kanjia_activity_goods_id", kanJiaActivityGoods.getId());
queryWrapper.eq("member_id", member.getId());
if (this.count(queryWrapper) > 0) {
throw new ServiceException(ResultCode.KANJIA_ACTIVITY_MEMBER_ERROR);
}
KanjiaActivity kanJiaActivity = new KanjiaActivity();
//获取商品信息
GoodsSku goodsSku = goodsSkuService.getGoodsSkuByIdFromCache(kanJiaActivityGoods.getSkuId());
if (goodsSku != null && member != null) {
kanJiaActivity.setSkuId(kanJiaActivityGoods.getSkuId());
kanJiaActivity.setGoodsName(goodsSku.getGoodsName());
kanJiaActivity.setKanjiaActivityGoodsId(kanJiaActivityGoods.getId());
kanJiaActivity.setThumbnail(goodsSku.getThumbnail());
kanJiaActivity.setMemberId(UserContext.getCurrentUser().getId());
kanJiaActivity.setMemberName(member.getUsername());
kanJiaActivity.setStatus(KanJiaStatusEnum.START.name());
//剩余砍价金额 开始 是商品金额;
kanJiaActivity.setSurplusPrice(goodsSku.getPrice());
//砍价最低购买金额
kanJiaActivity.setPurchasePrice(kanJiaActivityGoods.getPurchasePrice());
//保存我的砍价活动
boolean result = this.save(kanJiaActivity);
//因为发起砍价就是自己给自己砍一刀，所以要添加砍价记录信息
if (result) {
kanjiaActivityLog = this.helpKanJia(kanJiaActivity.getId());
}
}
return kanjiaActivityLog;
}
@Override
public KanjiaActivityLog helpKanJia(String kanjiaActivityId) {
//获取会员信息
Member member = memberService.getById(UserContext.getCurrentUser().getId());
//根据砍价发起活动id查询砍价活动信息
KanjiaActivity kanjiaActivity = this.getById(kanjiaActivityId);
//判断活动非空或非正在进行中的活动
if (kanjiaActivity == null || !kanjiaActivity.getStatus().equals(PromotionStatusEnum.START.name())) {
throw new ServiceException(ResultCode.PROMOTION_STATUS_END);
} else if (member == null) {
throw new ServiceException(ResultCode.USER_NOT_EXIST);
}
//根据skuId查询当前sku是否参与活动并且是在活动进行中
KanjiaActivityGoods kanJiaActivityGoods = kanjiaActivityGoodsService.getById(kanjiaActivity.getKanjiaActivityGoodsId());
if (kanJiaActivityGoods == null) {
throw new ServiceException(ResultCode.PROMOTION_STATUS_END);
}
//判断是否已参与
LambdaQueryWrapper lambdaQueryWrapper = new LambdaQueryWrapper<KanjiaActivityLog>()
.eq(KanjiaActivityLog::getKanjiaActivityId, kanjiaActivityId)
.eq(KanjiaActivityLog::getKanjiaMemberId, member.getId());
if (kanjiaActivityLogService.count(lambdaQueryWrapper) > 0) {
throw new ServiceException(ResultCode.PROMOTION_LOG_EXIST);
}
//添加砍价记录
KanjiaActivityDTO kanjiaActivityDTO = new KanjiaActivityDTO();
kanjiaActivityDTO.setKanjiaActivityGoodsId(kanjiaActivity.getKanjiaActivityGoodsId());
kanjiaActivityDTO.setKanjiaActivityId(kanjiaActivityId);
//获取砍价金额
Double price = this.getKanjiaPrice(kanJiaActivityGoods, kanjiaActivity.getSurplusPrice());
kanjiaActivityDTO.setKanjiaPrice(price);
//计算剩余金额
kanjiaActivityDTO.setSurplusPrice(CurrencyUtil.sub(kanjiaActivity.getSurplusPrice(), price));
kanjiaActivityDTO.setKanjiaMemberId(member.getId());
kanjiaActivityDTO.setKanjiaMemberName(member.getUsername());
kanjiaActivityDTO.setKanjiaMemberFace(member.getFace());
KanjiaActivityLog kanjiaActivityLog = kanjiaActivityLogService.addKanJiaActivityLog(kanjiaActivityDTO);
//如果可砍金额为0的话说明活动成功了
if (Double.doubleToLongBits(kanjiaActivityDTO.getSurplusPrice()) == Double.doubleToLongBits(0D)) {
kanjiaActivity.setStatus(KanJiaStatusEnum.SUCCESS.name());
}
kanjiaActivity.setSurplusPrice(kanjiaActivityLog.getSurplusPrice());
this.updateById(kanjiaActivity);
return kanjiaActivityLog;
}
/**
* 随机获取砍一刀价格
*
* @param kanjiaActivityGoods 砍价商品信息
* @param surplusPrice 剩余可砍金额
* @return
*/
private Double getKanjiaPrice(KanjiaActivityGoods kanjiaActivityGoods, Double surplusPrice) {
//如果剩余砍价金额小于最低砍价金额则返回0
if (kanjiaActivityGoods.getLowestPrice() > surplusPrice) {
return surplusPrice;
}
//如果金额相等则直接返回
if (kanjiaActivityGoods.getLowestPrice().equals(kanjiaActivityGoods.getHighestPrice())) {
return kanjiaActivityGoods.getLowestPrice();
}
//获取随机砍价金额
BigDecimal bigDecimal = RandomUtil.randomBigDecimal(Convert.toBigDecimal(kanjiaActivityGoods.getLowestPrice()),
Convert.toBigDecimal(kanjiaActivityGoods.getHighestPrice()));
bigDecimal.setScale(2, BigDecimal.ROUND_UP);
return Convert.toDouble(bigDecimal, 0.0);
}
@Override
public IPage<KanjiaActivity> getForPage(KanjiaActivityQuery kanjiaActivityQuery, PageVO page) {
QueryWrapper<KanjiaActivity> queryWrapper = kanjiaActivityQuery.wrapper();
return this.page(PageUtil.initPage(page), queryWrapper);
}
}

20
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PointsGoodsServiceImpl.java
View File

@ -203,20 +203,14 @@ public class PointsGoodsServiceImpl extends ServiceImpl<PointsGoodsMapper, Point
return this.checkExist(id);
}
/**
* 根据SkuID获取积分详情
*
* @param skuId@return 积分详情
*/
@Override
public PointsGoods getPointsGoodsDetailBySkuId(String skuId) {
LambdaQueryWrapper<PointsGoods> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(PointsGoods::getSkuId, skuId).eq(PointsGoods::getPromotionStatus, PromotionStatusEnum.START.name());
List<PointsGoods> list = this.list(queryWrapper);
if (list.size() == 1) {
return list.get(0);
}
return null;
public PointsGoodsVO getPointsGoodsVOByMongo(String skuId) {
//mongo查询条件
Query query = new Query();
query.addCriteria(Criteria.where("skuId").is(skuId))
.addCriteria(Criteria.where("promotionStatus").is(PromotionStatusEnum.START.name()));
List<PointsGoodsVO> pointsGoodsVO=this.mongoTemplate.find(query, PointsGoodsVO.class);
return pointsGoodsVO.get(0);
}
/**

17
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PromotionGoodsServiceImpl.java
View File

@ -2,11 +2,11 @@ package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.utils.BeanUtil;
import cn.lili.common.utils.DateUtil;
import cn.lili.mybatis.util.PageUtil;
import cn.lili.common.vo.PageVO;
import cn.lili.modules.distribution.entity.dos.DistributionGoods;
import cn.lili.modules.distribution.service.DistributionGoodsService;
@ -24,7 +24,6 @@ import cn.lili.modules.promotion.entity.dto.BasePromotion;
import cn.lili.modules.promotion.entity.dto.PromotionGoodsDTO;
import cn.lili.modules.promotion.entity.enums.CouponScopeTypeEnum;
import cn.lili.modules.promotion.entity.enums.PromotionStatusEnum;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.modules.promotion.entity.vos.CouponVO;
import cn.lili.modules.promotion.entity.vos.PromotionGoodsSearchParams;
import cn.lili.modules.promotion.entity.vos.SeckillVO;
@ -32,6 +31,7 @@ import cn.lili.modules.promotion.mapper.PromotionGoodsMapper;
import cn.lili.modules.promotion.service.PointsGoodsService;
import cn.lili.modules.promotion.service.PromotionGoodsService;
import cn.lili.modules.promotion.service.SeckillApplyService;
import cn.lili.mybatis.util.PageUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
@ -123,10 +123,14 @@ public class PromotionGoodsServiceImpl extends ServiceImpl<PromotionGoodsMapper,
//下一次更新时间
cartSkuVO.setUpdatePromotionTime(date);
}
PointsGoods pointsGoods = pointsGoodsService.getPointsGoodsDetailBySkuId(cartSkuVO.getGoodsSku().getId());
//skuvo写入需支付积分
PointsGoods pointsGoods = pointsGoodsService.getPointsGoodsVOByMongo(cartSkuVO.getGoodsSku().getId());
if (pointsGoods != null) {
cartSkuVO.setPoint(pointsGoods.getPoints().intValue());
}
//分销商品
DistributionGoods distributionGoods = distributionGoodsService.distributionGoodsVOBySkuId(cartSkuVO.getGoodsSku().getId());
if (distributionGoods != null) {
cartSkuVO.setDistributionGoods(distributionGoods);
@ -142,8 +146,9 @@ public class PromotionGoodsServiceImpl extends ServiceImpl<PromotionGoodsMapper,
public void getCartSkuPromotion(CartSkuVO cartSkuVO) {
Date date = DateUtil.getCurrentDayEndTime();
LambdaQueryWrapper<PromotionGoods> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(PromotionGoods::getSkuId, cartSkuVO.getGoodsSku().getId()).eq(PromotionGoods::getPromotionStatus, PromotionStatusEnum.START.name());
queryWrapper.le(PromotionGoods::getStartTime, date);
queryWrapper.eq(PromotionGoods::getSkuId, cartSkuVO.getGoodsSku().getId())
.eq(PromotionGoods::getPromotionStatus, PromotionStatusEnum.START.name())
.le(PromotionGoods::getStartTime, date);
//获取有效的促销活动
List<PromotionGoods> promotionGoods = this.list(queryWrapper);
//同步查询缓存中的促销活动商品的库存
@ -168,7 +173,7 @@ public class PromotionGoodsServiceImpl extends ServiceImpl<PromotionGoodsMapper,
promotionGoods.add(p);
}
}
//单独检查，添加适用于全品类的全平台或属于当前店铺的满优惠活动
//单独检查，添加适用于全品类的全平台或属于当前店铺的优惠券活动
List<CouponVO> couponVOS = mongoTemplate.find(query, CouponVO.class);
for (CouponVO couponVO : couponVOS) {
boolean aLLScopeType = (couponVO.getPromotionGoodsList() == null

285
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PromotionPriceServiceImpl.java
View File

@ -1,16 +1,17 @@
package cn.lili.modules.promotion.serviceimpl;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.text.CharSequenceUtil;
import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.common.utils.CurrencyUtil;
import cn.lili.modules.goods.entity.dos.GoodsSku;
import cn.lili.modules.goods.service.GoodsSkuService;
import cn.lili.modules.order.cart.entity.enums.CartTypeEnum;
import cn.lili.modules.promotion.entity.dos.*;
import cn.lili.modules.promotion.entity.dto.*;
import cn.lili.modules.promotion.entity.enums.*;
import cn.lili.modules.promotion.service.PromotionGoodsService;
import cn.lili.modules.promotion.service.PromotionPriceService;
import cn.lili.modules.promotion.service.SeckillApplyService;
import cn.lili.modules.promotion.entity.vos.PointsGoodsVO;
import cn.lili.modules.promotion.service.*;
import cn.lili.modules.search.entity.dos.EsGoodsIndex;
import cn.lili.modules.search.service.EsGoodsSearchService;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
@ -51,46 +52,114 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
*/
@Autowired
private GoodsSkuService goodsSkuService;
/**
* 积分商品
*/
@Autowired
private PointsGoodsService pointsGoodsService;
/**
* 积分商品
*/
@Autowired
private KanjiaActivityGoodsService kanjiaActivityGoodsService;
@Override
public PromotionPriceDTO calculationPromotionPrice(List<PromotionPriceParamDTO> tradeSkuList, List<MemberCoupon> memberCouponList) {
PromotionPriceDTO promotionPrice = new PromotionPriceDTO();
if (!tradeSkuList.isEmpty()) {
public PromotionPriceDTO calculationPromotionPrice(List<PromotionPriceParamDTO> tradeSkuList, List<MemberCoupon> memberCouponList, CartTypeEnum cartTypeEnum) {
List<GoodsSkuPromotionPriceDTO> priceDTOList = new ArrayList<>();
//拆分出SkuId列表
List<String> skuIds = tradeSkuList.parallelStream().map(PromotionPriceParamDTO::getSkuId).collect(Collectors.toList());
//参与计算的ES商品SKU及其促销信息列表
List<EsGoodsIndex> esGoodsSkus = goodsSearchService.getEsGoodsBySkuIds(skuIds);
//判断交易类型，进行不同的处理
if (cartTypeEnum.equals(CartTypeEnum.POINTS)) {
priceDTOList = this.pointGoodsPromotion(tradeSkuList);
} else if (cartTypeEnum.equals(CartTypeEnum.KANJIA)) {
priceDTOList = this.kanjiaPromotion(tradeSkuList);
} else {
//参与计算的缓存中的商品SKU列表
List<GoodsSku> goodsSkus = goodsSkuService.getGoodsSkuByIdFromCache(skuIds);
//计算价格
promotionPrice = this.calculationPromotionPrice(tradeSkuList, memberCouponList, esGoodsSkus, goodsSkus);
//单品商品SKU促销计算结果列表
priceDTOList = this.packageGoodsSkuPromotionPrice(tradeSkuList, esGoodsSkus, goodsSkus);
}
//获取商品促销价格DTO列表
List<StorePromotionPriceDTO> storePromotionPriceList = new ArrayList<>();
//计算优惠券金额
Double couponTotalPrice = 0.0;
//将使用的优惠券根据店铺分类
Map<String, List<MemberCoupon>> couponCollect = memberCouponList.parallelStream().collect(Collectors.groupingBy(MemberCoupon::getStoreId));
//获取店铺优惠券金额
this.getStorePromotionPrice(storePromotionPriceList, priceDTOList, esGoodsSkus, couponCollect, couponTotalPrice);
//获取平台优惠金额
this.getPlatformPromotionPrice(couponCollect, storePromotionPriceList, priceDTOList, couponTotalPrice);
//计算最终结算金额返回数据
return this.getPromotionPriceDTO(storePromotionPriceList, couponTotalPrice);
}
/**
* 获取促销金额DTO
*
* @param storePromotionPriceList 店铺促销列表
* @param couponTotalPrice 优惠券优惠金额
* @return 促销金额DTO
*/
private PromotionPriceDTO getPromotionPriceDTO(List<StorePromotionPriceDTO> storePromotionPriceList, Double couponTotalPrice) {
PromotionPriceDTO promotionPrice = new PromotionPriceDTO();
promotionPrice.setStorePromotionPriceList(storePromotionPriceList);
promotionPrice.setTotalCouponPrice(couponTotalPrice);
promotionPrice.setTotalOriginPrice(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalOriginPrice).sum());
promotionPrice.setTotalPoints(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalPoints).sum());
promotionPrice.setTotalDiscountPrice(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalDiscountPrice).sum());
//最终结算金额 = 商品原价格合计 - 总优惠价格合计 - 优惠券合计
double totalFinalePrice = CurrencyUtil.sub(CurrencyUtil.sub(promotionPrice.getTotalOriginPrice(), promotionPrice.getTotalDiscountPrice()), promotionPrice.getTotalCouponPrice());
promotionPrice.setTotalFinalePrice(totalFinalePrice);
return promotionPrice;
}
/**
* 促销计算
* 获取平台优惠券促销金额
*
* @param tradeSkuList 促销计算参数列表
* @param memberCouponList 参与促销计算的优惠券列表
* @param esGoodsSkus 参与计算的ES商品SKU及其促销信息列表
* @param goodsSkus 参与计算的缓存中的商品SKU列表
* @return 促销计算结果
* @param couponCollect 优惠券列表
* @param storePromotionPriceList 店铺促销列表
* @param priceDTOList 商品促销DTO列表
* @param couponTotalPrice 优惠券金额合计
*/
private PromotionPriceDTO calculationPromotionPrice(List<PromotionPriceParamDTO> tradeSkuList, List<MemberCoupon> memberCouponList, List<EsGoodsIndex> esGoodsSkus, List<GoodsSku> goodsSkus) {
PromotionPriceDTO promotionPrice = new PromotionPriceDTO();
//单品商品SKU促销计算结果列表
List<GoodsSkuPromotionPriceDTO> priceDTOList = this.packageGoodsSkuPromotionPrice(tradeSkuList, esGoodsSkus, goodsSkus);
//将使用的优惠券根据店铺分类
Map<String, List<MemberCoupon>> couponCollect = memberCouponList.parallelStream().collect(Collectors.groupingBy(MemberCoupon::getStoreId));
double couponTotalPrice = 0;
private void getPlatformPromotionPrice(Map<String, List<MemberCoupon>> couponCollect, List<StorePromotionPriceDTO> storePromotionPriceList, List<GoodsSkuPromotionPriceDTO> priceDTOList, Double couponTotalPrice) {
//获取平台优惠券
List<MemberCoupon> platformCoupons = couponCollect.get("platform");
if (platformCoupons != null && !platformCoupons.isEmpty()) {
//计算平台优惠券活动
couponTotalPrice = CurrencyUtil.add(couponTotalPrice, this.calculationCoupon(platformCoupons, priceDTOList));
for (StorePromotionPriceDTO storePromotionPriceDTO : storePromotionPriceList) {
Double couponPrice = storePromotionPriceDTO.getGoodsSkuPromotionPriceList().parallelStream().mapToDouble(GoodsSkuPromotionPriceDTO::getCouponPrice).sum();
storePromotionPriceDTO.setTotalCouponPrice(couponPrice);
}
}
}
/**
* 获取店铺优惠券促销金额
*
* @param storePromotionPriceList 店铺促销金额列表
* @param priceDTOList 商品促销金额DTO列表
* @param esGoodsSkus 商品索引SKU
* @param couponCollect 会员优惠券列表
* @param couponTotalPrice 优惠券金额合计
*/
private void getStorePromotionPrice(List<StorePromotionPriceDTO> storePromotionPriceList, List<GoodsSkuPromotionPriceDTO> priceDTOList,
List<EsGoodsIndex> esGoodsSkus, Map<String, List<MemberCoupon>> couponCollect, Double couponTotalPrice) {
//根据卖家分组商品信息
Map<String, List<GoodsSkuPromotionPriceDTO>> storeCollect = priceDTOList.parallelStream().collect(Collectors.groupingBy(GoodsSkuPromotionPriceDTO::getStoreId));
List<StorePromotionPriceDTO> storePromotionPriceList = new ArrayList<>();
for (Map.Entry<String, List<GoodsSkuPromotionPriceDTO>> entry : storeCollect.entrySet()) {
StorePromotionPriceDTO storePromotionPrice = new StorePromotionPriceDTO();
storePromotionPrice.setStoreId(entry.getKey());
@ -130,27 +199,7 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
storePromotionPriceList.add(storePromotionPrice);
}
//获取平台优惠券
List<MemberCoupon> platformCoupons = couponCollect.get("platform");
if (platformCoupons != null && !platformCoupons.isEmpty()) {
//计算平台优惠券活动
couponTotalPrice = CurrencyUtil.add(couponTotalPrice, this.calculationCoupon(platformCoupons, priceDTOList));
for (StorePromotionPriceDTO storePromotionPriceDTO : storePromotionPriceList) {
Double couponPrice = storePromotionPriceDTO.getGoodsSkuPromotionPriceList().parallelStream().mapToDouble(GoodsSkuPromotionPriceDTO::getCouponPrice).sum();
storePromotionPriceDTO.setTotalCouponPrice(couponPrice);
}
}
promotionPrice.setStorePromotionPriceList(storePromotionPriceList);
promotionPrice.setTotalCouponPrice(couponTotalPrice);
promotionPrice.setTotalOriginPrice(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalOriginPrice).sum());
promotionPrice.setTotalPoints(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalPoints).sum());
promotionPrice.setTotalDiscountPrice(storePromotionPriceList.parallelStream().mapToDouble(StorePromotionPriceDTO::getTotalDiscountPrice).sum());
//最终结算金额 = 商品原价格合计 - 总优惠价格合计 - 优惠券合计
double totalFinalePrice = CurrencyUtil.sub(CurrencyUtil.sub(promotionPrice.getTotalOriginPrice(), promotionPrice.getTotalDiscountPrice()), promotionPrice.getTotalCouponPrice());
promotionPrice.setTotalFinalePrice(totalFinalePrice);
return promotionPrice;
}
/**
* 单品SKU的促销计算
@ -167,19 +216,16 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
if (!collect.isEmpty()) {
EsGoodsIndex esGoodsIndex = collect.get(0);
//找出当前商品相应的结算参数
PromotionPriceParamDTO tradeSku = tradeSkuList.parallelStream().filter(i -> i.getSkuId().equals(skus.getId())).findFirst().orElse(new PromotionPriceParamDTO());
GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice = new GoodsSkuPromotionPriceDTO(skus, tradeSku.getNum());
PromotionPriceParamDTO promotionPriceParamDTO = tradeSkuList.parallelStream().filter(i -> i.getSkuId().equals(skus.getId())).findFirst().orElse(new PromotionPriceParamDTO());
GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice = new GoodsSkuPromotionPriceDTO(skus, promotionPriceParamDTO.getNum());
//商品原价总价 = 商品原价 * 数量
goodsSkuPromotionPrice.setTotalOriginalPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getOriginalPrice(), tradeSku.getNum()));
goodsSkuPromotionPrice.setTotalOriginalPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getOriginalPrice(), promotionPriceParamDTO.getNum()));
//获取当前商品所有参加的促销活动
Map<String, Object> promotionMap = esGoodsIndex.getPromotionMap();
//是否计算拼团促销
String pintuanId = tradeSku.getPintuanId() != null ? tradeSku.getPintuanId() : null;
//如果商品促销列表存在促销活动
this.calculationPromotionMap(promotionMap, goodsSkuPromotionPrice, esGoodsIndex, pintuanId);
this.calculationPromotionMap(promotionMap, goodsSkuPromotionPrice, esGoodsIndex, promotionPriceParamDTO);
goodsSkuPromotionPrice.setTotalOriginalPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getOriginalPrice(), goodsSkuPromotionPrice.getNumber()));
goodsSkuPromotionPrice.setTotalPoints(CurrencyUtil.mul(goodsSkuPromotionPrice.getPoints(), goodsSkuPromotionPrice.getNumber()));
goodsSkuPromotionPrice.setTotalDiscountPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getDiscountPrice(), goodsSkuPromotionPrice.getNumber()));
goodsSkuPromotionPrice.setTotalFinalePrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getFinalePrice(), goodsSkuPromotionPrice.getNumber()));
priceDTOList.add(goodsSkuPromotionPrice);
@ -188,36 +234,79 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
return priceDTOList;
}
/**
* 促销计算(秒杀活动，拼团)
* 计算积分商品
* 积分商品的购买金额是：0
* 1.根据SkuId去查询积分商品（Mongo）
* 2.计算积分商品的优惠信息
*
* @param tradeSkuList 交易商品促销金额列表
* @return 计算结果
*/
private List<GoodsSkuPromotionPriceDTO> pointGoodsPromotion(List<PromotionPriceParamDTO> tradeSkuList) {
List<GoodsSkuPromotionPriceDTO> priceDTOList = new ArrayList<>();
//获取积分商品SkuId
String skuId = tradeSkuList.get(0).getSkuId();
//获取积分商品VO
PointsGoodsVO pointsGoodsVO = pointsGoodsService.getPointsGoodsVOByMongo(skuId);
//参与计算的缓存中的商品SKU列表
GoodsSku goodsSku = pointsGoodsVO.getGoodsSku();
//获取商品促销金额
GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice = new GoodsSkuPromotionPriceDTO(goodsSku, tradeSkuList.get(0).getNum());
//计算商品原价=原价*数量
goodsSkuPromotionPrice.setTotalOriginalPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getOriginalPrice(), goodsSkuPromotionPrice.getNumber()));
//计算商品积分数量=兑换积分*数量
goodsSkuPromotionPrice.setTotalPoints(pointsGoodsVO.getPoints() * Convert.toLong(goodsSkuPromotionPrice.getNumber()));
//优惠金额=商品原价*数量
goodsSkuPromotionPrice.setTotalDiscountPrice(CurrencyUtil.mul(goodsSkuPromotionPrice.getOriginalPrice(), goodsSkuPromotionPrice.getNumber()));
//购买价格=积分商品价格为 0
goodsSkuPromotionPrice.setTotalFinalePrice(0.0);
priceDTOList.add(goodsSkuPromotionPrice);
return priceDTOList;
}
/**
* 计算砍价商品
* 砍价商品只能购买一件
* 1.根据SkuId去查询积分商品（Mongo）
* 2.计算积分商品的优惠信息
*
* @param tradeSkuList 交易商品促销金额列表
* @return 计算结果
*/
private List<GoodsSkuPromotionPriceDTO> kanjiaPromotion(List<PromotionPriceParamDTO> tradeSkuList) {
List<GoodsSkuPromotionPriceDTO> priceDTOList = new ArrayList<>();
//获取积分商品SkuId
String skuId = tradeSkuList.get(0).getSkuId();
//获取积分商品VO
KanjiaActivityGoodsDTO kanjiaActivityGoodsDTO = kanjiaActivityGoodsService.getKanJiaGoodsBySku(skuId);
//参与计算的缓存中的商品SKU列表
GoodsSku goodsSku = kanjiaActivityGoodsDTO.getGoodsSku();
GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice = new GoodsSkuPromotionPriceDTO(goodsSku, tradeSkuList.get(0).getNum());
//优惠金额=商品原价-购买价格
goodsSkuPromotionPrice.setTotalDiscountPrice(CurrencyUtil.sub(goodsSkuPromotionPrice.getOriginalPrice(), kanjiaActivityGoodsDTO.getPurchasePrice()));
//购买价格=砍价成交金额
goodsSkuPromotionPrice.setTotalFinalePrice(kanjiaActivityGoodsDTO.getPurchasePrice());
//原价
goodsSkuPromotionPrice.setTotalOriginalPrice(goodsSkuPromotionPrice.getOriginalPrice());
priceDTOList.add(goodsSkuPromotionPrice);
return priceDTOList;
}
/**
* 促销计算(秒杀活动、拼团、满优惠活动、砍价)
*
* @param promotionMap 当前商品所有参加的促销活动
* @param goodsSkuPromotionPrice 商品SKU促销计算信息
* @param esGoodsIndex ES商品信息
* @param pintuanId 拼团id，标示是否计算拼团活动
* @param promotionPriceParamDTO 拼团id，标示是否计算拼团活动
*/
private void calculationPromotionMap(Map<String, Object> promotionMap, GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice, EsGoodsIndex esGoodsIndex, String pintuanId) {
if (promotionMap != null && !promotionMap.isEmpty()) {
//检查当前商品是否存在秒杀活动活动
Optional<String> existSeckill = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.SECKILL.name())).findFirst();
if (existSeckill.isPresent()) {
Seckill seckill = (Seckill) promotionMap.get(existSeckill.get());
//计算秒杀活动促销
this.calculationSeckill(seckill, goodsSkuPromotionPrice);
seckill.setPromotionName(PromotionTypeEnum.SECKILL.name());
goodsSkuPromotionPrice.getJoinPromotion().add(seckill);
}
//检查当前商品是否存在拼团活动
Optional<String> existPintuan = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.PINTUAN.name())).findFirst();
if (existPintuan.isPresent() && pintuanId != null) {
Pintuan pintuan = (Pintuan) promotionMap.get(existPintuan.get());
//优惠的总价格 = 原商品总价 - 优惠后的商品总价
double discountPrice = CurrencyUtil.sub(goodsSkuPromotionPrice.getOriginalPrice(), esGoodsIndex.getPromotionPrice());
goodsSkuPromotionPrice.setDiscountPrice(discountPrice);
goodsSkuPromotionPrice.setFinalePrice(esGoodsIndex.getPromotionPrice());
pintuan.setPromotionName(PromotionTypeEnum.PINTUAN.name());
goodsSkuPromotionPrice.getJoinPromotion().add(pintuan);
private void calculationPromotionMap(Map<String, Object> promotionMap, GoodsSkuPromotionPriceDTO goodsSkuPromotionPrice, EsGoodsIndex esGoodsIndex, PromotionPriceParamDTO promotionPriceParamDTO) {
//未参加促销则直接返回
if (promotionMap == null || promotionMap.isEmpty()) {
return;
}
//检查当前商品是否存在满优惠活动
@ -228,11 +317,52 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
goodsSkuPromotionPrice.setPromotionType(PromotionTypeEnum.FULL_DISCOUNT.name());
}
//检查当前商品是否存在秒杀活动活动
Optional<String> existSeckill = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.SECKILL.name())).findFirst();
if (existSeckill.isPresent()) {
Seckill seckill = (Seckill) promotionMap.get(existSeckill.get());
//计算秒杀活动促销
this.calculationSeckill(seckill, goodsSkuPromotionPrice);
seckill.setPromotionName(PromotionTypeEnum.SECKILL.name());
goodsSkuPromotionPrice.getJoinPromotion().add(seckill);
}
//检查当前商品是否存在砍价活动
if (promotionPriceParamDTO.getKanjiaId() != null) {
Optional<String> existKanjia = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.KANJIA.name())).findFirst();
if (existKanjia.isPresent()) {
KanjiaActivityGoods kanjiaActivityGoods = (KanjiaActivityGoods) promotionMap.get(existKanjia.get());
//优惠的总价格 = 原商品总价 - 优惠后的商品总价
double discountPrice = CurrencyUtil.sub(kanjiaActivityGoods.getOriginalPrice(), kanjiaActivityGoods.getPurchasePrice());
goodsSkuPromotionPrice.setDiscountPrice(discountPrice);
goodsSkuPromotionPrice.setFinalePrice(kanjiaActivityGoods.getPurchasePrice());
goodsSkuPromotionPrice.getJoinPromotion().add(kanjiaActivityGoods);
}
}
//检查当前商品是否存在拼团活动
else if (promotionPriceParamDTO.getPintuanId() != null) {
Optional<String> existPintuan = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.PINTUAN.name())).findFirst();
if (existPintuan.isPresent()) {
Pintuan pintuan = (Pintuan) promotionMap.get(existPintuan.get());
//优惠的总价格 = 原商品总价 - 优惠后的商品总价
double discountPrice = CurrencyUtil.sub(goodsSkuPromotionPrice.getOriginalPrice(), esGoodsIndex.getPromotionPrice());
goodsSkuPromotionPrice.setDiscountPrice(discountPrice);
goodsSkuPromotionPrice.setFinalePrice(esGoodsIndex.getPromotionPrice());
pintuan.setPromotionName(PromotionTypeEnum.PINTUAN.name());
goodsSkuPromotionPrice.getJoinPromotion().add(pintuan);
}
}
//检查当前商品是否存在积分商品活动
else if (promotionPriceParamDTO.getPointsId() != null) {
Optional<String> existPointsGoods = promotionMap.keySet().parallelStream().filter(i -> i.contains(PromotionTypeEnum.POINTS_GOODS.name())).findFirst();
if (existPointsGoods.isPresent()) {
PointsGoods pointsGoods = (PointsGoods) promotionMap.get(existPointsGoods.get());
goodsSkuPromotionPrice.setPoints(pointsGoods.getPoints().doubleValue());
goodsSkuPromotionPrice.setDiscountPrice(goodsSkuPromotionPrice.getOriginalPrice());
goodsSkuPromotionPrice.setFinalePrice(0.0);
pointsGoods.setPromotionName(pointsGoods.getPromotionName());
goodsSkuPromotionPrice.getJoinPromotion().add(pointsGoods);
}
}
}
@ -346,7 +476,8 @@ public class PromotionPriceServiceImpl implements PromotionPriceService {
*/
private void calculationSeckill(Seckill seckill, GoodsSkuPromotionPriceDTO promotionPrice) {
//检查 活动有效时间 及 活动有效状态
if (checkPromotionValidTime(seckill.getStartTime(), seckill.getEndTime(), PromotionTypeEnum.SECKILL.name(), seckill.getId()) && seckill.getPromotionStatus().equals(PromotionStatusEnum.START.name())) {
if (checkPromotionValidTime(seckill.getStartTime(), seckill.getEndTime(), PromotionTypeEnum.SECKILL.name(), seckill.getId()) &&
seckill.getPromotionStatus().equals(PromotionStatusEnum.START.name())) {
LambdaQueryWrapper<SeckillApply> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SeckillApply::getSkuId, promotionPrice.getSkuId()).eq(SeckillApply::getSeckillId, seckill.getId());
SeckillApply seckillApply = seckillApplyService.getOne(queryWrapper);

36
framework/src/main/java/cn/lili/modules/promotion/serviceimpl/PromotionServiceImpl.java
View File

@ -10,6 +10,7 @@ import cn.lili.common.enums.PromotionTypeEnum;
import cn.lili.trigger.message.PromotionMessage;
import cn.lili.modules.order.cart.entity.vo.FullDiscountVO;
import cn.lili.modules.promotion.entity.dos.*;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.enums.*;
import cn.lili.modules.promotion.entity.vos.CouponVO;
import cn.lili.modules.promotion.entity.vos.PintuanVO;
@ -97,6 +98,8 @@ public class PromotionServiceImpl implements PromotionService {
*/
@Autowired
private MongoTemplate mongoTemplate;
@Autowired
private KanjiaActivityGoodsService kanJiaActivityGoodsService;
@Override
@ -124,7 +127,11 @@ public class PromotionServiceImpl implements PromotionService {
break;
//积分商品
case POINTS_GOODS:
result = this.updatePointsGoods(promotionMessage, esPromotionKey, promotionTypeEnum);
result = this.updatePointsGoods(promotionMessage, promotionTypeEnum);
break;
//砍价商品商品
case KANJIA:
result = this.updateKanjiaGoods(promotionMessage, promotionTypeEnum);
break;
//优惠券活动
case COUPON_ACTIVITY:
@ -432,11 +439,10 @@ public class PromotionServiceImpl implements PromotionService {
* 修改积分商品状态
*
* @param promotionMessage 信息队列传输促销信息实体
* @param esPromotionKey es Key
* @param promotionTypeEnum 促销分类枚举
* @return 修改结果
*/
private boolean updatePointsGoods(PromotionMessage promotionMessage, String esPromotionKey, PromotionTypeEnum promotionTypeEnum) {
private boolean updatePointsGoods(PromotionMessage promotionMessage, PromotionTypeEnum promotionTypeEnum) {
boolean result;
PointsGoodsVO pointsGoodsVO = this.mongoTemplate.findById(promotionMessage.getPromotionId(), PointsGoodsVO.class);
if (pointsGoodsVO == null) {
@ -445,12 +451,31 @@ public class PromotionServiceImpl implements PromotionService {
}
pointsGoodsVO.setPromotionStatus(promotionMessage.getPromotionStatus());
result = this.pointsGoodsService.update(updateWrapper(promotionMessage));
PointsGoods pointsGoods = JSONUtil.toBean(JSONUtil.toJsonStr(pointsGoodsVO), PointsGoods.class);
this.goodsIndexService.updateEsGoodsIndex(pointsGoodsVO.getSkuId(), pointsGoods, esPromotionKey, null);
this.mongoTemplate.save(pointsGoodsVO);
return result;
}
/**
* 修改砍价商品状态
*
* @param promotionMessage 信息队列传输促销信息实体
* @param promotionTypeEnum 促销分类枚举
* @return 修改结果
*/
private boolean updateKanjiaGoods(PromotionMessage promotionMessage, PromotionTypeEnum promotionTypeEnum) {
KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO = this.mongoTemplate.findById(promotionMessage.getPromotionId(), KanjiaActivityGoodsDTO.class);
if (kanJiaActivityGoodsDTO == null) {
this.throwPromotionException(promotionTypeEnum, promotionMessage.getPromotionId(), promotionMessage.getPromotionStatus());
return false;
}
kanJiaActivityGoodsDTO.setPromotionStatus(promotionMessage.getPromotionStatus());
boolean result = this.kanJiaActivityGoodsService.updateById(kanJiaActivityGoodsDTO);
if (result) {
this.mongoTemplate.save(kanJiaActivityGoodsDTO);
}
return result;
}
/**
* 修改优惠券活动状态
*
@ -500,6 +525,7 @@ public class PromotionServiceImpl implements PromotionService {
/**
* 根据消息，获取update wrapper
*
* @param <T>
* @return
*/

7
framework/src/main/java/cn/lili/modules/store/entity/dos/Bill.java
View File

@ -92,6 +92,7 @@ public class Bill {
* -commissionPrice+refundCommissionPrice
* -distributionCommission+distributionRefundCommission
* +siteCouponCommission-siteCouponRefundCommission
* +kanjiaSettlementPrice+pointSettlementPrice
*/
@ApiModelProperty(value = "结算周期内订单付款总金额")
private Double orderPrice;
@ -117,6 +118,12 @@ public class Bill {
@ApiModelProperty(value = "退货平台优惠券补贴返还")
private Double siteCouponRefundCommission;
@ApiModelProperty(value = "积分商品结算价格")
private Double pointSettlementPrice;
@ApiModelProperty(value = "砍价商品结算价格")
private Double kanjiaSettlementPrice;
@ApiModelProperty(value = "最终结算金额")
private Double billPrice;

5
framework/src/main/java/cn/lili/modules/store/mapper/BillMapper.java
View File

@ -37,7 +37,10 @@ public interface BillMapper extends BaseMapper<Bill> {
*/
@Select("SELECT SUM( final_price ) AS orderPrice,SUM( commission_price ) AS commissionPrice" +
",SUM( distribution_rebate ) AS distributionCommission,SUM( site_coupon_commission ) AS siteCouponCommission" +
",SUM( bill_price ) AS billPrice FROM li_store_flow ${ew.customSqlSegment}")
",SUM( point_settlement_price ) AS pointSettlementPrice " +
",SUM( kanjia_settlement_price ) AS kanjiaSettlementPrice " +
",SUM( bill_price ) AS billPrice " +
"FROM li_store_flow ${ew.customSqlSegment}")
Bill getOrderBill(@Param(Constants.WRAPPER) QueryWrapper<Bill> queryWrapper);
/**

6
framework/src/main/java/cn/lili/modules/store/serviceimpl/BillServiceImpl.java
View File

@ -89,7 +89,11 @@ public class BillServiceImpl extends ServiceImpl<BillMapper, Bill> implements Bi
bill.setCommissionPrice(orderBill.getCommissionPrice());
bill.setDistributionCommission(orderBill.getDistributionCommission());
bill.setSiteCouponCommission(orderBill.getSiteCouponCommission());
orderPrice = orderBill.getBillPrice();
bill.setPointSettlementPrice(orderBill.getPointSettlementPrice());
bill.setKanjiaSettlementPrice(orderBill.getKanjiaSettlementPrice());
//入账金额=订单金额+积分商品+砍价商品
orderPrice = CurrencyUtil.add(CurrencyUtil.add(orderBill.getBillPrice(), orderBill.getPointSettlementPrice()),
orderBill.getKanjiaSettlementPrice());
}

77
manager-api/src/main/java/cn/lili/controller/promotion/KanJiaActivityGoodsManagerController.java Normal file
View File

@ -0,0 +1,77 @@
package cn.lili.controller.promotion;
import cn.lili.common.enums.ResultCode;
import cn.lili.common.enums.ResultUtil;
import cn.lili.common.exception.ServiceException;
import cn.lili.common.vo.PageVO;
import cn.lili.common.vo.ResultMessage;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsDTO;
import cn.lili.modules.promotion.entity.dto.KanjiaActivityGoodsOperationDTO;
import cn.lili.modules.promotion.entity.vos.kanjia.KanjiaActivityGoodsParams;
import cn.lili.modules.promotion.service.KanjiaActivityGoodsService;
import com.baomidou.mybatisplus.core.metadata.IPage;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Arrays;
/**
* 管理端,促销接口
*
* @author qiuqiu
* @date 2021/7/2
**/
@RestController
@Api(tags = "管理端,砍价促销接口")
@RequestMapping("/manager/promotion/kan-jia-goods")
public class KanJiaActivityGoodsManagerController {
@Autowired
private KanjiaActivityGoodsService kanJiaActivityGoodsService;
@PostMapping
@ApiOperation(value = "添加砍价活动")
public ResultMessage<Object> add(@RequestBody KanjiaActivityGoodsOperationDTO kanJiaActivityGoodsOperationDTO) {
kanJiaActivityGoodsService.add(kanJiaActivityGoodsOperationDTO);
return ResultUtil.success();
}
@ApiOperation(value = "获取砍价活动分页")
@GetMapping
public ResultMessage<IPage<KanjiaActivityGoodsDTO>> getKanJiaActivityPage(KanjiaActivityGoodsParams KanJiaActivityParams, PageVO page) {
return ResultUtil.data(kanJiaActivityGoodsService.getForPage(KanJiaActivityParams, page));
}
@GetMapping("/{id}")
@ApiOperation(value = "获取积分商品详情")
public ResultMessage<Object> getPointsGoodsDetail(@PathVariable("id") String goodsId) {
KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO = kanJiaActivityGoodsService.getKanjiaGoodsDetail(goodsId);
return ResultUtil.data(kanJiaActivityGoodsDTO);
}
@PutMapping
@ApiOperation(value = "修改砍价商品")
public ResultMessage<Object> updatePointsGoods(@RequestBody KanjiaActivityGoodsDTO kanJiaActivityGoodsDTO) {
kanJiaActivityGoodsService.updateKanjiaActivityGoods(kanJiaActivityGoodsDTO);
return ResultUtil.success();
}
@DeleteMapping("/{ids}")
@ApiOperation(value = "删除砍价商品")
public ResultMessage<Object> delete(@PathVariable String ids) {
if (kanJiaActivityGoodsService.deleteKanJiaGoods(Arrays.asList(ids.split(",")))) {
return ResultUtil.success();
}
throw new ServiceException(ResultCode.KANJIA_GOODS_DELETE_ERROR);
}
}

2
manager-api/src/main/java/cn/lili/controller/promotion/PointsGoodsManagerController.java
View File

@ -39,7 +39,7 @@ public class PointsGoodsManagerController {
List<PointsGoodsVO> collect = new ArrayList<>();
for (PointsGoodsVO i : pointsGoodsList) {
i.setStoreName(i.getGoodsSku().getStoreName());
i.setStoreId(UserContext.getCurrentUser().getStoreId());
i.setStoreId(i.getGoodsSku().getStoreId());
collect.add(i);
}
pointsGoodsService.addPointsGoods(collect);

9
update-sql/version4.2to4.3.sql
View File

@ -16,6 +16,14 @@
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
/** 添加结算单积分、砍价结算价信息**/
ALTER TABLE li_bill ADD point_settlement_price double DEFAULT 0.00 COMMENT '积分商品结算金额 ';
ALTER TABLE li_bill ADD kanjia_settlement_price double DEFAULT 0.00 COMMENT '砍价商品结算金额';
ALTER TABLE li_store_flow ADD point_settlement_price double DEFAULT 0.00 COMMENT '积分商品结算金额';
ALTER TABLE li_store_flow ADD kanjia_settlement_price double DEFAULT 0.00 COMMENT '砍价商品结算金额';
/** 热词管理*/
UPDATE `lilishop`.`li_menu` SET `create_by` = 'admin', `create_time` = '2021-03-03 09:54:51', `delete_flag` = b'0', `update_by` = 'admin', `update_time` = '2021-07-23 19:07:45', `description` = 'null', `front_route` = 'page/article-manage/hotWords', `icon` = 'md-aperture', `level` = 2, `name` = 'hotKeyWord', `parent_id` = '1367050250249830400', `path` = 'hotKeyWord', `sort_order` = 0.00, `title` = '搜索热词', `front_component` = 'null' WHERE `id` = 1367050829697122304;
-- ----------------------------
-- Table structure for li_menu
@ -146,5 +154,4 @@ INSERT INTO `li_menu` VALUES (1407602673334636546, 'admin', '2021-06-23 15:33:24
INSERT INTO `li_menu` VALUES (1410862675914764290, 'admin', '2021-07-02 15:27:29', b'0', 'admin', '2021-07-27 16:06:26', 'null', 'distribution/distributionCash', '', 2, 'distributionCash', '1374173575405109248', 'distributionCash', 5.00, '分销提现', 'null', '/manager/distribution/cash*');
INSERT INTO `li_menu` VALUES (1419926569920536578, 'admin', '2021-07-27 15:44:10', b'0', 'admin', '2021-07-27 16:07:10', NULL, 'customWords/index', NULL, 2, 'customWords', '1367050250249830400', 'customWords', 4.00, 'ES分词', NULL, '/manager/manager/custom-words*');
COMMIT;
SET FOREIGN_KEY_CHECKS = 1;