Skip to content

O
order-group
Commit 71ff516b by 周晓航
Options

Merge branch '支付有礼订单返回券信息新增字段-zxh-20211105' into pre 

# Conflicts:
#	shopping-cart-application-service/src/main/java/cn/freemud/entities/dto/calculate/SendGoods.java
#	shopping-cart-application-service/src/main/java/cn/freemud/service/impl/calculate/promotion/AdditionSharingService.java
parents e3d87365 998699de
Showing with 1566 additions and 578 deletions
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/adapter/OrderSdkAdapter.java
......@@ -25,12 +25,10 @@ import com.freemud.application.sdk.api.util.DateUtil;
import com.freemud.sdk.api.assortment.order.constant.CommonConstant;
import com.freemud.sdk.api.assortment.order.domain.OrderStatesVO;
import com.freemud.sdk.api.assortment.order.domain.ResponseCodeConstant;
import com.freemud.sdk.api.assortment.order.entities.OrderEditInfo;
import com.freemud.sdk.api.assortment.order.enums.*;
import com.freemud.sdk.api.assortment.order.request.order.OrderDownloadRequest;
import com.freemud.sdk.api.assortment.order.request.order.*;
import com.freemud.sdk.api.assortment.order.response.order.*;
//import com.freemud.sdk.api.assortment.order.response.payment.OrderPayResponse;
import com.freemud.sdk.api.assortment.order.util.AssortOrderLogUtil;
import com.freemud.sdk.api.assortment.order.util.ClassUtils;
import com.freemud.sdk.api.assortment.order.util.WeightUtils;
......@@ -48,6 +46,8 @@ import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;
//import com.freemud.sdk.api.assortment.order.response.payment.OrderPayResponse;
@Component
public class OrderSdkAdapter {
......@@ -136,6 +136,7 @@ public class OrderSdkAdapter {
CancelOrderRequest var1 = new CancelOrderRequest();
var1.setOrderId(orderBean.getOid());
var1.setReason(reason);
var1.setOrderClient(Integer.parseInt(orderBean.getOrderClient()));
var1.setPartnerId(orderBean.getCompanyId());
if (orderBean.getRefundList() != null && orderBean.getRefundList().size() != 0) {
//新订单服务需要售后单code
......@@ -170,6 +171,7 @@ public class OrderSdkAdapter {
var1.setRefundSerialNo(refund_id);
var1.setReason(reason);
var1.setOperator(operator);
var1.setOrderClient(orderBean.getOrderClient());
if (orderBean.getRefundList() != null && orderBean.getRefundList().size() != 0) {
//新订单服务需要售后单code
var1.setAfterSalesCode(orderBean.getRefundList().get(orderBean.getRefundList().size() - 1).getRid());
......@@ -657,18 +659,21 @@ public class OrderSdkAdapter {
if ("saas".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.SAAS.getIndex());
}
if ("meals".equals(queryOrdersRequest.getSource()[i])) {
else if ("meals".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.WAI_MEAL.getIndex());
}
if ("saasmall".equals(queryOrdersRequest.getSource()[i])) {
else if ("saasmall".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.SAASMALL.getIndex());
}
if ("app".equals(queryOrdersRequest.getSource()[i])) {
else if ("app".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.APP.getIndex());
}
if ("beautiful".equals(queryOrdersRequest.getSource()[i])) {
else if ("beautiful".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.BEAUTIFUL.getIndex());
}
else if ("cashier".equals(queryOrdersRequest.getSource()[i])) {
orderClients.add(OrderClientType.CASHIER.getIndex());
}
}
orderClients.add(OrderClientType.TIKTOKPAY.getIndex());
orderClients.add(OrderClientType.ALIPAY.getIndex());
......@@ -3009,8 +3014,7 @@ public class OrderSdkAdapter {
orderItemCreateReq.setSettlementPrice(settlementPrice);
totalOriginalProductAmount = weightPrice.longValue();
} else {
Long productPrice = product.getPrice() * product.getNumber();
Long settlementPrice = productPrice - totalDiscountAmount;
Long settlementPrice = product.getPrice() * product.getNumber() - totalDiscountAmount;
orderItemCreateReq.setSalePrice(settlementPrice / product.getNumber());
orderItemCreateReq.setSettlementPrice(settlementPrice);
/**
......@@ -3045,7 +3049,7 @@ public class OrderSdkAdapter {
}
}
// 套餐原价 fisherman 新算价改动,套餐原价直接取 促销给的值, (因为套餐划线价问题)
orderItemCreateReq.setProductPrice(productPrice);
orderItemCreateReq.setProductPrice(product.getPrice());
// 如果套餐没有设置价格取子商品结算价和，否则取套餐自身的结算价
setmealTotalSettlementPrice = product.getPrice() == 0 ? setmealTotalSettlementPrice : settlementPrice;
orderItemCreateReq.setSettlementPrice(setmealTotalSettlementPrice);
......
order-application-service/src/main/java/cn/freemud/constant/KgdRedisKeyConstant.java → assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/constant/OrderRedisKeyConstant.java
package cn.freemud.constant;
package com.freemud.sdk.api.assortment.order.constant;
/**
* @author Clover.z
* @Date 2021/8/11
* @Desc
*/
public class KgdRedisKeyConstant {
public class OrderRedisKeyConstant {
/**
......@@ -14,22 +14,54 @@ public class KgdRedisKeyConstant {
* 1：小程序appId
*
* value: hash结构
* hkey : eatInType 堂食 和takeOutType 外卖
* hkey : HashKeyForOrderRefundConfig中定义
* 具体配置为json字符串
* @see HashKeyForOrderRefundConfig
*/
public static final String ORDER_REFUND_CONFIG = "kgd:order_refund_config_{0}_{1}";
/**
* 订单类型为堂食 redis配置的hkey
* 订单是否支持退款配置 缓存key的value中 hashKey的枚举
* 对于的值为json字符串
* @see com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity
*/
public static final String REFUND_CFG_EAT_IN = "eatInType";
public static class HashKeyForOrderRefundConfig {
/**
* 订单类型为堂食单 redis配置的hkey 对于的值为json字符串
*/
public static final String EAT_IN = "eatInType";
/**
* 订单类型为外卖单 redis配置的hkey 对于的值为json字符串
*/
public static final String TAKE_OUT = "takeOutType";
/**
* 订单类型为收银单 redis配置的hkey 对于的值为json字符串
*/
public static final String CASHIER = "cashierType";
}
/**
* 订单类型为外卖 redis配置的hkey
* 订单配置 缓存key
* 0：商户号
* 1：小程序appId
*
* value: hash结构
* hkey : HashKeyForOrderComplainConfig
* 具体配置为json字符串
* @see HashKeyForOrderRefundConfig
*/
public static final String REFUND_CFG_TAKE_OUT = "takeOutType";
public static final String ORDER_COMPLAIN_KEY = "kgd:order_config_{0}_{1}";
/**
* 订单售后信息相关配置hashKey
*/
public static class HashKeyForOrderComplainConfig {
/**
* 订单售后是否可申诉开关
* hashKey 对于的值为 open/close
*/
public static final String ORDER_COMPLAIN_TYPE = "orderComplaintType";
}
public static final String ORDER_COMPLAIN_TYPE = "orderComplaintType";
/**
* 下单时 支付商品名称redis缓存key，懒加载方式，有效时间为24小时
......@@ -42,4 +74,7 @@ public class KgdRedisKeyConstant {
public static final String PARTNER_PAYMENT_PRINCIPAL_NAME = "kgd:order:payment:principalName:{0}";
}
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/entities/OrderRefundConfigEntity.java 0 → 100644
package com.freemud.sdk.api.assortment.order.entities;
import lombok.Data;
/**
* @author Clover.z
* @Date 2021/10/19
* @Desc 订单退款配置
*/
@Data
public class OrderRefundConfigEntity {
/**
* 未接单状态是否允许退款:
* 0-不允许
* 1-允许
*/
private String takeOrderRefund;
/**
* 已接单状态是否允许退款:
* 0-不允许
* 1-允许
*/
private String receiptOrderRefund;
/**
* 制作完成是否支持退款
* 0-不允许
* 1-允许
*/
private String completeMakeOrderRefund;
/**
* 已完成订单是否允许退款
* 0-不允许
* 1-允许
*/
private String orderRefund;
/**
* 外卖单未接单是否支持退款
* 0-不允许
* 1-允许
*/
private String deliveryTakeOrderRefund;
/**
* 外卖单已接单是否支持退款
* 0-不允许
* 1-允许
*/
private String deliveryReceiptOrderRefund;
/**
* 外卖单制作完成是否支持退款
* 0-不允许
* 1-允许
*/
private String deliveryCompleteMakeOrderRefund;
/**
* 外卖单订单完成是否支持退款
* 0-不允许
* 1-允许
*/
private String deliveryOrderRefund;
/**
* 退款允许日期
*/
private String refundDateRange;
/**
* 商家同意退款时是否退配送费
* 0-不允许
* 1-允许
*/
private String refundShippingFee;
/**
* 退款退优惠券
* 0-不允许
* 1-允许
*/
private String refundReverseCoupon;
/**
* 收银订单是否允许退款
* 0-不允许
* 1-允许
*/
private String cashierOrderRefund;
}
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/enums/OrderSourceType.java
......@@ -45,6 +45,7 @@ public enum OrderSourceType {
BEAUTIFUL("beautiful","美业", 28),
ASSISTANT("assistant","非码小助手", 29),
SHERPAS("sherpas","食派士", 30),
CASHIER("cashier", "收银单", 36),
parkingmanual("parkingmanual", "农工商停车手工录单", 98),
PARKING("parking", "农工商停车", 99),
SDG("sdg", "闪电购", 1000);
......@@ -58,6 +59,14 @@ public enum OrderSourceType {
this.clientType = clientType;
}
public static OrderSourceType valueOfCode(String code) {
for (OrderSourceType e : values()) {
if (e.getCode().equals(code))
return e;
}
return null;
}
/**
* 字符串渠道码转对应数字类型渠道码
*
......
assortment-ordercenter-sdk/src/main/java/com/freemud/sdk/api/assortment/order/service/order/OrderCenterSdkServiceImpl.java
......@@ -1043,7 +1043,7 @@ public class OrderCenterSdkServiceImpl implements OrderCenterSdkService {
AfterSalesOperateReq request = new AfterSalesOperateReq();
request.setOrderCode(baseQueryOrderRequest.getOrderId());
request.setPartnerId(baseQueryOrderRequest.getPartnerId());
request.setOrderClient(OrderClientType.SAAS.getIndex());
request.setOrderClient(Integer.parseInt(baseQueryOrderRequest.getOrderClient()));
request.setAfterSalesCode(baseQueryOrderRequest.getAfterSalesCode());
request.setAfterSerialNo(baseQueryOrderRequest.getRefundSerialNo());
request.setAdultRemark(baseQueryOrderRequest.getReason());
......@@ -1070,7 +1070,7 @@ public class OrderCenterSdkServiceImpl implements OrderCenterSdkService {
AfterSalesOperateReq request = new AfterSalesOperateReq();
request.setOrderCode(baseQueryOrderRequest.getOrderId());
request.setPartnerId(baseQueryOrderRequest.getPartnerId());
request.setOrderClient(OrderClientType.SAAS.getIndex());
request.setOrderClient(Integer.parseInt(baseQueryOrderRequest.getOrderClient()));
request.setAfterSalesCode(baseQueryOrderRequest.getAfterSalesCode());
request.setAfterSerialNo(baseQueryOrderRequest.getRefundSerialNo());
request.setAdultRemark(baseQueryOrderRequest.getReason());
......@@ -1082,7 +1082,7 @@ public class OrderCenterSdkServiceImpl implements OrderCenterSdkService {
@Override
public BaseOrderResponse orderRefundReject(CancelOrderRequest cancelOrderRequest) {
AfterSalesOperateReq request = new AfterSalesOperateReq();
request.setOrderClient(OrderClientType.SAAS.getIndex());
request.setOrderClient(cancelOrderRequest.getOrderClient());
request.setPartnerId(cancelOrderRequest.getPartnerId());
request.setOrderCode(cancelOrderRequest.getOrderId());
request.setAfterSalesCode(cancelOrderRequest.getAfterSalesCode());
......
assortment-shoppingcart-sdk/src/main/java/com/freemud/sdk/api/assortment/shoppingcart/service/ShoppingCartBaseService.java
......@@ -366,7 +366,7 @@ public interface ShoppingCartBaseService {
.collect(Collectors.toList());
}
for (CartGoods cartGoods : cartGoodsByProduct) {
DetailVO detail = detailsMap.get(cartGoods.getSpuId());
DetailVO detail = detailsMap.get(cartGoods.getCouponCode());
String activeCode = detail != null ? detail.getActiveCode() : "";
if (couponOrderWayMap == null || couponOrderWayMap.isEmpty() || !couponOrderWayMap.get(activeCode)) {
orderWayFlag = true;
......
call-back-service/src/main/java/cn/freemud/amp/service/OrderCallBackMQService.java
......@@ -99,10 +99,16 @@ public class OrderCallBackMQService {
* @param body
*/
public void revert(OrderCallBackRequestVo body){
ApiLog.infoMessage("activityReverse start orderCode:{}", body.getOrderCode());
if (ObjectUtils.notEqual(body.getDelayMsgEventType(),2)){
return;
}
String redisKey = "kgd:cancel_payment_oid:" + body.getOrderCode() ;
//取消支付订单缓存,
Object value = redisCache.getValue(redisKey);
if(value != null){
return;
}
ApiLog.infoMessage("activityReverse start orderCode:{}", body.getOrderCode());
String orderCode=body.getOrderCode();
OrderStatusChangeRequestDto requestDto = new OrderStatusChangeRequestDto();
requestDto.setOid(orderCode);
......
order-application-service/src/main/java/cn/freemud/adapter/OrderAdapter.java
......@@ -13,7 +13,10 @@
package cn.freemud.adapter;
import cn.freemud.base.util.DateUtil;
import cn.freemud.constant.*;
import cn.freemud.constant.CommonsConstant;
import cn.freemud.constant.CustomerScoreConstant;
import cn.freemud.constant.RedisKeyConstant;
import cn.freemud.constant.ResponseCodeConstant;
import cn.freemud.entities.dto.*;
import cn.freemud.entities.dto.activity.ShareDiscountActivityDto;
import cn.freemud.entities.dto.order.CreateOrderAccountDto;
......@@ -61,14 +64,16 @@ import com.freemud.application.sdk.api.ordercenter.request.OrderConditionsReq;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtendedReq;
import com.freemud.application.sdk.api.ordercenter.response.BaseDownLoadResponse;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderPayItemResp;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.AfterSalesOrderResp;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderInfoReqs;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderPayItemResp;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderSettlementResp;
import com.freemud.application.sdk.api.promotioncenter.dto.promotion.GoodsStockDTO;
import com.freemud.application.sdk.api.promotioncenter.request.promotion.ActivityUpdateStockRequest;
import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
import com.freemud.sdk.api.assortment.order.constant.OrderRedisKeyConstant;
import com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity;
import com.freemud.sdk.api.assortment.order.enums.*;
import com.freemud.sdk.api.assortment.order.request.order.*;
import com.freemud.sdk.api.assortment.order.request.payment.CombPayRequest;
......@@ -77,7 +82,6 @@ import com.freemud.sdk.api.assortment.order.request.payment.ProductVO;
import com.freemud.sdk.api.assortment.order.response.order.CreateOrderFlowResponse;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrderByIdResponse;
import com.freemud.sdk.api.assortment.order.response.order.QueryOrdersResponse;
//import com.freemud.sdk.api.assortment.order.response.payment.OrderPayResponse;
import com.freemud.sdk.api.assortment.payment.request.UnifiedOrderRequest;
import com.freemud.sdk.api.assortment.payment.response.UnifiedOrderResponse;
import com.google.common.collect.Lists;
......@@ -1031,6 +1035,8 @@ public class OrderAdapter {
queryOrdersDto.setSource(new String[]{"app"});
} else if (OrderChannelType.BEAUTIFUL.getCode().equals(channelType)) {
queryOrdersDto.setSource(new String[]{"beautiful"});
} else if (OrderChannelType.CASHIER.getCode().equals(channelType)) {
queryOrdersDto.setSource(new String[]{"cashier"});
} else {
queryOrdersDto.setSource(new String[]{"saas"});
}
......@@ -1181,7 +1187,7 @@ public class OrderAdapter {
if (null != orderBean) {
partnerId = orderBean.getCompanyId();
}
String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_COMPLAIN_KEY, partnerId, wxAppId), KgdRedisKeyConstant.ORDER_COMPLAIN_TYPE);
String configStr = redisCache.hashGet(MessageFormat.format(OrderRedisKeyConstant.ORDER_COMPLAIN_KEY, partnerId, wxAppId), OrderRedisKeyConstant.HashKeyForOrderComplainConfig.ORDER_COMPLAIN_TYPE);
Boolean buttonComplain = false;
if (CommonsConstant.ORDER_COMPLAIN_OPEN.equals(configStr)) {
buttonComplain = true;
......@@ -2156,82 +2162,72 @@ public class OrderAdapter {
}
boolean canRefund = false;
String hkey = OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType()) ? KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT : KgdRedisKeyConstant.REFUND_CFG_EAT_IN;
String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), hkey);
// 查询小程序配置的退款设置
String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId);
String hashKey;
if (OrderClientType.CASHIER.getIndex().toString().equals(orderBean.getOrderClient())) {
//收银单，使用收银单的退款配置
hashKey = OrderRedisKeyConstant.HashKeyForOrderRefundConfig.CASHIER;
} else {
hashKey = OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())
? OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT
: OrderRedisKeyConstant.HashKeyForOrderRefundConfig.EAT_IN;
}
String configStr = redisCache.hashGet(redisKey, hashKey);
if (StringUtils.isEmpty(configStr)) {
return true;
}
JSONObject config = JSON.parseObject(configStr);
String orderRefund;
//订单状态
switch (status) {
// 未接单
case TAKE_ORDER:
//区分外卖单和到店订单，判断是否可以退款
if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_TAKE_ORDER_REFUND.getKeyValue());
} else {
orderRefund = config.getString(OrderRefundEnum.TAKEORDER_REFUND.getKeyValue());
}
if (orderRefund == null || ALLOW_REFUND.equals(orderRefund)) {
canRefund = true;
}
break;
//已接单
case RECEIPT:
if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_RECEIPT_ORDER_REFUND.getKeyValue());
} else {
orderRefund = config.getString(OrderRefundEnum.RECEIPTORDER_REFUND.getKeyValue());
}
if (orderRefund == null || ALLOW_REFUND.equals(orderRefund)) {
canRefund = true;
}
break;
//制作完成
case COMPLETE_MAKE:
if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_COMPLETE_MAKE_ORDER_REFUND.getKeyValue());
} else {
orderRefund = config.getString(OrderRefundEnum.COMPLETEMAKEORDER_REFUND.getKeyValue());
}
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
canRefund = true;
}
break;
// 订单完成
case COMPLETE:
long currentTime = System.currentTimeMillis();
long gmtModified = orderBean.getGmtModified();
// 因允许退款日期在外卖类型的value中，如果订单类型为堂食，则会取不到这个值
if (!OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT);
if (StringUtils.isNotEmpty(configStr)) {
// 将允许退款日期的配置放到config中
config.put(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue(), JSON.parseObject(configStr).getString(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue()));
}
}
long value = 0L;
String refundDateConfig = config.getString(OrderRefundEnum.REFUND_DATA_RANGE.getKeyValue());
if (null != refundDateConfig) {
value = Long.parseLong(StringUtils.isEmpty(refundDateConfig) ? "0" : refundDateConfig);
}
long allowRefundTime = gmtModified + value * 24 * 60 * 60 * 1000;
if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_ORDER_REFUND.getKeyValue());
} else {
orderRefund = config.getString(OrderRefundEnum.ORDER_REFUND.getKeyValue());
}
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund) && (allowRefundTime - currentTime) >= 0) {
canRefund = true;
OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
String orderRefund = null;
if (OrderClientType.CASHIER.getIndex().toString().equals(orderBean.getOrderClient())) {
//收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
orderRefund = config.getCashierOrderRefund();
} else if (OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
//外卖单，使用外卖单的退款配置
switch (status) {
// 未接单
case TAKE_ORDER: orderRefund = config.getDeliveryTakeOrderRefund(); break;
//已接单
case RECEIPT: orderRefund = config.getDeliveryReceiptOrderRefund(); break;
//制作完成
case COMPLETE_MAKE: orderRefund = config.getDeliveryCompleteMakeOrderRefund(); break;
// 订单完成
case COMPLETE: orderRefund = config.getDeliveryOrderRefund(); break;
default: break;
}
} else {
//其他，使用堂食的退款配置（必须先判断收银单，因为收银单的类型也是堂食，只是orderClient不一样
switch (status) {
// 未接单
case TAKE_ORDER: orderRefund = config.getTakeOrderRefund(); break;
//已接单
case RECEIPT: orderRefund = config.getReceiptOrderRefund(); break;
//制作完成
case COMPLETE_MAKE: orderRefund = config.getCompleteMakeOrderRefund(); break;
// 订单完成
case COMPLETE: orderRefund = config.getOrderRefund(); break;
default: break;
}
}
canRefund = ALLOW_REFUND.equals(orderRefund);
// 如果是订单完成状态的 支持退款， 这里还需要校验一下是否在退款时间范围内
if (OrderStatus.COMPLETE.getCode().equals(status.getCode()) && canRefund) {
long currentTime = System.currentTimeMillis();
long gmtModified = orderBean.getGmtModified();
// 因允许退款日期在外卖类型的value中，如果订单类型为堂食，则会取不到这个值
if (!OrderType.TAKE_OUT.getCode().equals(orderBean.getOrderType())) {
configStr = redisCache.hashGet(redisKey, OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT);
if (StringUtils.isNotEmpty(configStr)) {
OrderRefundConfigEntity ce = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
config.setRefundDateRange(ce.getRefundDateRange());
}
break;
default:
break;
}
//退款日期允许范围
long value = 0L;
if (StringUtils.isNotEmpty(config.getRefundDateRange())) {
value = Long.parseLong(config.getRefundDateRange());
}
canRefund = ((gmtModified + value * 24 * 60 * 60 * 1000) - currentTime) >= 0;
}
return canRefund;
}
......@@ -2675,6 +2671,7 @@ public class OrderAdapter {
productBean1.setProductOtherInfo(extraName);
productBean1.setParentType(productBean.getProductType());
productBean1.setSonProducts(new ArrayList<>());
productBean1.setUnit(productBean.getUnit());
return productBean1;
}
......@@ -4277,6 +4274,8 @@ public class OrderAdapter {
//queryOrdersDto.setSource(new String[]{"app"});
} else if (OrderChannelType.BEAUTIFUL.getCode().equals(channelType)) {// 美业新加
orderClients.add(OrderClientType.BEAUTIFUL.getIndex());
} else if (OrderChannelType.CASHIER.getCode().equals(channelType)) {
orderClients.add(OrderClientType.CASHIER.getIndex());
} else {
orderClients.add(OrderClientType.SAAS.getIndex());
//queryOrdersDto.setSource(new String[]{"saas"});
......
order-application-service/src/main/java/cn/freemud/config/ApolloVariableConfig.java 0 → 100644
package cn.freemud.config;
import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* @author Clover.z
* @Date 2021/10/19
* @Desc 阿波罗配置的一些变量
*/
@Data
@Component
public class ApolloVariableConfig {
/**
* 创单锁定的key的有效期 默认5秒
*/
@Value("${create.order.key.expire:5}")
private Long createOrderKeyExpire;
}
order-application-service/src/main/java/cn/freemud/constant/RedisKeyConstant.java
......@@ -100,6 +100,10 @@ public class RedisKeyConstant {
public final static String USER_BUY_PRODUCT_ONCE = "user_buy_product_once:";
/**
* 取消支付冲正mq在redis的key前缀
*/
public final static String KGD_PAYMENT_CANCEL_OID = "kgd:cancel_payment_oid:";
/**
* cocoNotMadeGoods:商户号:门店号:yyyy-MM-dd
......
order-application-service/src/main/java/cn/freemud/constant/RedisLockKey.java 0 → 100644
package cn.freemud.constant;
/**
* @author Clover.z
* @Date 2021/10/19
* @Desc redis锁的 key 统计
*/
public class RedisLockKey {
/**
* 下单时防止重复点击的并发锁key
* {0}: 会员id
*/
public static final String CREATE_ORDER = "create_order_key:{0}";
}
order-application-service/src/main/java/cn/freemud/controller/OrderController.java
......@@ -14,10 +14,12 @@ package cn.freemud.controller;
import cn.freemud.annotations.IsConvertEN;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.entities.dto.order.CreateCashierOrderDto;
import cn.freemud.entities.dto.order.InvoiceCreateResponseVo;
import cn.freemud.entities.vo.*;
import cn.freemud.entities.vo.encircle.CreateReserveOrderVo;
import cn.freemud.entities.vo.encircle.EncircleReserveBaseVo;
import cn.freemud.entities.vo.order.CreateCashierOrderVo;
import cn.freemud.entities.vo.order.CreateOrderInvoiceRequest;
import cn.freemud.entities.vo.order.OrderAppealVo;
import cn.freemud.handler.OrderReportJobHandler;
......@@ -31,6 +33,7 @@ import cn.freemud.xxljob.OrderCountJobHandler;
import com.freemud.application.sdk.api.log.ApiAnnotation;
import com.freemud.application.sdk.api.log.LogParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.BindingResult;
import org.springframework.validation.annotation.Validated;
......@@ -53,8 +56,6 @@ public class OrderController {
@Autowired
private MallOrderServiceImpl mallOrderService;
@Autowired
private MCCafeOrderService mcCafeOrderService;
@Autowired
private OrderReportJobHandler orderReportJobHandler;
@Autowired
private OrderCountJobHandler orderCountJobHandler;
......@@ -88,6 +89,18 @@ public class OrderController {
}
/**
* 创建收银订单（无商品单）
*/
@IsConvertEN
@ApiAnnotation(logMessage = "createCashierOrder")
@PostMapping("/createCashierOrder")
public BaseResponse<CreateOrderResponseVo> createCashierOrder(@Validated @LogParams @RequestBody CreateCashierOrderVo request) {
CreateCashierOrderDto dto = new CreateCashierOrderDto();
BeanUtils.copyProperties(request, dto);
return ResponseUtil.success(orderAdapterService.createCashierOrder(dto));
}
/**
* 通用创建订单
*/
@ApiAnnotation(logMessage = "createOrderUniversal")
......@@ -226,16 +239,6 @@ public class OrderController {
}
/**
* 取消支付删除订单
*/
// @ApiAnnotation(logMessage = "deleteOrderById")
// @PostMapping("/deleteOrderById")
// public BaseResponse deleteOrderById(@Validated @LogParams @RequestBody DeleteOrderVo deleteOrderVo) {
// //return orderservice.deleteOrderById(deleteOrderVo);
// return orderservice.cancelPayOrder(deleteOrderVo);
// }
/**
* 用户申请退款
*/
@ApiAnnotation(logMessage = "refund")
......
order-application-service/src/main/java/cn/freemud/entities/dto/CouponCodeVerificationDto.java
......@@ -35,6 +35,14 @@ public class CouponCodeVerificationDto extends CouponCodeBaseDto {
private String channel;
/**
*
*/
private String tradeChannel;
private String tradeNo;
/**
* 会员编号
*/
private String memberId;
......
order-application-service/src/main/java/cn/freemud/entities/dto/OrderPrintDto.java
......@@ -130,6 +130,8 @@ public class OrderPrintDto {
private List<ProductsBean> sonProducts;
//加料商品的加料
private List<ProductsBean> materialProducts;
// 商品单位
private String unit;
}
}
order-application-service/src/main/java/cn/freemud/entities/dto/order/CreateCashierOrderDto.java 0 → 100644
package cn.freemud.entities.dto.order;
import lombok.Data;
/**
* @author Clover.z
* @Date 2021/10/21
* @Desc
*/
@Data
public class CreateCashierOrderDto {
/**
* 用户登陆的session
*/
private String sessionId;
/**
* 商户号
*/
private String partnerId;
/**
* 门店号
*/
private String storeCode;
/**
* 订单金额（单位：分）
*/
private Long orderAmount;
/**
* 小程序版本号
*/
private String version;
}
order-application-service/src/main/java/cn/freemud/entities/dto/store/BusinessInfoDto.java
......@@ -2,43 +2,301 @@ package cn.freemud.entities.dto.store;
import lombok.Data;
import java.util.List;
@Data
public class BusinessInfoDto {
private String autoSelfmentionTakeOrderWorkflowFinishTime;
private String autoSelfmentionMakerWorkflowFinishTime;
private String autoTakeOutTakeOrderWorkflowFinishTime;
private String autoDeliveryTakeOrderWorkflowFinishTime;
private String appointAutoSelfmentionTakeOrderWorkflowFinishTime;
private String appointAutoSelfmentionMakerWorkflowFinishTime;
private String appointAutoTakeOutTakeOrderWorkflowFinishTime;
private String appointAutoDeliveryTakeOrderWorkflowFinishTime;
private Long id;
/**
* 模板名称
*/
private String templateName;
/**
* 模板类型0:通用 1:个性化
*/
private Integer templateType;
/**
* 所属商户
*/
private String partnerId;
/**
* 预订单提醒时间{1:15分钟;2:30分钟;3:45分钟;4:60分钟;5:5分钟;6:10分钟}
*/
private String orderWarnTime;
/**
* 外卖预订单提醒时间{1:15分钟;2:30分钟;3:45分钟;4:60分钟;5:5分钟;6:10分钟}
*/
private String deliveryOrderWarnTime;
/**
* 预订单打印时间{1：提醒时打印；2：接单时打印}
*/
private String orderPrintConfig;
/**
* 最大接单量,单位笔
*/
private Integer maxOrderQuantity;
/**
* 是否支持自动接单(1是2否)
*/
private Integer isAutoTakeOrder;
/**
* 自提-服务端自动接单时间 1:立即;2:1分钟;3:5分钟（顾客下单XX后，订单状态自动更改为已接单）
*/
private Integer pickupAutomaticOrderTime;
/**
* 外卖-服务端自动接单时间 1:立即;2:1分钟;3:5分钟（顾客下单XX后，订单状态自动更改为已接单）
*/
private Integer takeoutAutomaticOrderTime;
/**
* 退单模式 1手动退单 2自动退单
*/
private Integer autoChargebackOrderType;
/**
* 自动退单时间
*/
private Integer autoChargebackOrderTime;
/**
* 超时关单 1开启 2关闭
*/
private Integer overTimeCloseOrder;
/**
* 接单超时关单时间，默认30分钟
*/
private Integer overTimeCloseOrderTime;
/**
* 自提单接单后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer autoSelfmentionTakeOrderWorkflowFinishTime;
/**
* 自提单制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer autoSelfmentionMakerWorkflowFinishTime;
/**
* 自建外卖接单后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer autoTakeOutTakeOrderWorkflowFinishTime;
/**
* 自建外卖制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer autoDeliveryTakeOrderWorkflowFinishTime;
/**
* 预约自提单接单后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer appointAutoSelfmentionTakeOrderWorkflowFinishTime;
/**
* 预约自提单制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer appointAutoSelfmentionMakerWorkflowFinishTime;
/**
* 预约自建外卖接单后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer appointAutoTakeOutTakeOrderWorkflowFinishTime;
/**
* 预约自建外卖制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;
*/
private Integer appointAutoDeliveryTakeOrderWorkflowFinishTime;
/**
* 实时三方外卖制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;7:3分钟;8:2分钟
*/
private Integer autoThirdDeliveryTakeOrderWorkflowFinishTime;
/**
* 预约三方外卖制作完成后自动流程时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;7:3分钟;8:2分钟
*/
private Integer appointThirdDeliveryTakeOrderWorkflowFinishTime;
private String autoChargebackOrderTime;
private String autoChargebackOrderType;
private String autoOrderPrintConfig;
private String overTimeCloseOrder;
private String overTimeCloseOrderTime;
private String pickUpAutomaticOrderTime;
private String takeOutAutomaticOrderTime;
/**
* 点餐方式(,隔开)：pickup,delivery
*/
private String orderType;
/**
* 是否支持发票 1是 0否
*/
private Integer invoice;
/**
* 外卖时间：00:00-23:59
*/
private String deliveryHours;
/**
* 预计送达时间（分钟）
*/
private Integer expectedTime;
/**
* 参与结算（1：是、2：否）
*/
private Integer takePartInSettleAccounts;
/**
* 是否自动同意退款（同意:1,不同意:0）
*/
private Integer automaticRefund;
/**
* 可开票的最小价格
*/
private Integer minPriceForInvoice;
/**
* 发票特殊说明
*/
private String invoiceExplain;
/**
* 外卖预约单开关（0:关闭，1:开启）
*/
private Integer deliveryAppoint;
private Integer selfMentionSwitch;
/**
* "外卖预约单时间（分钟） 65分钟、90分钟、120分钟"
*/
private Integer deliveryAppointTime;
private String deliveryOrderWarnTime;
/**
* 是否需要餐具 1 需要 0 不需要
*/
private Integer tableware;
/**
* 自提预约单开关（0:关闭，1:开启）
*/
private Integer selfMentionSwitch;
/**
* 三方外卖订单自动拣货完成时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;7:3分钟;8:2分钟
*/
private Integer autoThirdDeliveryPickCompleteWorkflowFinishTime;
/**
* 三方外卖预订单自动拣货完成时间 1:2小时;2:1小时;3:30分钟;4:15分钟;5:10分钟;6:5分钟;7:3分钟;8:2分钟;
*/
private Integer appointThirdDeliveryPickCompleteWorkflowFinishTime;
private String timeOfRefund;
private Integer timeTypeOfRefund;
/**
* 开启制作时间 1 ：是 ， 2 ：否
*/
private Integer turnOnTimeOfMaking;
/**
* 商品平均制作时常 分钟
*/
private Integer goodsAvgTimeOfMaking;
/**
* 自建外卖订单，商家自配送xx分钟后，订单状态更改为【已完成】
*/
private Integer deliveryFinishedAfterMinute;
/**
* 自建外卖订单-实时单，商家自配送，门店接单xx分钟后，订单状态变更为配送中
*/
private Integer deliveryProcessingAfterMinute;
/**
* 自建外卖订单-预约单，商家自配送，预约商家前xx分钟，订单更改为配送中
*/
private Integer deliveryProcessingBeforeMinute;
/**
* 点餐进度条 1 开启，2 关闭
*/
private Integer orderProgressBarStatus;
private ExpandFields expandFields;
/**
* 收银买单开关 1 开启 2 关闭
*/
private Integer supportCashierPay;
/**
* 拓展字段定义
*/
private ExpandInfo expandFields;
@Data
public static class ExpandInfo {
/**
* 月销量是否展示（1-是；0-否）
*/
private Integer monthlySalesShow;
/**
* 月销量配置值
*/
private Integer monthlySalesConfigValue;
/**
* 点赞数是否展示（1-是；0-否）
*/
private Integer likesShow;
/**
* 点赞数配置值
*/
private Integer likesConfigValue;
/**
* 高峰时间配送时间
*/
private List<PeakTimeDelivery> peakTimeDelivery;
/**
* 每增加一公里增加的时长（分钟）
*/
private Integer appendMinutePerKilometer;
@Data
public static class PeakTimeDelivery {
/**
* 高峰期开始时间
*/
private String startTime;
/**
* 高峰期结束时间
*/
private String endTime;
/**
* 耗费时间
*/
private Integer costMinute;
}
/**
* 扫桌码下单(1-开启;0-关闭)
*/
private Integer scanOrderSwitch;
/**
* 爱马哥蛋糕预定单开关(1-开启;0-关闭)
*/
private Integer preOrderSwitch;
}
}
order-application-service/src/main/java/cn/freemud/entities/dto/store/OrgListTreeResponse.java 0 → 100644
package cn.freemud.entities.dto.store;
import io.swagger.annotations.ApiModelProperty;
import lombok.Builder;
import lombok.Data;
import java.util.List;
/**
* Created with IntelliJ IDEA 2017.1 <br>
* User: dll [loverochy8@gmail.com] <br>
* Date: 2019/1/15 16:02 <br>
* To change this template use File | Settings | File Templates. <br>
* Description:
*/
@Data
public class OrgListTreeResponse {
private List<OrganizationVo> orgList;
@Data
@Builder
public static class OrganizationVo {
@ApiModelProperty("排序")
private Integer sort;
@ApiModelProperty("商户ID")
private String partnerId;
@ApiModelProperty("组织code")
private String organizationCode;
@ApiModelProperty("组织ID")
private String organizationId;
@ApiModelProperty("组织名称")
private String organizationName;
@ApiModelProperty("组织类型")
private Integer typeFlag;
}
}
order-application-service/src/main/java/cn/freemud/entities/dto/store/SoreMixResponseDto.java deleted 100644 → 0
package cn.freemud.entities.dto.store;
import cn.freemud.entities.dto.StoreResponseDto;
import lombok.Data;
@Data
public class SoreMixResponseDto {
private StoreResponseDto storeInfo;
private BusinessInfoDto businessInfo;
private DeliveryInfoDTO deliveryInfo;
private Object parentUntilTop;
private Object storeBusyTimeInfoList;
private Object storeImageList;
}
order-application-service/src/main/java/cn/freemud/entities/dto/store/StoreBusyTimeInfo.java 0 → 100644
package cn.freemud.entities.dto.store;
import lombok.Data;
import java.util.List;
@Data
public class StoreBusyTimeInfo {
/**
* 渠道
*/
private String channel;
/**
* 周期类型（0每日，1工作日，2双休日，默认每日）
*/
private Integer periodType;
/**
* 时间段
*/
private List<TimeInfo> timeInfoList;
/**
* 文案
*/
private String detail;
@Data
public static class TimeInfo {
/**
* 开始时间,格式HH:mm:ss,00:00:00-23:59:59
*/
private String startTime;
/**
* 结束时间,格式HH:mm:ss,00:00:00-23:59:59
*/
private String endTime;
}
}
order-application-service/src/main/java/cn/freemud/entities/dto/store/StoreInfoRequestDto.java
......@@ -32,17 +32,29 @@ public class StoreInfoRequestDto {
@Data
public static class QueryInfo{
//查询门店基本信息
/**
* 查询门店基本信息
*/
private Boolean queryStoreInfo;
// 查询门店的渠道上级列表
/**
* 查询门店的渠道上级列表
*/
private Boolean queryParentUntilTop;
//查询配送设置信息
/**
* 查询配送设置信息
*/
private Boolean queryDeliveryInfo;
//查询业务设置信息
/**
* 查询业务设置信息
*/
private Boolean queryBusinessInfo;
//查询门店图片
/**
* 查询门店图片
*/
private Boolean queryStoreImage;
//查询门店繁忙时间
/**
* 查询门店繁忙时间
*/
private Boolean queryStoreBusyTime;
}
......
order-application-service/src/main/java/cn/freemud/entities/dto/store/StoreMixResponseDto.java 0 → 100644
package cn.freemud.entities.dto.store;
import cn.freemud.entities.dto.StoreResponseDto;
import lombok.Data;
import java.util.List;
@Data
public class StoreMixResponseDto {
/**
* 门店基础信息
*/
private StoreResponseDto storeInfo;
/**
* 门店业务配置信息
*/
private BusinessInfoDto businessInfo;
/**
* 门店配送配置信息
*/
private DeliveryInfoDTO deliveryInfo;
/**
* 门店的渠道+渠道的父渠道+父渠道的父渠道…… 直到总公司，计入一个list中
*/
private OrgListTreeResponse parentUntilTop;
/**
* 门店繁忙时间列表
*/
private List<StoreBusyTimeInfo> storeBusyTimeInfoList;
/**
* 门店图片列表
*/
private List<String> storeImageList;
}
order-application-service/src/main/java/cn/freemud/entities/vo/PayGiftCouponVo.java
......@@ -57,4 +57,9 @@ public class PayGiftCouponVo {
* 起用金额
*/
private String minAmount;
/**
* 活动描述
*/
private String activityDesc;
}
order-application-service/src/main/java/cn/freemud/entities/vo/PaysuccessNoticeMessage.java
......@@ -35,6 +35,11 @@ public class PaysuccessNoticeMessage {
* 订单金额
*/
private Integer total_fee;
/**
* 第三方交易流水 （支付宝、微信）
*/
private String thirdPartTradeNo;
/**
* 营业员编号
*/
......
order-application-service/src/main/java/cn/freemud/entities/vo/QueryOrderVo.java
......@@ -60,6 +60,7 @@ public class QueryOrderVo {
/**
* 渠道信息 saas; img; iwc; saasmall
* 查询收银订单列表传 cashier
*/
private String channelType;
......
order-application-service/src/main/java/cn/freemud/entities/vo/SellCouponCreateOrderVo.java
......@@ -65,4 +65,11 @@ public class SellCouponCreateOrderVo {
*/
private String channel;
/**
* 【华莱士】【订单C端记录不分账的卡面编号】不让走分账，卡面编号--11840，11845，11846，11853，11854，11855，11857，11858，11859，11860，11861，11862，11863，11864，11865，11866，11906
*
* 1 表示不分账 ,其他情况 不传值 给基础服务
*/
private Integer unDistribution;
}
order-application-service/src/main/java/cn/freemud/entities/vo/order/CreateCashierOrderVo.java 0 → 100644
package cn.freemud.entities.vo.order;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
/**
* @author Clover.z
* @Date 2021/10/19
* @Desc 创建无单订单请求报文实体
*/
@Data
public class CreateCashierOrderVo {
/**
* 用户登陆的session
*/
@ApiModelProperty("用户登陆的session")
@NotEmpty(message = "请先授权登陆")
private String sessionId;
/**
* 商户号
*/
@ApiModelProperty("商户号")
@NotEmpty(message = "商户号必填")
private String partnerId;
/**
* 门店号
*/
@ApiModelProperty("门店号")
@NotEmpty(message = "门店号必填")
private String storeCode;
/**
* 订单金额（单位：分）
*/
@ApiModelProperty("订单金额（单位：分）")
@NotNull(message = "请输入订单金额")
@Min(value = 1, message = "请输入有效的订单金额哟")
private Long orderAmount;
/**
* 小程序版本号
*/
@ApiModelProperty("小程序版本号")
private String version;
}
order-application-service/src/main/java/cn/freemud/enums/CouponTradeChannelEnum.java 0 → 100644
package cn.freemud.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: CouponTradeChannelEnum
* @Package cn.freemud.enums
* @Description:
* @author: bowen.hu
* @date: 2021-10-20 15:36
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
*/
public enum CouponTradeChannelEnum {
WX_TRADE_CHANNEL("WX_TRADE_CHANNEL", "1", "微信交易渠道"),
OTHER_TRADE_CHANNEL("WX_TRADE_CHANNEL", "", "其他交易渠道"),
ALIPAY_TRADE_CHANNEL("ZHIFUBAO_TRADE_CHANNEL", "2", "支付宝渠道");
private String tradeChannel;
private String orderClient;
private String desc;
CouponTradeChannelEnum(String tradeChannel, String orderClient, String desc) {
this.tradeChannel = tradeChannel;
this.orderClient = orderClient;
this.desc = desc;
}
public String getTradeChannel() {
return tradeChannel;
}
public String getOrderClient() {
return orderClient;
}
public String getDesc() {
return desc;
}
public static String getCouponChannel(String orderClient) {
CouponTradeChannelEnum[] values = CouponTradeChannelEnum.values();
for (CouponTradeChannelEnum tradeChannelEnum : values) {
if (tradeChannelEnum.getOrderClient().equals(orderClient)) {
return tradeChannelEnum.getTradeChannel();
}
}
return CouponTradeChannelEnum.OTHER_TRADE_CHANNEL.getTradeChannel();
}
}
order-application-service/src/main/java/cn/freemud/enums/OrderChannelType.java
......@@ -31,6 +31,11 @@ public enum OrderChannelType {
*/
TIKTOK("dy", "抖音小程序"),
/**
* 收银单
*/
CASHIER("cashier", "收银单"),
POINTSMALL("pointsmall", "积分商城");
private String code;
......
order-application-service/src/main/java/cn/freemud/enums/OrderRefundEnum.java deleted 100644 → 0
package cn.freemud.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderRefundEnum
* @Package cn.freemud.constant
* @Description:
* @author: bowen.hu
* @date: 2019-09-17 10:46
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
*/
public enum OrderRefundEnum {
ORDER_REFUND("orderRefund", "已完成订单是否允许退款"),
TAKEORDER_REFUND("takeOrderRefund", "未接单是否支持退款"),
RECEIPTORDER_REFUND("receiptOrderRefund", "已接单是否支持退款"),
COMPLETEMAKEORDER_REFUND("completeMakeOrderRefund", "制作完成是否支持退款"),
DELIVERY_TAKE_ORDER_REFUND("deliveryTakeOrderRefund","外卖单未接单是否支持退款"),
DELIVERY_RECEIPT_ORDER_REFUND("deliveryReceiptOrderRefund","外卖单已接单是否支持退款"),
DELIVERY_COMPLETE_MAKE_ORDER_REFUND("deliveryCompleteMakeOrderRefund","外卖单制作完成是否支持退款"),
DELIVERY_ORDER_REFUND("deliveryOrderRefund","外卖单订单完成是否支持退款"),
REFUND_DATA_RANGE("refundDateRange", "退款允许日期"),
REFUND_DELIVERY_FEE_ENABLE("refundShippingFee","商家同意退款时是否退配送费"),
REFUND_REVERSE_COUPON("refundReverseCoupon", "退款退优惠券");
;
private String keyValue;
private String message;
OrderRefundEnum(String keyValue, String message) {
this.keyValue = keyValue;
this.message = message;
}
public String getKeyValue() {
return keyValue;
}
public String getMessage() {
return message;
}
}
order-application-service/src/main/java/cn/freemud/enums/ResponseResult.java
......@@ -17,6 +17,7 @@ public enum ResponseResult {
PARAMETER_MISSING("40002", "缺少必要参数","Missing required parameter"),
OPERATE_TOO_OFTEN("40003", "忙不过来了，请稍后再试","The system is busy, please try again later"),
LOGIN_STORE_ERROR("40004", "登录门店异常","Login store exception"),
OPERATE_NOT_SUPPORT("40005", "该操作暂不支持","This operation is not support"),
/**
* 用户信息状态码
......@@ -72,6 +73,7 @@ public enum ResponseResult {
STORE_QUERYEXPECTARRIVETIME("43022", "获取门店计算预计送达时间失败",""),
STORE_DATE_ERROR("43023", "门店数据错误",""),
STORE_ITEM_NOT_ADVANCE("43024", "门店未开启预约单配置",""),
STORE_CASHIER_CONFIG_ERROR("43025", "请联系门店开启收银功能哦", "Please contact the store to open the cashier function"),
/**
* 购物车状态码
......
order-application-service/src/main/java/cn/freemud/enums/UserLoginChannelEnum.java
......@@ -4,6 +4,7 @@ import lombok.Getter;
@Getter
public enum UserLoginChannelEnum {
OTHER("0", "其他"),
WEIXIN("1", "微信"),
ALIPAY("2", "支付宝"),
APP("3", "APP"),
......@@ -14,11 +15,19 @@ public enum UserLoginChannelEnum {
*/
TIKTOKPAY("5", "抖音小程序");
private String code;
private String desc;
private final String code;
private final String desc;
UserLoginChannelEnum(String code, String desc) {
this.code = code;
this.desc = desc;
}
public static UserLoginChannelEnum get(String code) {
for (UserLoginChannelEnum e : values()) {
if (e.getCode().equals(code)) return e;
}
return UserLoginChannelEnum.OTHER;
}
}
order-application-service/src/main/java/cn/freemud/interceptor/BizExceptionHandler.java
......@@ -42,7 +42,9 @@ public class BizExceptionHandler {
@ExceptionHandler(ServiceException.class)
@ResponseStatus(HttpStatus.OK)
public BaseResponse bindException(ServiceException e) {
return ResponseUtil.error(e.getResult());
return null != e.getResult()
? ResponseUtil.error(e.getResult())
: ResponseUtil.error(e.getCode(), e.getMessage());
}
@ExceptionHandler(ParameterException.class)
......
order-application-service/src/main/java/cn/freemud/interceptor/ServiceException.java
......@@ -13,6 +13,7 @@ public class ServiceException extends RuntimeException {
private ResponseResult result;
private String code;
private String message;
private String enMessage;
......@@ -23,6 +24,16 @@ public class ServiceException extends RuntimeException {
this.enMessage = result.getEnMessage();
}
public ServiceException(String message) {
this.code = ResponseResult.SYSTEM_BUSINESS_ERROR.getCode();
this.message = message;
}
public ServiceException(String code, String message) {
this.code = code;
this.message = message;
}
public ServiceException(ResponseResult result, String message) {
this.result = result;
this.message = message;
......@@ -53,4 +64,12 @@ public class ServiceException extends RuntimeException {
public void setEnMessage(String enMessage) {
this.enMessage = enMessage;
}
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
}
order-application-service/src/main/java/cn/freemud/service/CashierOrderService.java 0 → 100644
package cn.freemud.service;
import cn.freemud.entities.dto.ConfirmOrderDto;
import cn.freemud.entities.dto.order.CreateCashierOrderDto;
import cn.freemud.entities.vo.CreateOrderResponseVo;
import cn.freemud.entities.vo.PaysuccessNoticeMessage;
import com.freemud.api.assortment.datamanager.entity.vo.AssortmentCustomerInfoVo;
import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
import java.util.Map;
/**
* @author Clover.z
* @Date 2021/10/20
* @Desc 收银订单 service
*/
public interface CashierOrderService {
/**
* 创建无单收银订单
* 不需要查询购物车，没有商品，流程上 只需要创建一个订单然后唤起预支付就行了
* @param createOrderDto 请求数据
* @param member 会员信息
* @return 预支付信息
*/
CreateOrderResponseVo createOrder(CreateCashierOrderDto createOrderDto, AssortmentCustomerInfoVo member);
/**
* 支付成功回调处理
* @param message 支付消息
* @param confirmOrderDto 支付成功消息dto
* @param orderBeans 订单信息
* @return 处理结果json字符串
*/
String paySuccessCallback(PaysuccessNoticeMessage message, ConfirmOrderDto confirmOrderDto, Map<String, OrderBeanV1> orderBeans);
}
order-application-service/src/main/java/cn/freemud/service/business/OrderBusinessService.java
package cn.freemud.service.business;
import com.freemud.application.sdk.api.ordercenter.request.PaySuccessReq;
import com.freemud.sdk.api.assortment.order.request.order.CancelOrderRequest;
import com.freemud.sdk.api.assortment.order.request.order.ConfirmOrderRequest;
import com.freemud.sdk.api.assortment.order.request.order.CreateOrderRequest;
import com.freemud.sdk.api.assortment.order.response.order.BaseOrderResponse;
import com.freemud.sdk.api.assortment.order.response.order.CreateOrderResponse;
import com.freemud.sdk.api.assortment.order.response.order.PayAccessResponse;
......@@ -20,4 +22,6 @@ public interface OrderBusinessService {
CreateOrderResponse createOrderFlow(CreateOrderRequest createOrderRequest);
BaseOrderResponse orderCancel(CancelOrderRequest cancelOrderRequest);
}
order-application-service/src/main/java/cn/freemud/service/business/impl/OrderBusinessServiceImpl.java
......@@ -328,7 +328,7 @@ public class OrderBusinessServiceImpl implements OrderBusinessService {
// @Override
@Override
public BaseOrderResponse orderCancel(CancelOrderRequest cancelOrderRequest) {
OrderCancelReq request = new OrderCancelReq();
//商户号必传
......
order-application-service/src/main/java/cn/freemud/service/coupon/impl/PlatformCouponRelationServiceImpl.java
......@@ -135,6 +135,9 @@ public class PlatformCouponRelationServiceImpl implements CouponRelationService
* @param couponReqType
*/
private BaseResponse commonMethodVerification(CouponCodeVerificationTransDto couponCodeVerificationTransDto, List<AccountBeanV1> accountList, OrderBeanV1 orderBean, CouponReqType couponReqType) {
//orderBean.getOrderClient();
String couponChannel = CouponTradeChannelEnum.getCouponChannel(orderBean.getOrderClient());
for (AccountBeanV1 accountBean : accountList) {
List<CouponCodeVerificationProductDto> products = new ArrayList<>();
//商品券核销核销参数
......@@ -177,7 +180,7 @@ public class PlatformCouponRelationServiceImpl implements CouponRelationService
|| OrderAccountType.FREIGHT_COUPON.getCode().equals(accountBean.getType())
|| OrderAccountType.DISCOUNT_COUPON.getCode().equals(accountBean.getType())) {
CouponCodeVerificationDto couponCodeVerificationDto = couponAdapter.convert2CouponCodeVerificationDto(activityChannelEnum,
CouponCodeVerificationDto couponCodeVerificationDto = couponAdapter.convert2CouponCodeVerificationDto (activityChannelEnum,
// 这里是活动code
accountBean.getAccountId(), orderBean.getOid(), orderBean.getCompanyId(),
orderBean.getShopId(), orderBean.getUserId(), products, accountBean.getPrice().intValue(), couponReqType);
......@@ -188,6 +191,9 @@ public class PlatformCouponRelationServiceImpl implements CouponRelationService
couponCodeVerificationDto.setOrderDiscountAmount(Math.abs(accountBean.getPrice()));
// 核销券新增参数：组织机构ID
couponCodeVerificationDto.setChannel_ids(storeService.getOrgIdsArr(orderBean.getCompanyId(), orderBean.getShopId()));
couponCodeVerificationDto.setTradeNo(orderBean.getThirdPartTradeNo());
couponCodeVerificationDto.setTradeChannel(couponChannel);
boolean ok = false;
Exception lastException = null;
CouponCodeResponseDto couponCodeResponseDto = null;
......
order-application-service/src/main/java/cn/freemud/service/impl/AppOrderServiceImpl.java
......@@ -171,7 +171,7 @@ public class AppOrderServiceImpl implements AppOrderService {
cardCode, createPrepayVo.getPayCode(), createOrderOperateDto.getFatherOrderBean(), createOrderOperateDto.getProductOrderBean(), createOrderOperateDto.getTotalAmount(),
createOrderOperateDto.getCardAmount(), extInfo, transId, OrderClientType.APP);
redisService.savePaymentTransIdOrder(RedisUtil.getPaymentTransIdOrderKey(transId), productOrderBean.getOid(), 60L, TimeUnit.MINUTES);
return payServiceimpl.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payServiceimpl.createPrepayOrder(createPrepayRequestDto));
}
......
order-application-service/src/main/java/cn/freemud/service/impl/CashierOrderServiceImpl.java 0 → 100644
package cn.freemud.service.impl;
import cn.freemud.adapter.LightApplicationConvertToAssortmentSdkAdapter;
import cn.freemud.base.util.DateUtil;
import cn.freemud.constant.ResponseCodeConstant;
import cn.freemud.entities.dto.ConfirmOrderDto;
import cn.freemud.entities.dto.StoreResponseDto;
import cn.freemud.entities.dto.order.CreateCashierOrderDto;
import cn.freemud.entities.dto.order.CreatePrepayRequestDto;
import cn.freemud.entities.dto.store.StoreMixResponseDto;
import cn.freemud.entities.vo.CreateOrderResponseVo;
import cn.freemud.entities.vo.PaysuccessNoticeMessage;
import cn.freemud.enums.OrderBeanType;
import cn.freemud.enums.ResponseResult;
import cn.freemud.enums.UserLoginChannelEnum;
import cn.freemud.interceptor.ServiceException;
import cn.freemud.service.CashierOrderService;
import cn.freemud.service.business.OrderBusinessService;
import cn.freemud.service.store.StoreManager;
import cn.freemud.utils.AppLogUtil;
import com.alibaba.fastjson.JSONObject;
import com.freemud.api.assortment.datamanager.entity.vo.AssortmentCustomerInfoVo;
import com.freemud.application.sdk.api.log.LogThreadLocal;
import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
import com.freemud.application.sdk.api.ordercenter.enums.NewOrderStatus;
import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
import com.freemud.application.sdk.api.ordercenter.enums.OrderType;
import com.freemud.application.sdk.api.ordercenter.enums.PayChannelType;
import com.freemud.application.sdk.api.ordercenter.request.OrderChangeStateReq;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtendedReq;
import com.freemud.application.sdk.api.ordercenter.request.create.CreateOrderRequest;
import com.freemud.application.sdk.api.ordercenter.response.OrderBaseResp;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderInfoReqs;
import com.freemud.application.sdk.api.ordercenter.service.OrderSdkService;
import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
import com.freemud.sdk.api.assortment.order.request.order.ConfirmOrderRequest;
import com.google.common.collect.Maps;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Date;
import java.util.Map;
import java.util.Objects;
/**
* @author Clover.z
* @Date 2021/10/20
* @Desc
*/
@Service
@RequiredArgsConstructor
public class CashierOrderServiceImpl implements CashierOrderService {
private final StoreManager storeManager;
private final OrderSdkService orderSdkService;
private final PayServiceImpl payService;
private final OrderSdkAdapter orderSdkAdapter;
private final OrderBusinessService orderBusinessService;
/**
* 创建无单收银订单
* 不需要查询购物车，没有商品，流程上 只需要创建一个订单然后唤起预支付就行了
*
* @param createOrderDto 请求数据
* @param member 会员信息
* @return 预支付信息
*/
@Override
public CreateOrderResponseVo createOrder(CreateCashierOrderDto createOrderDto, AssortmentCustomerInfoVo member) {
// 查询门店和配置信息
StoreMixResponseDto storeMix = storeManager.queryStoreMixInfo(createOrderDto.getPartnerId(), createOrderDto.getStoreCode(), query -> {
query.setQueryBusinessInfo(true); query.setQueryStoreInfo(true);
});
if (null == storeMix.getStoreInfo() || null == storeMix.getBusinessInfo()) throw new ServiceException(ResponseResult.STORE_DATE_ERROR);
// 门店未配置收银买单开关或者未配置为 1-开启， 则不允许下单
if (! Objects.equals(storeMix.getBusinessInfo().getSupportCashierPay(), 1)) throw new ServiceException(ResponseResult.STORE_CASHIER_CONFIG_ERROR);
//创建订单
CreateOrderRequest request = this.generateCreateOrderRequest(storeMix.getStoreInfo(), createOrderDto.getOrderAmount(), member);
OrderBaseResp<OrderInfoReqs> response = orderSdkService.createOrder(request, LogThreadLocal.getTrackingNo());
if (null == response || !ResponseCodeConstant.RESPONSE_SUCCESS_STR.equals(response.getCode())) {
throw new ServiceException(ResponseResult.ORDER_CREATE_ERROR);
}
//创建预支付
CreatePrepayRequestDto createPrepayRequestDto = new CreatePrepayRequestDto();
createPrepayRequestDto.setPartnerId(createOrderDto.getPartnerId());
createPrepayRequestDto.setTransId(response.getResult().getOrderCode());
createPrepayRequestDto.setWxAppId(member.getWxAppId());
createPrepayRequestDto.setOpenId(member.getOpenId());
createPrepayRequestDto.setTotalAmount(createOrderDto.getOrderAmount());
createPrepayRequestDto.setChannel(Objects.requireNonNull(PayChannelType.getByIndex(request.getPayChannelType())).getEbcode());
OrderBeanV1 orderBeanV1 = orderSdkAdapter.convent2NEWOrderInfo(response.getResult());
createPrepayRequestDto.setProductOrderBean(orderBeanV1);
createPrepayRequestDto.setFatherOrderBean(orderBeanV1);
OrderExtInfoDto orderExtInfoDto = new OrderExtInfoDto();
orderExtInfoDto.setOpenid(member.getOpenId());
orderExtInfoDto.setAppid(member.getWxAppId());
orderExtInfoDto.setSessionId(member.getSessionId());
orderExtInfoDto.setVersion(createOrderDto.getVersion());
orderExtInfoDto.setSessionKey(member.getSessionKey());
orderExtInfoDto.setFromAppId(member.getWxAppId());
createPrepayRequestDto.setOrderExtInfoDTO(orderExtInfoDto);
return payService.createPrepayOrder(createPrepayRequestDto);
}
private CreateOrderRequest generateCreateOrderRequest(StoreResponseDto storeInfo, Long orderAmount, AssortmentCustomerInfoVo member) {
CreateOrderRequest request = new CreateOrderRequest();
request.setPartnerId(storeInfo.getPartnerId());
request.setStoreId(storeInfo.getStoreCode());
request.setStoreName(storeInfo.getStoreName());
request.setUserId(member.getMemberId());
request.setUserName(member.getNickName());
request.setSettlementAmount(orderAmount);
request.setActualPayAmount(orderAmount);
request.setOriginalAmount(orderAmount);
request.setOrderType(OrderType.GENERAL_DINE_IN.getIndex());
request.setOrderClient(OrderClientType.CASHIER.getIndex());
switch (UserLoginChannelEnum.get(member.getChannel())) {
case ALIPAY:
request.setPayChannel(PayChannelType.ALIPAY.getIndex().toString());
request.setPayChannelType(PayChannelType.ALIPAY.getIndex());
break;
case WEIXIN:
request.setPayChannel(PayChannelType.WECHAT.getIndex().toString());
request.setPayChannelType(PayChannelType.WECHAT.getIndex());
break;
default:
throw new ServiceException(ResponseResult.OPERATE_NOT_SUPPORT);
}
// 无单收银没有商品信息， 这里防止基础服务处理NPE，传一个空的商品集合
request.setOrderItemList(new ArrayList<>());
OrderExtendedReq orderExtended = new OrderExtendedReq();
orderExtended.setOrderClientGroupCode(storeInfo.getParentCode());
orderExtended.setOrderClientGroup(storeInfo.getParentName());
request.setOrderExtended(orderExtended);
request.setOperator(member.getNickName());
request.setAppId(member.getWxAppId());
return request;
}
/**
* 支付成功回调处理
*
* @param message 支付消息
* @param confirmOrderDto 支付成功消息dto
* @param orderBeans 订单信息
* @return 处理结果json字符串
*/
@Override
public String paySuccessCallback(PaysuccessNoticeMessage message, ConfirmOrderDto confirmOrderDto, Map<String, OrderBeanV1> orderBeans) {
OrderBeanV1 orderBean = orderBeans.get(OrderBeanType.SAASORDER.getCode());
ConfirmOrderRequest var1 = LightApplicationConvertToAssortmentSdkAdapter.confirmOrderDtoConvertToConfirmOrderRequest(confirmOrderDto, orderBeans.get(OrderBeanType.MERMBERORDER.getCode()));
var1.setPartnerId(orderBean.getCompanyId());
var1.setUserId(orderBean.getUserId());
var1.setStoreId(orderBean.getShopId());
var1.setOrderType(orderBean.getType());
var1.setProductOrderCode(orderBean.getOid());
var1.setPayDate(DateUtil.convert2String(new Date(), "yyyy-MM-dd HH:mm:ss"));
var1.setPayTransId(message.getOut_trade_no());
var1.setOperator(orderBean.getUserName());
var1.setEndTransId(message.getEndTransId());
var1.setExtInfo(orderBean.getExtInfo());
if(orderBean.getGmtExpect() != null && orderBean.getGmtExpect() != 0){
var1.setExpectTime(DateUtil.convert2String(new Date(orderBean.getGmtExpect()),DateUtil.FORMAT_YYYY_MM_DD_HHMMSS));
}
try {
// 订单支付成功
orderBusinessService.payAccess(var1);
}catch (Exception e){
AppLogUtil.errorLog("sellCouponPayAccessError", JSONObject.toJSONString(var1),null,e);
}
//支付成功直接完成
OrderChangeStateReq request = new OrderChangeStateReq();
request.setOrderCode(orderBean.getOid());
request.setOrderState(NewOrderStatus.COMPLETE.getIndex());
request.setOperator(orderBean.getUserName());
request.setRemark("已完成");
orderSdkService.updateOrderState(request, LogThreadLocal.getTrackingNo());
Map<String, Object> map = Maps.newTreeMap();
map.put("code", 100);
map.put("message", "success");
return JSONObject.toJSONString(map);
}
}
order-application-service/src/main/java/cn/freemud/service/impl/CheckOrder.java
......@@ -31,6 +31,7 @@ import cn.freemud.entities.dto.user.GetSvcInfoByMemberIdResponseVo;
import cn.freemud.entities.dto.user.StatisticalScoreRequestVo;
import cn.freemud.entities.vo.CreateOrderVo;
import cn.freemud.entities.vo.GetMemberCouponRequestVo;
import cn.freemud.entities.vo.SellCouponCreateOrderVo;
import cn.freemud.entities.vo.ShoppingCartInfoRequestVo;
import cn.freemud.enums.*;
import cn.freemud.interceptor.ServiceException;
......@@ -63,6 +64,7 @@ import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
import com.freemud.application.sdk.api.storecenter.service.StoreCenterService;
import com.freemud.sdk.api.assortment.order.enums.StoreDeliveryMethod;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import com.google.gson.Gson;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
......@@ -175,6 +177,21 @@ public class CheckOrder {
return userLoginInfoDto;
}
public void checkMemberSvcCard(String partnerId, String memberId, SellCouponCreateOrderVo requestVo) {
if (StringUtils.isNotBlank(requestVo.getCardCode())) {
//校验会员svc卡信息
List<GetSvcInfoByMemberIdResponseVo> memberCardCode = checkCardCode(partnerId, memberId, Sets.newHashSet(requestVo.getCardCode()));
if (CollectionUtils.isNotEmpty(memberCardCode)) {
// 【华莱士】【订单C端记录不分账的卡面编号】不让走分账，卡面编号--11840，11845，11846，11853，11854，11855，11857，11858，11859，11860，11861，11862，11863，11864，11865，11866，11906
long count = memberCardCode.stream().filter(card -> Sets.newHashSet(requestVo.getCardCode()).contains(card.getCardCode()) && unDistributions.contains(card.getApplyId())).count();
if (count > 0) {
requestVo.setUnDistribution(1);
}
}
}
}
public AssortmentCustomerInfoVo checkOrderByMemberNew(String sessionId) {
// 通过sessionId查询缓存中会员id
......@@ -206,7 +223,7 @@ public class CheckOrder {
/**
* 查询门店信息新接口
*/
public SoreMixResponseDto getStoreInfoNew(String partnerId, String shopId, Boolean queryBusinessInfo) {
public StoreMixResponseDto getStoreInfoNew(String partnerId, String shopId, Boolean queryBusinessInfo) {
// 获取门店信息
StoreInfoRequestDto request = new StoreInfoRequestDto();
request.setPartnerId(partnerId);
......@@ -215,7 +232,7 @@ public class CheckOrder {
// query.setQueryStoreInfo(true);
query.setQueryBusinessInfo(queryBusinessInfo);
request.setQuery(query);
StoreBaseResponseDto<SoreMixResponseDto> storeInfoNew = storeClient.getStoreInfoNew(request);
StoreBaseResponseDto<StoreMixResponseDto> storeInfoNew = storeClient.getStoreInfoNew(request);
if (storeInfoNew == null || storeInfoNew.getBizVO() == null) {
throw new ServiceException(ResponseResult.STORE_NOT_FOUND);
......@@ -229,13 +246,13 @@ public class CheckOrder {
/**
* 查询门店信息新接口
*/
public SoreMixResponseDto getStoreInfoNew(String partnerId, String shopId, StoreInfoRequestDto.QueryInfo query) {
public StoreMixResponseDto getStoreInfoNew(String partnerId, String shopId, StoreInfoRequestDto.QueryInfo query) {
// 获取门店信息
StoreInfoRequestDto request = new StoreInfoRequestDto();
request.setPartnerId(partnerId);
request.setStoreCode(shopId);
request.setQuery(query);
StoreBaseResponseDto<SoreMixResponseDto> storeInfoNew = storeClient.getStoreInfoNew(request);
StoreBaseResponseDto<StoreMixResponseDto> storeInfoNew = storeClient.getStoreInfoNew(request);
if (storeInfoNew == null || storeInfoNew.getBizVO() == null) {
throw new ServiceException(ResponseResult.STORE_NOT_FOUND);
}
......@@ -281,7 +298,7 @@ public class CheckOrder {
String shopId = createOrderVo.getShopId();
// 获取门店信息
SoreMixResponseDto storeInfoNew = getStoreInfoNew(partnerId, shopId, true);
StoreMixResponseDto storeInfoNew = getStoreInfoNew(partnerId, shopId, true);
BusinessInfoDto businessInfo = storeInfoNew.getBusinessInfo();
return businessInfo;
......@@ -294,9 +311,9 @@ public class CheckOrder {
* @param query
* @return
*/
public SoreMixResponseDto getStoremixDto(String partnerId, String shopId, StoreInfoRequestDto.QueryInfo query) {
public StoreMixResponseDto getStoremixDto(String partnerId, String shopId, StoreInfoRequestDto.QueryInfo query) {
// 获取门店信息
SoreMixResponseDto storeInfoNew = getStoreInfoNew(partnerId, shopId, query);
StoreMixResponseDto storeInfoNew = getStoreInfoNew(partnerId, shopId, query);
return storeInfoNew;
}
......@@ -452,7 +469,7 @@ public class CheckOrder {
// 先暂时这么写, 到时候需要优化这一块 对于门店的请求操作
StoreInfoRequestDto.QueryInfo query = new StoreInfoRequestDto.QueryInfo();
query.setQueryDeliveryInfo(Boolean.TRUE);
SoreMixResponseDto storemixDto = this.getStoremixDto(createOrderVo.getPartnerId(), createOrderVo.getShopId(), query);
StoreMixResponseDto storemixDto = this.getStoremixDto(createOrderVo.getPartnerId(), createOrderVo.getShopId(), query);
DeliveryInfoDTO deliveryInfo = storemixDto.getDeliveryInfo();
Long deliveryLimitAmount = storeDeliveryInfoDto.getDeliveryLimitAmount();
Long totalAmount = shoppingCartGoodsDto.getTotalAmount();
......
order-application-service/src/main/java/cn/freemud/service/impl/MallOrderServiceImpl.java
......@@ -557,7 +557,7 @@ public class MallOrderServiceImpl implements MallOrderService {
//支付回掉成功标记
redisCache.save(RedisKeyConstant.KGD_PAYMENT_CALLBACK_FMID + message.getOut_trade_no(), message.getOut_trade_no(), 10L, TimeUnit.MINUTES);
if (message.getSource() != null && message.getSource().equals(PaySuccessSource.OUTSIDE.getSource())) {
verificationCoupon(message.getTrans_id());
verificationCoupon(message.getTrans_id(), message.getThirdPartTradeNo());
}
orderIds.add(orderBean.getOid());
......@@ -967,7 +967,7 @@ public class MallOrderServiceImpl implements MallOrderService {
return afterSalesOrderExtInfoVo;
}
private String verificationCoupon(String transId) {
private String verificationCoupon(String transId, String thirdTradeNo) {
String orderId = redisCache.getValue(RedisUtil.getPaymentTransIdOrderKey(transId));
if (StringUtils.isNotBlank(orderId)) {
transId = orderId;
......@@ -977,6 +977,7 @@ public class MallOrderServiceImpl implements MallOrderService {
return refundFaileMessage("mallOrderService order query fail" + queryOrderByIdResponseDto);
}
OrderBeanV1 orderBean = new OrderBeanV1();
orderBean.setThirdPartTradeNo(thirdTradeNo);
if (1 == queryOrderByIdResponseDto.getData().size()) {
orderBean = queryOrderByIdResponseDto.getData().get(0);
} else {
......
order-application-service/src/main/java/cn/freemud/service/impl/OrderAdapterServiceImpl.java
......@@ -2,11 +2,11 @@ package cn.freemud.service.impl;
import cn.freemud.adapter.OrderAdapter;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.demoTest.service.OrderService;
import cn.freemud.config.ApolloVariableConfig;
import cn.freemud.constant.RedisLockKey;
import cn.freemud.entities.dto.ConfirmOrderDto;
import cn.freemud.entities.dto.QueryOrdersResponseDto;
import cn.freemud.entities.dto.order.CreateCashierOrderDto;
import cn.freemud.entities.vo.*;
import cn.freemud.entities.vo.encircle.CreateReserveOrderVo;
import cn.freemud.enums.*;
import cn.freemud.interceptor.ServiceException;
import cn.freemud.management.service.handle.SaasOrderHandle;
......@@ -15,36 +15,30 @@ import cn.freemud.redis.RedisCache;
import cn.freemud.service.*;
import cn.freemud.service.universal.UniversalOrderService;
import cn.freemud.service.universal.factory.CreateOrderServiceFactory;
import cn.freemud.utils.AppLogUtil;
import cn.freemud.utils.RedisUtil;
import cn.freemud.utils.ResponseUtil;
import com.freemud.api.assortment.datamanager.entity.vo.AssortmentCustomerInfoVo;
import com.freemud.api.assortment.datamanager.enums.IappIdType;
import com.freemud.api.assortment.datamanager.manager.customer.AssortmentCustomerInfoManager;
import com.freemud.application.sdk.api.log.ApiLog;
import com.freemud.application.sdk.api.log.LogThreadLocal;
import com.freemud.application.sdk.api.ordercenter.config.OrderCenterProperties;
import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
import com.freemud.application.sdk.api.ordercenter.entities.vo.OrderCallBackRequestVo;
import com.freemud.application.sdk.api.ordercenter.enums.BizTypeEnum;
import com.freemud.application.sdk.api.ordercenter.response.orderInfo.OrderInfoReqs;
import com.freemud.sdk.api.assortment.order.enums.OrderSourceType;
import com.freemud.sdk.api.assortment.order.util.LockUtils;
import com.google.gson.Gson;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
import org.hibernate.validator.HibernateValidator;
import org.hibernate.validator.HibernateValidatorConfiguration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import javax.validation.ConstraintViolation;
import javax.validation.Validation;
import javax.validation.ValidatorFactory;
import java.util.*;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
/**
......@@ -131,7 +125,10 @@ public class OrderAdapterServiceImpl {
private OrderCallbackClient orderCallbackClient;
@Autowired
private SellCouponOrderServiceImpl sellCouponOrderServiceImpl;
@Autowired
private ApolloVariableConfig apolloVariable;
@Autowired
private CashierOrderService cashierOrderService;
//获取下单实现对象
private OrderFactoryService getCreateOrderBean(AssortmentCustomerInfoVo assortmentCustomerInfoVo,CreateOrderVo createOrderVo){
......@@ -162,7 +159,25 @@ public class OrderAdapterServiceImpl {
return orderService;
}
// @Override
/**
* 创建无单 收银订单
* 不需要查询购物车，没有商品，流程上 只需要创建一个订单然后唤起预支付就行了
* @param createOrderDto 请求信息
*/
public CreateOrderResponseVo createCashierOrder(CreateCashierOrderDto createOrderDto) {
AssortmentCustomerInfoVo member = assortmentCustomerInfoManager.getCustomerInfoByObject(createOrderDto.getSessionId());
if (member == null || StringUtils.isEmpty(member.getMemberId())) {
throw new ServiceException(ResponseResult.NOT_LOGIN);
}
//下单锁，防止重复点击
String lockKey = MessageFormat.format(RedisLockKey.CREATE_ORDER, member.getMemberId());
if (!LockUtils.lock(redisCache.getRedisTemplate(), lockKey, apolloVariable.getCreateOrderKeyExpire())) {
throw new ServiceException(ResponseResult.ORDER_NOT_CREATE_ERROR);
}
//创建订单，返回预支付信息
return cashierOrderService.createOrder(createOrderDto, member);
}
public BaseResponse createOrderNew(CreateOrderVo createOrderVo) {
AssortmentCustomerInfoVo assortmentCustomerInfoVo = assortmentCustomerInfoManager.getCustomerInfoByObject(createOrderVo.getSessionId());
if (assortmentCustomerInfoVo == null || StringUtils.isEmpty(assortmentCustomerInfoVo.getMemberId())) {
......@@ -194,7 +209,6 @@ public class OrderAdapterServiceImpl {
}
}
// @Override
public BaseResponse createOrderUniversal(Map<String, Object> param) {
if (param.isEmpty()) {
throw new ServiceException(ResponseResult.PARAMETER_MISSING);
......@@ -232,52 +246,6 @@ public class OrderAdapterServiceImpl {
}
}
// private BaseResponse validateParam(CreateOrderBaseVo createOrderBaseVo) {
// HibernateValidatorConfiguration configuration = Validation.byProvider(HibernateValidator.class)
// .configure()
// .failFast(false);
// ValidatorFactory validatorFactory = configuration.buildValidatorFactory();
// Set<ConstraintViolation<CreateOrderBaseVo>> set = validatorFactory.getValidator().validate(createOrderBaseVo);
// if (CollectionUtils.isNotEmpty(set)) {
// Iterator<ConstraintViolation<CreateOrderBaseVo>> iterator = set.iterator();
// if (iterator.hasNext()) {
// ConstraintViolation<CreateOrderBaseVo> constraintViolation = iterator.next();
// return ResponseUtil.error(ResponseResult.PARAMETER_MISSING.getCode(), constraintViolation.getMessage());
// }
// }
// return ResponseUtil.success();
// }
// @Override
// public BaseResponse createMCCafeOrder(CreateOrderVo createOrderVo) {
// AssortmentCustomerInfoVo assortmentCustomerInfoVo = assortmentCustomerInfoManager.getCustomerInfoByObject(createOrderVo.getSessionId());
// if (assortmentCustomerInfoVo == null || StringUtils.isEmpty(assortmentCustomerInfoVo.getMemberId())) {
// return ResponseUtil.error(ResponseResult.NOT_LOGIN);
// }
// if (!mcCafePartnerId.equals(assortmentCustomerInfoVo.getPartnerId())) {
// return ResponseUtil.error(ResponseResult.LOGIN_STORE_ERROR);
// }
// // 扩展字段中存储 sessionKey
// createOrderVo.setSessionKey(assortmentCustomerInfoVo.getSessionKey());
//
// // 添加分布式锁，如果没有取得锁直接返回失败；整个方法执行完毕后会删掉该锁
// // 锁定秒数从apollo获取，如果apollo没有设置，默认5秒
// String createOrderKey = CREATE_ORDER_KEY + assortmentCustomerInfoVo.getMemberId();
// try {
// Long expire = Long.valueOf(createOrderKeyExpire);
// if (!LockUtils.lock(redisCache.getRedisTemplate(), createOrderKey, expire)) {
// return ResponseUtil.error(ResponseResult.ORDER_NOT_CREATE_ERROR);
// }
// return mcCafeOrderService.createMCCafeOrder(createOrderVo);
// } catch (Exception e) {
// throw e;
// } finally {
// //LockUtils.unlock(redisCache.getRedisTemplate(),createOrderKey);
// }
// }
// @Override
public BaseResponse createPrepay(CreatePrepayVo createPrepayVo) {
AssortmentCustomerInfoVo assortmentCustomerInfoVo = assortmentCustomerInfoManager.getCustomerInfoByObject(createPrepayVo.getSessionId());
if (assortmentCustomerInfoVo == null || StringUtils.isEmpty(assortmentCustomerInfoVo.getMemberId())) {
......@@ -289,7 +257,6 @@ public class OrderAdapterServiceImpl {
throw new UnsupportedOperationException("暂不支持渠道：" + assortmentCustomerInfoVo.getChannel());
}
// @Override
public String paySuccessCallback(PaysuccessNoticeMessage message) {
if (StringUtils.isEmpty(message.getTrans_id())) {
return orderAdapter.newSendPayFailedMessage();
......@@ -325,47 +292,48 @@ public class OrderAdapterServiceImpl {
}
//紧急开关时 判断订单bean是否存在
orderBeanSass = orderBean;
/**
* 围餐处理
*/
if (OrderSourceType.MEAL.getCode().equals(orderBean.getSource())) {
return orderCommonService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
/**
* 微商城处理
*/
if (OrderSourceType.SAASMALL.getCode().equals(orderBean.getSource())) {
return mallOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
//积分商城处理
if (OrderSourceType.I_MEMBER.getCode().equals(orderBean.getSource()) && orderBean.getBizType() == 4) {
return pointsMallOrderService.paySuccessCallback(message,orderBeans);
}
//抖音卖券处理
if (OrderSourceType.TIKTOKPAY.getCode().equals(orderBean.getSource())) {
return sellCouponOrderService.paySuccessCallbackForTiktok(message, confirmOrderDto, orderBeans);
}
/**
* app订单处理
*/
if (OrderSourceType.APP.getCode().equals(orderBean.getSource())) {
if (orderBean.getBizType() == 6) {
return sellCouponOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
return appOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
//买券虚拟订单
if (orderBean.getBizType() == 6) {
return sellCouponOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
//麦咖啡订单处理
if (mcCafePartnerId.equals(orderBean.getCompanyId())) {
return mcCafeOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
// 支付成功处理
String result;
switch (Objects.requireNonNull(OrderSourceType.valueOfCode(orderBean.getSource()))) {
case MEAL: //围餐订单处理
result = orderCommonService.paySuccessCallback(message, confirmOrderDto, orderBeans);
break;
case CASHIER: //收银单处理
result = cashierOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
break;
case SAASMALL: //微商城订单处理
result = mallOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
break;
case TIKTOKPAY: //抖音卖券订单处理
result = sellCouponOrderService.paySuccessCallbackForTiktok(message, confirmOrderDto, orderBeans);
break;
case I_MEMBER: //会员订单
if (orderBean.getBizType() == 4) {
// 会员订单中 bizType为4的，为积分商城订单处理
result = pointsMallOrderService.paySuccessCallback(message,orderBeans);
break;
}
// bizType不等于4的，非积分商城订单，继续往下走
case APP: //app订单
if (orderBean.getBizType() != 6) {
// bizType为卖券的订单，不走app订单逻辑
result = appOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
break;
}
default:
// 买券虚拟订单
if (orderBean.getBizType() == 6) {
result = sellCouponOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
// 麦咖啡订单处理
if (mcCafePartnerId.equals(orderBean.getCompanyId())) {
result = mcCafeOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
// 默认点餐处理
result = orderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
}
/**
* 默认点餐处理
*/
return orderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
return result;
} catch (Exception e) {
throw e;
} finally {
......@@ -381,41 +349,6 @@ public class OrderAdapterServiceImpl {
}
}
// @Override
// public String mcCafePaySuccessCallback(PaysuccessNoticeMessage message) {
// //添加分布式锁，如果没有取得锁直接返回失败；整个方法执行完毕后会删掉该锁
// String paySuccessKey = PAY_SUCCESS_KEY + message.getTrans_id();
// if (!LockUtils.lockAfter(redisCache.getRedisTemplate(), paySuccessKey)) {
// return orderAdapter.paySuccessLockedMessage();
// }
// try {
// ConfirmOrderDto confirmOrderDto = orderAdapter.convent2ConfirmOrderDto(message);
// // 通过交易号从缓存中拿订单号，如果有数据则实际订单号为其value值
// String orderId = redisCache.getValue(RedisUtil.getPaymentTransIdOrderKey(confirmOrderDto.getOrderId()));
// if (StringUtils.isNotBlank(orderId)) {
// confirmOrderDto.setOrderId(orderId);
// }
// Map<String, OrderBeanV1> orderBeans = orderServiceImpl.getOrderBeanByOrderId(confirmOrderDto.getOrderId());
// if (MapUtils.isEmpty(orderBeans)) {
// return gson.toJson(message);
// }
// OrderBeanV1 orderBean = orderBeans.get(OrderBeanType.SAASORDER.getCode());
// if (!PayStatus.NOT_PAY.getCode().equals(orderBean.getPayStatus())) {
// return orderAdapter.sendPaySuccessNoticeMessage();
// }
// /**
// * 默认点餐处理
// */
// return mcCafeOrderService.paySuccessCallback(message, confirmOrderDto, orderBeans);
// } catch (Exception e) {
// throw e;
// } finally {
// //删除分布式锁
// redisCache.delete("saas:lockAfter:" + paySuccessKey);
// }
// }
/**
* APP下单，下单带商品信息，不经过购物车服务，不唤起支付
*/
......
order-application-service/src/main/java/cn/freemud/service/impl/OrderQueueService.java
......@@ -5,8 +5,10 @@ import cn.freemud.amqp.Header;
import cn.freemud.amqp.MQAction;
import cn.freemud.amqp.MQMessage;
import cn.freemud.amqp.MQService;
import cn.freemud.constant.RedisKeyConstant;
import cn.freemud.entities.dto.OrderPrintDto;
import cn.freemud.entities.dto.pay.PaymentMqMessageDto;
import cn.freemud.redis.RedisCache;
import cn.freemud.utils.AppLogUtil;
import com.alibaba.fastjson.JSON;
import com.freemud.application.sdk.api.config.TopicExchangeConfig;
......@@ -18,11 +20,16 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
@Component
public class OrderQueueService {
@Autowired
private MQService mqService;
@Autowired
private RedisCache redisCache;
// TODO: 21-9-17 定义常量
......@@ -75,6 +82,10 @@ public class OrderQueueService {
} catch (Exception e) {
AppLogUtil.errorLog("ActivityReverse", JSON.toJSONString(requestDto), "", e);
}
String redisKey = RedisKeyConstant.KGD_PAYMENT_CANCEL_OID + oid ;
//取消支付订单缓存
// redisCache.save(redisKey, true, 180L, TimeUnit.MINUTES);
}
......
order-application-service/src/main/java/cn/freemud/service/impl/OrderServiceImpl.java
......@@ -15,7 +15,6 @@ package cn.freemud.service.impl;
import cn.freemud.adapter.*;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.base.util.DateUtil;
import cn.freemud.constant.KgdRedisKeyConstant;
import cn.freemud.constant.OrderRefundConstant;
import cn.freemud.constant.RedisKeyConstant;
import cn.freemud.constant.ResponseCodeConstant;
......@@ -101,6 +100,8 @@ import com.freemud.sdk.api.assortment.message.enums.MessageEventType;
import com.freemud.sdk.api.assortment.message.request.MessagePushOrderTemplateRequest;
import com.freemud.sdk.api.assortment.message.request.MessageTemplateRequest;
import com.freemud.sdk.api.assortment.message.service.IMessageTemplatePushService;
import com.freemud.sdk.api.assortment.order.constant.OrderRedisKeyConstant;
import com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity;
import com.freemud.sdk.api.assortment.order.enums.AutoOrderConfigTime;
import com.freemud.sdk.api.assortment.order.enums.NewOrderType;
import com.freemud.sdk.api.assortment.order.enums.OldOrderStatus;
......@@ -152,6 +153,8 @@ public class OrderServiceImpl implements Orderservice {
private List<String> cocoPartnerId;
@Value("#{'${hls.partnerId}'.split(',')}")
private List<String> hlsPartnerId;
@Value("#{'${order.delete.partnerId}'.split(',')}")
private List<String> deletePartnerId;
@Value("#{'${order.not.automatic.twist.partnerId}'.split(',')}")
private List<String> notAutomaticTwistPartnerId;
@Value("${order.not.automatic.twist.time}")
......@@ -326,7 +329,7 @@ public class OrderServiceImpl implements Orderservice {
CreateOrderOperateDto createOrderOperateDto = (CreateOrderOperateDto) createOrderOperateDtoResponse.getResult();
//创建支付
CreatePrepayRequestDto createPrepayRequestDto = orderAdapter.convertToCreatePrepayRequestDto(userLoginInfoDto, createOrderVo, createOrderOperateDto, extInfo);
return payServiceImpl.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payServiceImpl.createPrepayOrder(createPrepayRequestDto));
}
/**
......@@ -513,7 +516,7 @@ public class OrderServiceImpl implements Orderservice {
//支付回调成功标记
redisCache.save(RedisKeyConstant.KGD_PAYMENT_CALLBACK_FMID + message.getOut_trade_no(), message.getOut_trade_no(), 10L, TimeUnit.MINUTES);
if (message.getSource() != null && message.getSource().equals(PaySuccessSource.OUTSIDE.getSource())) {
verificationCoupon(message.getTrans_id());
verificationCoupon(message.getTrans_id(), message.getThirdPartTradeNo());
}
return sendPaySuccessNoticeMessage();
}
......@@ -588,6 +591,7 @@ public class OrderServiceImpl implements Orderservice {
message.setTerminalId(newMessage.getAppId());
message.setRuleId(newMessage.getRuleId());
message.setSource(PaySuccessSource.OUTSIDE.getSource());
message.setThirdPartTradeNo(message.getThirdPartTradeNo());
String res = orderAdapterService.paySuccessCallback(message);
JSONObject jsonObject = JSONObject.parseObject(res);
if (jsonObject.containsKey("code")) {
......@@ -601,7 +605,7 @@ public class OrderServiceImpl implements Orderservice {
return orderAdapter.newSendPayFailedMessage();
}
private String verificationCoupon(String transId) {
private String verificationCoupon(String transId, String thirdPartTradeNo) {
String orderId = redisCache.getValue(RedisUtil.getPaymentTransIdOrderKey(transId));
if (StringUtils.isNotBlank(orderId)) {
transId = orderId;
......@@ -619,6 +623,7 @@ public class OrderServiceImpl implements Orderservice {
orderBean = orderBeans.get(0);
}
}
orderBean.setThirdPartTradeNo(thirdPartTradeNo);
//核销券
BaseResponse baseResponse = couponActivityService.verificationCoupon(orderBean, CouponReqType.WRITEOFF);
return "核销券码返回结果" + baseResponse.getCode() + "," + baseResponse.getMessage();
......@@ -1619,7 +1624,7 @@ public class OrderServiceImpl implements Orderservice {
// 目前只有coco在订单详情参加支付有礼，且不检查订单的状态
if (cocoPartnerId.contains(partnerId)) {
joinPayGift(sessionId, queryOrderResponseVo, partnerId, null);
} else if(BizTypeEnum.SALE_COUPON.getBizType().equals(orderBean.getBizType()) && Integer.valueOf(1).equals(isQueryAfterPay)) {
} else if(BizTypeEnum.SALE_COUPON.getBizType().equals(orderBean.getBizType())) {
joinPayGift(sessionId, queryOrderResponseVo, partnerId, payGiftVer);
}
......@@ -1769,17 +1774,22 @@ public class OrderServiceImpl implements Orderservice {
if (paySuccess) {
return ResponseUtil.error(ResponseResult.ORDER_DELETE_ERROR.getCode(), "支付成功");
}
// DeleteOrderDto deleteOrderDto = orderAdapter.convent2DeleteOrderDto(deleteOrderVo.getOid());
//
// DeleteOrderRequest var1 = new DeleteOrderRequest();
// var1.setOrderId(deleteOrderDto.getOrderId());
// var1.setOrderSdkType(getDefaultOrderSdkType(deleteOrderVo.getPartnerId()));
// var1.setTrackingNo(LogThreadLocal.getTrackingNo());
// BaseOrderResponse baseOrderResponse = orderCenterSdkService.deleteOrder(var1);
//
// if (!RESPONSE_SUCCESS_CODE.equals(baseOrderResponse.getErrcode())) {
// return ResponseUtil.error(ResponseResult.ORDER_DELETE_ERROR);
// }
String partnerId = deleteOrderVo.getPartnerId();
if (CollectionUtils.isEmpty(deletePartnerId) || deletePartnerId.contains("") || deletePartnerId.contains(partnerId)) {
String reason = "用户取消支付";
CancelOrderRequest cancelOrderRequest = orderAdapter.convent2CancelOrderRequest(orderBean.getOid(),
partnerId, AfterSalesType.USER_CANCEL, reason, LogThreadLocal.getTrackingNo(), System.currentTimeMillis()+"");
cancelOrderRequest.setOperator(orderBean.getUserName());
cancelOrderRequest.setPartnerId(orderBean.getCompanyId());
cancelOrderRequest.setCreateEvent(AfterSalesOrderCreateEventEnum.REFUND_COMPLETE.getCreateEvent());
cancelOrderRequest.setReqRemark(reason);
try {
orderBusinessService.orderCancel(cancelOrderRequest);
// orderSdkService.deleteOrder(var1,LogThreadLocal.getTrackingNo());
}catch (Exception e) {
ErrorLog.printErrorLog("删除订单失败", "order/v2/cancel", JSONObject.toJSONString(cancelOrderRequest), e);
}
}
// TODO: 2019/9/10 删除订单通知
orderQueueService.backOrdersStatusChange(orderBean.getOid(), orderBean.getStatus());
return ResponseUtil.success();
......@@ -1996,10 +2006,10 @@ public class OrderServiceImpl implements Orderservice {
}
} else {
// 查询小程序是否配置了退运费
String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT);
String configStr = redisCache.hashGet(MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, orderBean.getCompanyId(), wxAppId), OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT);
if (StringUtils.isNotEmpty(configStr)) {
JSONObject config = JSON.parseObject(configStr);
String refundDeliveryFeeConfig = config.getString(OrderRefundEnum.REFUND_DELIVERY_FEE_ENABLE.getKeyValue());
OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
String refundDeliveryFeeConfig = config.getRefundShippingFee();
// 0、null表示 关闭 ; 1 表示开启
if (null != refundDeliveryFeeConfig
&& Arrays.asList(OrderStatus.DISTRIBUTION.getCode(), OrderStatus.COMPLETE.getCode()).contains(orderBean.getStatus())
......@@ -2867,6 +2877,8 @@ public class OrderServiceImpl implements Orderservice {
channelType = OrderChannelType.APP.getCode();
} else if (OrderChannelType.BEAUTIFUL.getCode().equals(queryOrderVo.getChannelType())) {
channelType = OrderChannelType.BEAUTIFUL.getCode();
} else if (OrderChannelType.CASHIER.getCode().equals(queryOrderVo.getChannelType())) {
channelType = OrderChannelType.CASHIER.getCode();
}
return channelType;
}
......
order-application-service/src/main/java/cn/freemud/service/impl/PayServiceImpl.java
......@@ -3,7 +3,6 @@ package cn.freemud.service.impl;
import cn.freemud.adapter.OrderAdapter;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.base.util.DateUtil;
import cn.freemud.constant.KgdRedisKeyConstant;
import cn.freemud.constant.RedisKeyConstant;
import cn.freemud.constant.ResponseCodeConstant;
import cn.freemud.entities.dto.SvcComPayRequestDto;
......@@ -66,6 +65,7 @@ import com.freemud.application.sdk.api.paymentcenter.client.response.PaymentClos
import com.freemud.application.sdk.api.paymentcenter.client.response.PaymentQueryResponse;
import com.freemud.application.sdk.api.paymentcenter.client.service.PaymentNewService;
import com.freemud.application.sdk.api.storecenter.response.StoreResponse;
import com.freemud.sdk.api.assortment.order.constant.OrderRedisKeyConstant;
import com.freemud.sdk.api.assortment.order.request.order.CancelOrderRequest;
import com.freemud.sdk.api.assortment.order.request.order.MultiOrderRefundRequest;
import com.freemud.sdk.api.assortment.order.request.order.OrderEditRequest;
......@@ -151,7 +151,7 @@ public class PayServiceImpl {
/**
* 创建预支付订单
*/
public BaseResponse createPrepayOrder(CreatePrepayRequestDto createPrepayRequestDto) {
public CreateOrderResponseVo createPrepayOrder(CreatePrepayRequestDto createPrepayRequestDto) {
CreateOrderResponseVo createOrderResponse;
OrderPayResponse orderPayResponse = null;
......@@ -190,13 +190,13 @@ public class PayServiceImpl {
|| ResponseCodeConstant.NOT_SUFFICIENT_FUND.equals(orderPayResponse.getPayTransId())) ?
orderPayResponse.getMsg() : "支付失败");
}
return baseResponse;
throw new ServiceException(baseResponse.getCode(), baseResponse.getMessage());
}
createOrderResponse = orderAdapter.convent2CreateFatherSonOrderResponseVo(orderPayResponse, createPrepayRequestDto.getProductOrderBean());
//更新订单支付信息
BaseResponse baseEditResponse = this.updateOrderInfo(orderPayResponse, createPrepayRequestDto.getOrderExtInfoDTO(), createPrepayRequestDto.getProductOrderBean(), LogThreadLocal.getTrackingNo());
if (baseEditResponse != null) {
return baseEditResponse;
throw new ServiceException(baseEditResponse.getCode(), baseEditResponse.getMessage());
}
if (totalAmount > 0 && StringUtils.isBlank(cardCode) && Objects.isNull(createPrepayRequestDto.getUnionPayCard())) {
createOrderResponse.setPaySuccess(false);
......@@ -208,7 +208,7 @@ public class PayServiceImpl {
createOrderResponse.setPaySuccess(true);
}
if (!createOrderResponse.getPaySuccess()) {
return ResponseUtil.success(createOrderResponse);
return createOrderResponse;
} else {
//如果是商品券支付0元，调用回调接口
/**
......@@ -225,7 +225,7 @@ public class PayServiceImpl {
message.setMerchant_coupon(0);
message.setSource(PaySuccessSource.OUTSIDE.getSource());
orderAdapterService.paySuccessCallback(message);
return ResponseUtil.success(createOrderResponse);
return createOrderResponse;
}
}
......@@ -485,7 +485,7 @@ public class PayServiceImpl {
* 查询支付配置
*/
private String getPaymentPrincipalName(String partnerId, String appId) {
String redisKey = MessageFormat.format(KgdRedisKeyConstant.PARTNER_PAYMENT_PRINCIPAL_NAME, partnerId);
String redisKey = MessageFormat.format(OrderRedisKeyConstant.PARTNER_PAYMENT_PRINCIPAL_NAME, partnerId);
// 先从redis中查询支付商户名称
String principalName = redisCache.hashGet(redisKey, appId);
if (StringUtils.isEmpty(principalName)) {
......
order-application-service/src/main/java/cn/freemud/service/impl/SellCouponOrderServiceImpl.java
......@@ -21,6 +21,7 @@ import cn.freemud.entities.vo.NgsSellCouponCreateOrderVo;
import cn.freemud.entities.vo.PaysuccessNoticeMessage;
import cn.freemud.entities.vo.SellCouponCreateOrderVo;
import cn.freemud.enums.*;
import cn.freemud.enums.integralproduct.IntegralProductStatusEnum;
import cn.freemud.interceptor.ServiceException;
import cn.freemud.manager.BuyProductOnceManager;
import cn.freemud.redis.RedisCache;
......@@ -77,6 +78,7 @@ import com.freemud.sdk.api.assortment.order.response.order.CreateOrderResponse;
import com.freemud.sdk.api.assortment.order.response.order.PayAccessResponse;
import com.freemud.sdk.api.assortment.order.service.OrderCenterSdkService;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.StringUtils;
......@@ -270,15 +272,17 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
orderExtInfoDto.setSaleCouponPhone(requestVo.getSaleCouponPhone());
createPrepayRequestDto.setOrderExtInfoDTO(orderExtInfoDto);
return payService.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payService.createPrepayOrder(createPrepayRequestDto));
}
/**
* 卖券订单创建
*/
public BaseResponse createOrder(SellCouponCreateOrderVo requestVo){
// 查询用户信息、校验svc卡
// 查询用户信息
AssortmentCustomerInfoVo userLoginInfoDto = checkOrder.checkOrderByMemberNew(requestVo.getSessionId());
// 如果用户适用SVC 卡支付，则校验svc卡,
checkOrder.checkMemberSvcCard(userLoginInfoDto.getPartnerId(), userLoginInfoDto.getMemberId(), requestVo);
String trackingNo = LogThreadLocal.getTrackingNo();
String partnerId = userLoginInfoDto.getPartnerId();
String storeId = requestVo.getShopId();
......@@ -388,7 +392,7 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
createPrepayRequestDto.setProductOrderBean(createOrderResponse.getData());
createPrepayRequestDto.setTotalAmount(createOrderRequest.getSettlementAmount());
createPrepayRequestDto.setCardAmount(0);
createPrepayRequestDto.setChannel(requestVo.getChannel());
OrderExtInfoDto orderExtInfoDto = new OrderExtInfoDto();
String deliveryHoursDayStart = "";
String deliveryHoursDayEnd = "";
......@@ -414,9 +418,9 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
orderExtInfoDto.setSessionKey(userLoginInfoDto.getSessionKey());
orderExtInfoDto.setFormId(requestVo.getFormId());
orderExtInfoDto.setFromAppId(userLoginInfoDto.getWxAppId());
orderExtInfoDto.setUnDistribution(requestVo.getUnDistribution());
createPrepayRequestDto.setOrderExtInfoDTO(orderExtInfoDto);
return payService.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payService.createPrepayOrder(createPrepayRequestDto));
}
......@@ -473,6 +477,15 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
if (CollectionUtils.isEmpty(productBindingCoupons)) {
return ResponseUtil.error(ResponseResult.STORE_ITEM_CHECK_INVAILD);
}
// 产品确认 暂时不需要改逻辑
// List<GetMenuCategoryInfoResponse.RootNodeBean.ChildrenBeanFirst.ChildrenBeanSecond.ProductBean> products = productInfosByIds.getData().getProducts();
//
// for (GetMenuCategoryInfoResponse.RootNodeBean.ChildrenBeanFirst.ChildrenBeanSecond.ProductBean product : products) {
// Integer status = product.getStatus();
// if (!Objects.equals(status, IntegralProductStatusEnum.STATUS_2.getCode())) {
// return ResponseUtil.error(ResponseResult.COUPON_INVAILD.getCode(),"您需要购买的券包，包含的优惠券券编号"+skuId+"包含的商品已失效，请联系门店尽快处理");
// }
// }
List<String> activityCodes = new ArrayList<>();
for (GetMenuCategoryInfoResponse.RootNodeBean.ChildrenBeanFirst.ChildrenBeanSecond.ProductBean.ProductBindingCouponType productBindingCouponType : productBindingCoupons) {
activityCodes.add(productBindingCouponType.getActivityCode());
......@@ -486,7 +499,18 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
Date now = new Date();
for (ActiveDetailVO activeDetailVO : activeDetailVOS) {
if (activeDetailVO.getEffectiveEndTime() != null && activeDetailVO.getEffectiveEndTime().before(now)) {
return ResponseUtil.error(ResponseResult.COUPON_INVAILD);
return ResponseUtil.error(ResponseResult.COUPON_INVAILD.getCode(),"您需要购买的券包，包含的优惠券券编号"+activeDetailVO.getActiveCode()+"已过期，请联系门店尽快处理");
}
// endDate 领券结束时间 校验 当前时间小鱼endDate
if (activeDetailVO.getEndDate() != null && activeDetailVO.getEndDate().before(now)) {
return ResponseUtil.error(ResponseResult.COUPON_INVAILD.getCode(),"您需要购买的券包，包含的优惠券券编号"+activeDetailVO.getActiveCode()+"已过期，请联系门店尽快处理");
}
// state = 1 || 2 可以买
if (activeDetailVO.getState() !=null) {
Integer state = activeDetailVO.getState();
if (!Objects.equals(state,1) && !Objects.equals(state,2)) {
return ResponseUtil.error(ResponseResult.COUPON_INVAILD.getCode(),"您需要购买的券包，包含的优惠券券编号"+activeDetailVO.getActiveCode()+"已失效，请联系门店尽快处理");
}
}
}
//转换CreateOrderRequest对象
......@@ -558,7 +582,7 @@ public class SellCouponOrderServiceImpl implements OrderFactoryService {
orderExtInfoDto.setStationId(stationid);
createPrepayRequestDto.setOrderExtInfoDTO(orderExtInfoDto);
return payService.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payService.createPrepayOrder(createPrepayRequestDto));
}
......
order-application-service/src/main/java/cn/freemud/service/impl/SpellGroupOrderServiceImpl.java
......@@ -193,7 +193,7 @@ public class SpellGroupOrderServiceImpl implements SpellGroupOrderService {
}
/*创建支付*/
CreatePrepayRequestDto createPrepayRequestDto = spellGroupOrderAdapter.convertToCreatePrepayRequest(userLoginInfoDto, createOrderResponse.getData(), trackingNo,createSpellGroupOrderDto.getProvince());
return payServiceimpl.createPrepayOrder(createPrepayRequestDto);
return ResponseUtil.success(payServiceimpl.createPrepayOrder(createPrepayRequestDto));
}
/***
......
order-application-service/src/main/java/cn/freemud/service/store/StoreManager.java 0 → 100644
package cn.freemud.service.store;
import cn.freemud.constant.ResponseCodeConstant;
import cn.freemud.entities.dto.store.StoreMixResponseDto;
import cn.freemud.entities.dto.store.StoreBaseResponseDto;
import cn.freemud.entities.dto.store.StoreInfoRequestDto;
import cn.freemud.enums.ResponseResult;
import cn.freemud.interceptor.ServiceException;
import cn.freemud.service.thirdparty.StoreClient;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import java.util.function.Consumer;
/**
* @author Clover.z
* @Date 2021/10/20
* @Desc
*/
@Service
@RequiredArgsConstructor
public class StoreManager {
private final StoreClient storeClient;
/**
* 查询门店相关聚合信息
* @param partnerId 商户号
* @param storeCode 门店号
* @param q 设置查询数据的func
* @return
*/
public StoreMixResponseDto queryStoreMixInfo(String partnerId, String storeCode, Consumer<StoreInfoRequestDto.QueryInfo> q) {
StoreInfoRequestDto request = new StoreInfoRequestDto(partnerId, storeCode);
StoreInfoRequestDto.QueryInfo query = new StoreInfoRequestDto.QueryInfo();
q.accept(query);
request.setQuery(query);
StoreBaseResponseDto<StoreMixResponseDto> response = storeClient.getStoreInfoNew(request);
if (null == response || !ResponseCodeConstant.RESPONSE_SUCCESS.equals(response.getStatusCode()) || null == response.getBizVO()) {
throw new ServiceException(ResponseResult.STORE_DATE_ERROR);
}
return response.getBizVO();
}
}
order-application-service/src/main/java/cn/freemud/service/thirdparty/StoreClient.java
......@@ -12,12 +12,9 @@
*/
package cn.freemud.service.thirdparty;
import cn.freemud.entities.dto.*;
import cn.freemud.entities.dto.store.SoreMixResponseDto;
import cn.freemud.entities.dto.store.StoreMixResponseDto;
import cn.freemud.entities.dto.store.StoreBaseResponseDto;
import cn.freemud.entities.dto.store.StoreInfoRequestDto;
import com.freemud.application.sdk.api.storecenter.request.ChangeTableOrderStateRequest;
import com.freemud.application.sdk.api.storecenter.response.StoreBaseResponse;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
......@@ -63,5 +60,5 @@ public interface StoreClient {
* 查询门店信息
*/
@PostMapping(value = "/api/v2/organization/getStoreMix", produces = MediaType.APPLICATION_JSON_UTF8_VALUE, consumes = MediaType.APPLICATION_JSON_UTF8_VALUE)
StoreBaseResponseDto<SoreMixResponseDto> getStoreInfoNew(@RequestBody StoreInfoRequestDto request);
StoreBaseResponseDto<StoreMixResponseDto> getStoreInfoNew(@RequestBody StoreInfoRequestDto request);
}
order-management/src/main/java/cn/freemud/management/constant/KgdRedisKeyConstant.java deleted 100644 → 0
package cn.freemud.management.constant;
/**
* @author Clover.z
* @Date 2021/8/11
* @Desc
*/
public class KgdRedisKeyConstant {
/**
* 订单是否支持退款配置 缓存key
* 0：商户号
* 1：小程序appId
*
* value: hash结构
* hkey : eatInType 堂食 和takeOutType 外卖
* 具体配置为json字符串
*/
public static final String ORDER_REFUND_CONFIG = "kgd:order_refund_config_{0}_{1}";
/**
* 订单类型为堂食 redis配置的hkey
*/
public static final String REFUND_CFG_EAT_IN = "eatInType";
/**
* 订单类型为外卖 redis配置的hkey
*/
public static final String REFUND_CFG_TAKE_OUT = "takeOutType";
}
order-management/src/main/java/cn/freemud/management/enums/OrderRefundEnum.java deleted 100644 → 0
package cn.freemud.management.enums;
/**
* All rights Reserved, Designed By www.freemud.cn
*
* @version V1.0
* @Title: OrderRefundEnum
* @Package cn.freemud.constant
* @Description:
* @author: bowen.hu
* @date: 2019-09-17 10:46
* @Copyright: 2019 www.freemud.cn Inc. All rights reserved.
* 注意：本内容仅限于上海非码科技内部传阅，禁止外泄以及用于其他的商业目的
*/
public enum OrderRefundEnum {
ORDER_REFUND("orderRefund", "已完成订单是否允许退款"),
TAKEORDER_REFUND("takeOrderRefund", "未接单是否支持退款"),
RECEIPTORDER_REFUND("receiptOrderRefund", "已接单是否支持退款"),
COMPLETEMAKEORDER_REFUND("completeMakeOrderRefund", "制作完成是否支持退款"),
DELIVERY_TAKE_ORDER_REFUND("deliveryTakeOrderRefund","外卖单未接单是否支持退款"),
DELIVERY_RECEIPT_ORDER_REFUND("deliveryReceiptOrderRefund","外卖单已接单是否支持退款"),
DELIVERY_COMPLETE_MAKE_ORDER_REFUND("deliveryCompleteMakeOrderRefund","外卖单制作完成是否支持退款"),
DELIVERY_ORDER_REFUND("deliveryOrderRefund","外卖单订单完成是否支持退款"),
REFUND_DATA_RANGE("refundDateRange", "退款允许日期"),
REFUND_DELIVERY_FEE_ENABLE("refundShippingFee","商家同意退款时是否退配送费"),
REFUND_REVERSE_COUPON("refundReverseCoupon", "退款退优惠券");
private String keyValue;
private String message;
OrderRefundEnum(String keyValue, String message) {
this.keyValue = keyValue;
this.message = message;
}
public String getKeyValue() {
return keyValue;
}
public String getMessage() {
return message;
}
}
order-management/src/main/java/cn/freemud/management/service/handle/OrderVerifyHandle.java
package cn.freemud.management.service.handle;
import cn.freemud.base.entity.BaseResponse;
import cn.freemud.management.constant.KgdRedisKeyConstant;
import cn.freemud.management.entities.dto.request.order.OrderManagerRequest;
import cn.freemud.management.entities.dto.response.order.OrderManagerResponse;
import cn.freemud.management.enums.*;
......@@ -14,8 +13,11 @@ import com.freemud.application.sdk.api.ordercenter.entities.v1.AccountBeanV1;
import com.freemud.application.sdk.api.ordercenter.entities.v1.OrderBeanV1;
import com.freemud.application.sdk.api.ordercenter.entities.v1.RefundBeanV1;
import com.freemud.application.sdk.api.ordercenter.enums.OperateClient;
import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
import com.freemud.sdk.api.assortment.message.enums.OrderType;
import com.freemud.sdk.api.assortment.order.adapter.OrderSdkAdapter;
import com.freemud.sdk.api.assortment.order.constant.OrderRedisKeyConstant;
import com.freemud.sdk.api.assortment.order.entities.OrderRefundConfigEntity;
import com.freemud.sdk.api.assortment.order.enums.OldOrderAccountType;
import com.freemud.sdk.api.assortment.order.enums.OldOrderType;
import com.freemud.sdk.api.assortment.order.enums.OrderSourceType;
......@@ -565,78 +567,63 @@ public class OrderVerifyHandle {
*/
private boolean getRefundConfig(OrderBeanV1 data) {
boolean isFinishRefund = false;
// [华莱士20210410] 微商城订单判断
if(Objects.equals(com.freemud.sdk.api.assortment.order.enums.OrderSourceType.SAASMALL.getCode(),data.getSource()) ){
// 除 未支付 拒单 和 取消外，其他可退款
return Stream.of(OrderStatus.WAIT_PAY,OrderStatus.REFUSE,OrderStatus.CANCEL).noneMatch(s -> Objects.equals(data.getStatus(),s.getCode()));
}
com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto extInfo = null;
JSONObject jsonObject1 = JSONObject.parseObject(data.getExtInfo());
extInfo = jsonObject1.toJavaObject(com.freemud.application.sdk.api.ordercenter.request.OrderExtInfoDto.class);
// 查询小程序配置的退款设置
String hkey = OrderType.TAKE_OUT.getCode().equals(data.getOrderType()) ? KgdRedisKeyConstant.REFUND_CFG_TAKE_OUT : KgdRedisKeyConstant.REFUND_CFG_EAT_IN;
String configStr = redisCache.hashGet(MessageFormat.format(KgdRedisKeyConstant.ORDER_REFUND_CONFIG, data.getCompanyId(), extInfo.getAppid()), hkey);
String redisKey = MessageFormat.format(OrderRedisKeyConstant.ORDER_REFUND_CONFIG, data.getCompanyId(), extInfo.getAppid());
String hashKey;
if (OrderClientType.CASHIER.getIndex().toString().equals(data.getOrderClient())) {
//收银单，使用收银单的退款配置
hashKey = OrderRedisKeyConstant.HashKeyForOrderRefundConfig.CASHIER;
} else {
hashKey = OrderType.TAKE_OUT.getCode().equals(data.getOrderType())
? OrderRedisKeyConstant.HashKeyForOrderRefundConfig.TAKE_OUT
: OrderRedisKeyConstant.HashKeyForOrderRefundConfig.EAT_IN;
}
String configStr = redisCache.hashGet(redisKey, hashKey);
if (StringUtils.isEmpty(configStr)) {
return true;
}
JSONObject config = JSON.parseObject(configStr);
String orderRefund;
//订单状态
switch (data.getStatus()) {
// 未接单
case 1:
//区分外卖单和到店订单，判断是否可以退款
if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_TAKE_ORDER_REFUND.getKeyValue());
}else {
orderRefund = config.getString(OrderRefundEnum.TAKEORDER_REFUND.getKeyValue());
}
if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund))) {
isFinishRefund = true;
}
break;
//已接单
case 3:
if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_RECEIPT_ORDER_REFUND.getKeyValue());
}else {
orderRefund = config.getString(OrderRefundEnum.RECEIPTORDER_REFUND.getKeyValue());
}
if (orderRefund == null || (orderRefund != null && ALLOW_REFUND.equals(orderRefund))) {
isFinishRefund = true;
}
break;
//制作完成
case 31:
if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_COMPLETE_MAKE_ORDER_REFUND.getKeyValue());
}else {
orderRefund = config.getString(OrderRefundEnum.COMPLETEMAKEORDER_REFUND.getKeyValue());
}
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
isFinishRefund = true;
}
break;
// 订单完成
case 5:
if(OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
orderRefund = config.getString(OrderRefundEnum.DELIVERY_ORDER_REFUND.getKeyValue());
}else {
orderRefund = config.getString(OrderRefundEnum.ORDER_REFUND.getKeyValue());
}
if (orderRefund != null && ALLOW_REFUND.equals(orderRefund)) {
isFinishRefund = true;
}
break;
default:
break;
OrderRefundConfigEntity config = JSON.parseObject(configStr, OrderRefundConfigEntity.class);
String orderRefund = null;
if (OrderClientType.CASHIER.getIndex().toString().equals(data.getOrderClient())) {
//收银单，使用收银单的退款配置 收银单只有完成的订单，直接判断是否可以退款就行
orderRefund = config.getCashierOrderRefund();
} else if (OrderType.TAKE_OUT.getCode().equals(data.getOrderType())) {
//外卖单，使用外卖单的退款配置
switch (data.getStatus()) {
// 未接单
case 1: orderRefund = config.getDeliveryTakeOrderRefund(); break;
//已接单
case 3: orderRefund = config.getDeliveryReceiptOrderRefund(); break;
//制作完成
case 31: orderRefund = config.getDeliveryCompleteMakeOrderRefund(); break;
// 订单完成
case 5: orderRefund = config.getDeliveryOrderRefund(); break;
default: break;
}
} else {
//其他，使用堂食的退款配置（必须先判断收银单，因为收银单的类型也是堂食，只是orderClient不一样
switch (data.getStatus()) {
// 未接单
case 1: orderRefund = config.getTakeOrderRefund(); break;
//已接单
case 3: orderRefund = config.getReceiptOrderRefund(); break;
//制作完成
case 31: orderRefund = config.getCompleteMakeOrderRefund(); break;
// 订单完成
case 5: orderRefund = config.getOrderRefund(); break;
default: break;
}
}
return isFinishRefund;
return ALLOW_REFUND.equals(orderRefund);
}
/**
......
ordercenter-sdk/src/main/java/com/freemud/application/sdk/api/ordercenter/entities/v1/OrderBeanV1.java
......@@ -38,6 +38,11 @@ public class OrderBeanV1 {
* 是否是父订单
*/
private Boolean isParent;
/**
* 第三方交易流水 （微信单号）
*/
private String thirdPartTradeNo;
/**
* 操作人
*/
......
ordercenter-sdk/src/main/java/com/freemud/application/sdk/api/ordercenter/enums/OrderClientType.java
......@@ -41,6 +41,7 @@ public enum OrderClientType {
ASSISTANT(29, "非码小助手"),
SHERPAS(30,"食派士"),
PARKING(99 , "农工商停车"),
CASHIER(36, "收银买单"),
;
......
ordercenter-sdk/src/main/java/com/freemud/application/sdk/api/ordercenter/request/OrderDeleteReq.java
......@@ -17,6 +17,8 @@ import lombok.Data;
@Data
public class OrderDeleteReq {
private String partnerId;
private String orderCode;
//操作人
......
ordercenter-sdk/src/main/java/com/freemud/application/sdk/api/ordercenter/request/create/CreateOrderRequest.java
......@@ -12,6 +12,7 @@
*/
package com.freemud.application.sdk.api.ordercenter.request.create;
import com.freemud.application.sdk.api.ordercenter.enums.OrderClientType;
import com.freemud.application.sdk.api.ordercenter.request.BaseRequest;
import com.freemud.application.sdk.api.ordercenter.request.OrderExtendedReq;
import lombok.Data;
......@@ -59,17 +60,28 @@ public class CreateOrderRequest extends BaseRequest {
*/
private Boolean isParent;
//默认为待支付状态，如需要则设置对应的值
/**
* 默认为待支付状态，如需要则设置对应的值订单状态 1:待支付 2:下单 3:已接单 4:制作完成(待发货) 5:配送中 6:已完 7:已关闭
*/
private Integer orderState;
//正常情况下不要设置值，此字段仅在做订单同步时使用 订单子状态
private Integer orderSubState;
//订单类型 店内自取实时-1常规堂食 店内自取预约-2预约堂食 店外快递实时-3常规外卖，
// 店外快递预约-4预约外卖 店外自取实时-5常规自取 店外自取预约-6预约自取
/**
* 订单类型
* 店内自取实时-1常规堂食
* 店内自取预约-2预约堂食
* 店外快递实时-3常规外卖，
* 店外快递预约-4预约外卖
* 店外自取实时-5常规自取
* 店外自取预约-6预约自取
*/
private Integer orderType;
//正常情况下不要设置值，此字段仅在做订单同步时使用
/**
* 正常情况下不要设置值，此字段仅在做订单同步时使用 支付状态 1:未支付 2:已支付 3:已退款 4:部分退款
*/
private Integer payState;
//1:线上支付 2:线下支付
......@@ -90,16 +102,23 @@ public class CreateOrderRequest extends BaseRequest {
//订单原始金额，单位分
private Long originalAmount;
//用户在界面上看到的支付金额
/**
* 用户在界面上看到的支付金额
*/
private Long settlementAmount;
//实际支付现金金额，扣除支付自生优惠，单位分
/**
* 实际支付现金金额，扣除支付自生优惠，单位分
*/
private Long actualPayAmount;
//是否需要开发票
private Boolean needInvoice;
//下单渠道必填，根据此字段的值判断是自营或第三方，来走不同的状态机 详细见 orderClientType枚举
/**
* 下单渠道必填，根据此字段的值判断是自营或第三方，来走不同的状态机 详细见 orderClientType枚举
* @see OrderClientType
*/
private Integer orderClient;
//商户自己生成的订单号
......@@ -171,9 +190,8 @@ public class CreateOrderRequest extends BaseRequest {
//打印次数
private Integer printNum;
//订单业务类型 1:普通订单 2:虚拟订单
/**
* 1: ; 2:
* 默认不填=1，订单业务类型 1:普通订单 2:虚拟订单 3:会员订单 4:积分商城订单 5:储值卡订单 6:卖券订单 97 农工商停车自助积分订单 98:农工商停车手工录单 99:农工商停车订单
*/
private Integer bizType;
......
shopping-cart-application-service/src/main/java/cn/freemud/adapter/ActivityAdapter.java
......@@ -309,7 +309,7 @@ public class ActivityAdapter {
// Long sendDiscountAmount = 0L;//赠送和换购商品优惠不算在内
// Long sendRealAmount = 0L;//赠送和换购商品实付不算在内
if(discountResult!=null){
boolean newCalculation = CollectionUtils.isNotEmpty(discountResult.getCouponSharedExclusive());
boolean newCalculation = discountResult.getV3Promotion();
if(newCalculation){
couponAvailableCartInfo.setNewCalculation(newCalculation);
buildOrderDiscount(couponAvailableCartInfo,discountResult.getDiscounts(),discountResult.getCouponSharedExclusive());
......
shopping-cart-application-service/src/main/java/cn/freemud/adapter/ShoppingCartConvertAdapter.java
......@@ -154,6 +154,39 @@ public class ShoppingCartConvertAdapter {
} else if (cartGoods.isWeightType()) {
cartGoodsDetailDto.setProductType(ProductType.WEIGHT_PRODUCT.getCode());
}
//套餐商品券
if (CollectionUtils.isNotEmpty(cartGoods.getProductComboList()) && GoodsTypeEnum.COUPON_GOODS.getGoodsType().equals(cartGoods.getGoodsType())) {
cartGoodsDetailDto.setProductType(ProductType.SETMEAL.getCode());
List<ShoppingCartGoodsDto.CartGoodsDetailDto> comboProducts = new ArrayList<>(0);
for (CartGoods.ComboxGoods comboxGoods : cartGoods.getProductComboList()) {
ShoppingCartGoodsDto.CartGoodsDetailDto comboProduct = new ShoppingCartGoodsDto.CartGoodsDetailDto();
comboProduct.setTaxId(cartGoods.getTaxId());
comboProduct.setTax(cartGoods.getTax());
comboProduct.setSpuId(comboxGoods.getSpuId());
comboProduct.setSpuName(comboxGoods.getSpuName());
comboProduct.setSkuId(comboxGoods.getGoodsId());
// 设置原始商品类型
comboProduct.setOriginalProductType(comboxGoods.getOriginalProductType());
comboProduct.setSkuName(StringUtils.isEmpty(comboxGoods.getSkuName()) ? comboxGoods.getSpuName() : comboxGoods.getSkuName());
comboProduct.setOriginalPrice(comboxGoods.getOriginalPrice());
comboProduct.setPicture(comboxGoods.getPic());
int qty = comboxGoods.getQty() * cartGoods.getQty();
comboProduct.setQty(qty);
comboProduct.setProductType(comboxGoods.isWeightType() ? ProductType.WEIGHT_PRODUCT.getCode() : ProductType.SETMEAL.getCode());
comboProduct.setParentProductId(cartGoods.getGoodsId());
comboProduct.setIsFixedProduct(true);
comboProduct.setStockLimit(cartGoods.isStockLimit());
comboProduct.setCustomerCode(comboxGoods.getCustomerCode());
comboProduct.setWeight(comboxGoods.getWeight());
comboProduct.setUnit(comboxGoods.getUnit());
List<ShoppingCartGoodsDto.CartGoodsDetailDto.CartGoodsExtra> cartGoodsExtras = BeanUtil.convertBeans(comboxGoods.getExtra(), ShoppingCartGoodsDto.CartGoodsDetailDto.CartGoodsExtra::new);
comboProduct.setExtraList(cartGoodsExtras);
comboProduct.setSpecialExtra(comboxGoods.getSpecialExtra());
comboProducts.add(comboProduct);
}
cartGoodsDetailDto.setComboProducts(comboProducts);
}
//小料
if (CollectionUtils.isNotEmpty(cartGoods.getProductMaterialList())) {
List<ShoppingCartGoodsDto.CartGoodsDetailDto.MaterialGoods> materialList = new ArrayList<>(0);
......@@ -799,7 +832,6 @@ public class ShoppingCartConvertAdapter {
newOrigOriginalPrice += cartGoods.getProductComboList().stream().mapToLong(t -> t.getOriginalAmount()).sum();
}
newOrigOriginalPrice += cartGoods.getProductGroupList().stream().mapToLong(t -> t.getOriginalAmount()).sum();
} else {
newOrigOriginalPrice = isSkuProduct ? skuProduct.getFinalPrice() : spuProduct.getFinalPrice();
}
......
shopping-cart-application-service/src/main/java/cn/freemud/demo/adapter/service/DistributeAdapter.java
......@@ -109,15 +109,15 @@ public class DistributeAdapter {
Map<String, List<String>> spqIdToCartUuid = discountResult == null ? new HashMap<>() : discountResult.getSpqIdToCartUuidMap();
if (MapUtils.isNotEmpty(validCouponMap) && MapUtils.isNotEmpty(spqIdToCartUuid) && discountResult != null){
List<String> activityCodeList = discountResult.getDiscounts().stream().map(p -> p.getActivityCode()).collect(Collectors.toList());
for (String spqId : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(spqId);
for (String couponCode : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(couponCode);
if (!activityCodeList.contains(sqpInfo.getCouponCode())){ // 表示商品券不够启用金额
List<String> uuidList = spqIdToCartUuid.get(sqpInfo.getCouponCode());
if (CollectionUtils.isNotEmpty(uuidList)){
List<CartGoods> newCartList = cartGoodsList.stream().filter(p -> !uuidList.contains(p.getCartGoodsUid())).collect(Collectors.toList());
assortmentSdkService.setShoppingCart(bo.getPartnerId(), bo.getShopId(), bo.getUserId(), newCartList, null, null, this.shoppingCartBaseService,null);
cartGoodsList = newCartList;
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(spqId);
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(couponCode);
commonSetMessageBO.setChanged(true);
commonSetMessageBO.setToastMsg("当前购物车金额低于【" + checkSpqInfoResponseDto.getCouponName() + "】优惠券起用金额门槛，券已自动移除购物车");
}
......
shopping-cart-application-service/src/main/java/cn/freemud/demo/service/impl/AbstractAddGoodsService.java
......@@ -234,7 +234,7 @@ public abstract class AbstractAddGoodsService implements AddGoodsService {
String couponCode = CommonUtils.getCouponCode(baseRequestBO.getCouponCode(), spuId);
cartGoods.setAddCartTime(System.currentTimeMillis());
cartGoods.setSpuId(couponCode);
// cartGoods.setSpuId(couponCode);
cartGoods.setSkuId(StringUtils.isEmpty(spqBO.getSkuId()) ? spqBO.getSpuId() : spqBO.getSkuId());
cartGoods.setOriginalPrice(0L);
cartGoods.setOriginalAmount(0L);
......
shopping-cart-application-service/src/main/java/cn/freemud/demo/service/impl/AbstractApportionService.java
......@@ -445,11 +445,11 @@ public class AbstractApportionService implements GetShoppingCartGoodsApportionSe
for (CartGoods product : cartGoodsList) {
//循环购物车商品券
if (CommonUtils.isProductCoupon(product.getCouponCode(), product.getCartGoodsUid())) {
String spqId = product.getCartGoodsUid().substring(CommonsConstant.COUPON_PREFIX.length());
String couponCode = product.getCouponCode();
// 计算优惠信息时，已将券校验过，放在map中
Map<String, CheckSpqInfoResponseDto> validCouponMap = discountResult == null ? new HashMap<>() : discountResult.getValidCouponMap();
if (MapUtils.isNotEmpty(validCouponMap)) {
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(spqId);
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(couponCode);
if (checkSpqInfoResponseDto != null) {
product.setOriginalPrice(checkSpqInfoResponseDto.getPrice());
product.setSpuId(checkSpqInfoResponseDto.getSpuId());
......
shopping-cart-application-service/src/main/java/cn/freemud/demo/service/impl/DistributeServiceImpl.java
......@@ -52,8 +52,9 @@ public class DistributeServiceImpl implements DistributeService {
originalAmount = 0L;amount = 0L;packageAmount = 0L;
if (CommonUtils.isProductCoupon(cartGoods.getCouponCode(), cartGoods.getCartGoodsUid())){
Map<String, CheckSpqInfoResponseDto> validCouponMap = discountResult.getValidCouponMap();
if (validCouponMap != null && validCouponMap.get(cartGoods.getSpuId()) != null){
cartGoods.setSpuId(validCouponMap.get(cartGoods.getSpuId()).getSpuId());
if (validCouponMap != null && validCouponMap.get(cartGoods.getCouponCode()) != null){
//商品spuId
cartGoods.setSpuId(validCouponMap.get(cartGoods.getCouponCode()).getSpuId());
}
}
......
shopping-cart-application-service/src/main/java/cn/freemud/demo/service/impl/PlatformApportionService.java
......@@ -164,11 +164,11 @@ public class PlatformApportionService extends AbstractApportionService {
//循环购物车商品券
for (CartGoods cartGoods : cartGoodsList) {
if (cartGoods.getCartGoodsUid().startsWith(CommonsConstant.COUPON_PREFIX)) {
String spqId = cartGoods.getCartGoodsUid().substring(CommonsConstant.COUPON_PREFIX.length());
String couponCode = cartGoods.getCouponCode();
// 计算优惠信息时，已将券校验过，放在map中
Map<String, CheckSpqInfoResponseDto> validCouponMap = discountResult == null ? new HashMap<>() : discountResult.getValidCouponMap();
if (MapUtils.isNotEmpty(validCouponMap)) {
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(spqId);
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(couponCode);
if (checkSpqInfoResponseDto != null) {
cartGoods.setOriginalPrice(checkSpqInfoResponseDto.getPrice());
cartGoods.setSpuId(checkSpqInfoResponseDto.getSpuId());
......
shopping-cart-application-service/src/main/java/cn/freemud/entities/dto/calculate/CalculationDiscountResult.java
......@@ -105,4 +105,7 @@ public class CalculationDiscountResult {
*/
private Set<ActivityTypeSharedExclusive> couponSharedExclusive;
//是否是v3版本算价
private Boolean v3Promotion = false;
}
shopping-cart-application-service/src/main/java/cn/freemud/service/ShoppingCartNewService.java
......@@ -194,7 +194,7 @@ public interface ShoppingCartNewService {
cartGoods.setGoodsType(GoodsTypeEnum.COUPON_GOODS.getGoodsType());
// 商品券Id
String spqId = spuId.substring(CommonsConstant.COUPON_PREFIX.length());
cartGoods.setSpuId(spqId);
// cartGoods.setSpuId(spqId);
cartGoods.setSkuId(spuId2);
cartGoods.setOriginalPrice(0L);
cartGoods.setOriginalAmount(0L);
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/AssortmentSdkService.java
......@@ -491,6 +491,9 @@ public class AssortmentSdkService {
productIds.add(Long.parseLong(checkSpqInfoResponseDto.getSkuId()));
couponProductDto.setType(checkSpqInfoResponseDto.getCouponType());
String spuId2 = checkSpqInfoResponseDto.getSkuId();
//商品spuid赋值
addCartGoods.setSpuId(checkSpqInfoResponseDto.getSpuId());
addCartGoods.setSkuId(checkSpqInfoResponseDto.getSkuId());
// TODO: 21-10-20 套餐商品券，商品信息赋值
if(StringUtils.isNotEmpty(couponCode) && CollectionUtils.isNotEmpty(addCartGoods.getProductComboList())){
addCartGoods.setSpuId(goodsId);
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/CouponPromotionService.java
......@@ -126,15 +126,15 @@ public class CouponPromotionService implements IPromotionService {
Map<String, List<String>> spqIdToCartUuid = calculationDiscountResult == null ? new HashMap<>() : calculationDiscountResult.getSpqIdToCartUuid();
if (MapUtils.isNotEmpty(validCouponMap) && MapUtils.isNotEmpty(spqIdToCartUuid) && calculationDiscountResult != null){
List<String> activityCodeList = calculationDiscountResult.getCouponDiscounts().stream().map(p -> p.getCouponCode()).collect(Collectors.toList());
for (String spqId : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(spqId);
for (String couponCode : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(couponCode);
if (!activityCodeList.contains(sqpInfo.getCouponCode())){ // 表示商品券不够启用金额
List<String> uuidList = spqIdToCartUuid.get(sqpInfo.getCouponCode());
if (CollectionUtils.isNotEmpty(uuidList)){
List<CartGoods> newCartList = cartGoodsList.stream().filter(p -> !uuidList.contains(p.getCartGoodsUid())).collect(Collectors.toList());
assortmentSdkService.setShoppingCart(activityQueryDto.getPartnerId(), activityQueryDto.getStoreId(), userLoginInfoDto.getMemberId(), newCartList, null, null, this.shoppingCartBaseService,activityQueryDto.getBizType());
cartGoodsList = newCartList;
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(spqId);
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(couponCode);
shoppingCartGoodsResponseVo.setChanged(true);
shoppingCartGoodsResponseVo.setToastMsg("当前购物车金额低于【" + checkSpqInfoResponseDto.getCouponName() + "】优惠券起用金额门槛，券已自动移除购物车");
}
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/ProductServiceImpl.java
......@@ -262,6 +262,7 @@ public class ProductServiceImpl implements ProductService {
*/
private boolean checkProductOrderWay(List<CartGoods> cartGoodsList, Map<String, GetCouponDetailResponseDto.Details> detailsMap, Map<String, Boolean> couponOrderWayMap) {
boolean orderWayFlag = false;
// TODO: 21-11-5 判断券商品待删除
List<CartGoods> cartGoodsByProduct = cartGoodsList.stream()
.filter(cartGoods -> cartGoods.getCartGoodsUid().startsWith(CommonsConstant.COUPON_PREFIX))
.collect(Collectors.toList());
......@@ -271,7 +272,7 @@ public class ProductServiceImpl implements ProductService {
.collect(Collectors.toList());
}
for (CartGoods cartGoods : cartGoodsByProduct) {
GetCouponDetailResponseDto.Details detail = detailsMap.get(cartGoods.getSpuId());
GetCouponDetailResponseDto.Details detail = detailsMap.get(cartGoods.getCouponCode());
String activeCode = detail != null ? detail.getActiveCode() : "";
if (couponOrderWayMap == null || couponOrderWayMap.isEmpty() || !couponOrderWayMap.get(activeCode)) {
orderWayFlag = true;
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/ShoppingCartNewServiceImpl.java
......@@ -1543,10 +1543,11 @@ public class ShoppingCartNewServiceImpl implements ShoppingCartNewService {
cartGoods.setSpuName(checkSpqInfoResponseDto.getCouponName());
}
cartGoods.setStockLimit(checkSpqInfoResponseDto.isStockLimit());
if (GoodsTypeEnum.BUY_M_SEND_N_COUPON.getGoodsType().equals(cartGoods.getGoodsType())) {
cartGoods.setName(checkSpqInfoResponseDto.getSkuName());
cartGoods.setSpuName(checkSpqInfoResponseDto.getSpuName());
}
//逻辑同 viewProductName
// if (GoodsTypeEnum.BUY_M_SEND_N_COUPON.getGoodsType().equals(cartGoods.getGoodsType())) {
// cartGoods.setName(checkSpqInfoResponseDto.getSkuName());
// cartGoods.setSpuName(checkSpqInfoResponseDto.getSpuName());
// }
//添加请求的优惠券信息 买M赠N券，不重复加促销券集合字段
String finalCouponCode = couponCode;
List<ActivityCalculationDiscountRequestDto.CalculationDiscountCoupon> collect = coupons.stream().filter(calculationDiscountCoupon -> Objects.equals(calculationDiscountCoupon.getCode(), finalCouponCode)).collect(toList());
......@@ -2162,18 +2163,15 @@ public class ShoppingCartNewServiceImpl implements ShoppingCartNewService {
} else {
cartGoods.setGoodsType(GoodsTypeEnum.COUPON_GOODS.getGoodsType());
}
if (StringUtils.isBlank(addShoppingCartGoodsRequestVo.getCouponCode())) { //老商品券
//老商品券
if (StringUtils.isBlank(addShoppingCartGoodsRequestVo.getCouponCode())) {
cartGoods.setCartGoodsUid(spuId);
} else {
cartGoods.setCouponCode(couponCode);
}
// 商品券Id
String spqId = spuId.substring(CommonsConstant.COUPON_PREFIX.length());
cartGoods.setSpuId(spqId);
cartGoods.setCouponCode(couponCode);
if (CollectionUtils.isNotEmpty(allCartGoodsList)) {
if (Objects.equals(CouponTypeEnum.TYPE_0.getCode(), couponProductDto.getType())
|| Objects.equals(CouponTypeEnum.TYPE_4.getCode(), couponProductDto.getType())) {
int sum = allCartGoodsList.stream().filter(p -> p.getSpuId().equals(spqId)).mapToInt(CartGoods::getQty).sum();
int sum = allCartGoodsList.stream().filter(p -> Objects.equals(p.getCouponCode(),couponCode)).mapToInt(CartGoods::getQty).sum();
//今日可用次数判断
if (sum + cartGoods.getQty() > todayAvailableTimes) {
throw new ServiceException(ResponseResult.SHOPPING_CART_GOODS_COUPON_CAN_NOT_USE);
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/calculate/CalculationCommonService.java
......@@ -190,7 +190,7 @@ public class CalculationCommonService {
}
choice.setAmount(mt.getRealAmount().longValue());
}
originPrice += choice.getFinalPrice() * choice.getQty()*cartGoods.getQty();
originPrice += choice.getFinalPrice() * choice.getQty();
}
cartGoods.setAmount(cartGoods.getAmount() + amount);
}
......
shopping-cart-application-service/src/main/java/cn/freemud/service/impl/calculate/promotion/CouponSharingService.java
......@@ -115,15 +115,15 @@ public class CouponSharingService {
Map<String, List<String>> spqIdToCartUuid = calculationDiscountResult == null ? new HashMap<>() : calculationDiscountResult.getSpqIdToCartUuid();
if (MapUtils.isNotEmpty(validCouponMap) && MapUtils.isNotEmpty(spqIdToCartUuid) && calculationDiscountResult != null){
List<String> activityCodeList = calculationDiscountResult.getDiscounts().stream().map(p -> p.getActivityCode()).collect(Collectors.toList());
for (String spqId : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(spqId);
for (String couponCode : validCouponMap.keySet()) {
CheckSpqInfoResponseDto sqpInfo = validCouponMap.get(couponCode);
if (!activityCodeList.contains(sqpInfo.getCouponCode())){ // 表示商品券不够启用金额
List<String> uuidList = spqIdToCartUuid.get(sqpInfo.getCouponCode());
if (CollectionUtils.isNotEmpty(uuidList)){
List<CartGoods> newCartList = cartGoodsList.stream().filter(p -> !uuidList.contains(p.getCartGoodsUid())).collect(Collectors.toList());
assortmentSdkService.setShoppingCart(partnerId, storeId, userId, newCartList, null, null, this.shoppingCartBaseService,bizType);
cartGoodsList = newCartList;
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(spqId);
CheckSpqInfoResponseDto checkSpqInfoResponseDto = validCouponMap.get(couponCode);
shoppingCartGoodsResponseVo.setChanged(true);
shoppingCartGoodsResponseVo.setToastMsg("当前购物车金额低于【" + checkSpqInfoResponseDto.getCouponName() + "】优惠券起用金额门槛，券已自动移除购物车");
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment