backend/java-mall
6
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

配送费调试日志添加

Browse Source
This commit is contained in:
Jack 2026-01-14 16:55:21 +08:00
parent 2bfe7c48dc
commit 0bd5e40487
5 changed files with 171 additions and 316 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
mall-shop/src/main/java/com/suisung/mall/shop/order/service/impl/ShopOrderInfoServiceImpl.java
View File

@ -1047,13 +1047,16 @@ public class ShopOrderInfoServiceImpl extends BaseServiceImpl<ShopOrderInfoMappe
Pair<String, String> storeBizTimeRange = null;
// 如果storeId不为空，则尝试获取店铺信息
if (StrUtil.isNotBlank(storeIds)) {
// 根据一个或多个店铺id获取有效店铺的有效营业时间段
List<Pair<String, String>> storeBizTimeRangesList = selectMulStoreBizTimeRanges(storeIds);
if (!CollUtil.isEmpty(storeBizTimeRangesList)) {
// 获取多个店铺的营业时间段的一个交集
storeBizTimeRange = DateTimeUtils.findTimeInterSection(storeBizTimeRangesList);
}
if (StrUtil.isBlank(storeIds)) {
logger.info("[生成预约参数] 缺少店铺Id参数");
return Collections.emptyList();
}
// 根据一个或多个店铺id获取有效店铺的有效营业时间段
List<Pair<String, String>> storeBizTimeRangesList = selectMulStoreBizTimeRanges(storeIds);
if (!CollUtil.isEmpty(storeBizTimeRangesList)) {
// 获取多个店铺的营业时间段的一个交集
storeBizTimeRange = DateTimeUtils.findTimeInterSection(storeBizTimeRangesList);
}
if (storeBizTimeRange == null

54
mall-shop/src/main/java/com/suisung/mall/shop/order/service/impl/ShopOrderReturnServiceImpl.java
View File

@ -253,15 +253,15 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
public List<Map<String, Object>> statisticCount(Date end, int days) {
Integer store_id = Convert.toInt(getCurrentUser().getStore_id());
if (ObjectUtil.isNotNull(store_id)) {
List<Map<String, Object>> mapList= shopOrderReturnMapper.statisticCountSeller(end, days, store_id);
if(null==mapList){
mapList=new ArrayList<>();
List<Map<String, Object>> mapList = shopOrderReturnMapper.statisticCountSeller(end, days, store_id);
if (null == mapList) {
mapList = new ArrayList<>();
}
return mapList;
}
List<Map<String, Object>> statisticList=shopOrderReturnMapper.statisticCount(end, days);
if(null==statisticList){
statisticList=new ArrayList<>();
List<Map<String, Object>> statisticList = shopOrderReturnMapper.statisticCount(end, days);
if (null == statisticList) {
statisticList = new ArrayList<>();
}
return statisticList;
}
@ -1980,16 +1980,16 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
throw new ApiException(I18nUtil._("订单信息不存在！"));
}
// 取消订单,更改订单的状态为已取消
shopOrderBaseService.cancel(order_id, info_row, false);
logger.info("订单已取消：{}", order_id);
// 当前订单状态
Integer order_state_id = info_row.getOrder_state_id();
// 订单不是禁止退货（能退货）的情况下
if (order_state_id != null && !isOrderDenyReturn(order_id)) {
logger.info("处理运费和打包费事宜：{}", order_id);
// 取消订单,更改订单的状态为已取消
shopOrderBaseService.cancel(order_id, info_row, false);
logger.info("订单已取消：{}", order_id);
logger.info("处理运费和打包费逻辑：{}", order_id);
ShopOrderData order_data_row = shopOrderDataService.get(order_id);
if (order_data_row != null) {
@ -2001,7 +2001,7 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
order_data_row.getPacking_fee().compareTo(BigDecimal.ZERO) > 0) {
additionalFees = additionalFees.add(order_data_row.getPacking_fee());
feeTypes.add("打包费");
logger.debug("添加打包费: {}，订单ID: {}", order_data_row.getPacking_fee(), order_id);
logger.info("添加打包费: {}，订单ID: {}", order_data_row.getPacking_fee(), order_id);
}
// 处理配送费
@ -2009,9 +2009,11 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
order_data_row.getOrder_shipping_fee().compareTo(BigDecimal.ZERO) > 0) {
additionalFees = additionalFees.add(order_data_row.getOrder_shipping_fee());
feeTypes.add("配送费");
logger.debug("添加配送费: {}，订单ID: {}", order_data_row.getOrder_shipping_fee(), order_id);
logger.info("添加配送费: {}，订单ID: {}", order_data_row.getOrder_shipping_fee(), order_id);
}
logger.info("处理运费和打包费结果：{}, 金额：{}", order_id, additionalFees);
// 更新退款金额和说明
if (additionalFees.compareTo(BigDecimal.ZERO) > 0) {
BigDecimal newRefundAmount = return_row.getReturn_refund_amount().add(additionalFees);
@ -2031,7 +2033,7 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
logger.error("更新退货单退款金额失败！退货单ID: {}", return_row.getReturn_id());
throw new ApiException(ResultCode.FAILED);
}
logger.debug("成功更新退款金额，新增费用: {}，总退款金额: {}，订单ID: {}",
logger.info("成功更新退款金额，新增费用: {}，总退款金额: {}，订单ID: {}",
additionalFees, newRefundAmount, order_id);
}
} else {
@ -2631,7 +2633,7 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
public boolean isOrderDenyReturn(String orderId) {
// 参数校验
if (StrUtil.isBlank(orderId)) {
log.debug("[订单是否禁止退货] 订单ID为空，禁止退货，orderId: {}", orderId);
log.warn("[订单是否禁止退货] 订单ID为空，禁止退货，orderId: {}", orderId);
return true;
}
@ -2639,25 +2641,25 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
// 获取订单信息
ShopOrderInfo shopOrderInfo = shopOrderInfoService.get(orderId);
if (shopOrderInfo == null) {
log.debug("[订单是否禁止退货] 订单信息不存在，禁止退货，orderId: {}", orderId);
log.warn("[订单是否禁止退货] 订单信息不存在，禁止退货，orderId: {}", orderId);
return true;
}
// 检查订单状态是否已收货或已完成
Integer orderStateId = shopOrderInfo.getOrder_state_id();
int orderStateId = shopOrderInfo.getOrder_state_id();
if (CheckUtil.isEmpty(orderStateId)) {
log.debug("[订单是否禁止退货] 订单状态为空，禁止退货，orderId: {}", orderId);
log.warn("[订单是否禁止退货] 订单状态为空，禁止退货，orderId: {}", orderId);
return true;
}
if (orderStateId.intValue() == StateCode.ORDER_STATE_CANCEL ||
orderStateId.intValue() == StateCode.ORDER_STATE_WAIT_PAY) {
log.debug("[订单是否禁止退货] 订单状态为已取消或未支付，禁止退货，orderId: {}, orderStateId: {}", orderId, orderStateId);
if (orderStateId == StateCode.ORDER_STATE_CANCEL ||
orderStateId == StateCode.ORDER_STATE_WAIT_PAY) {
log.warn("[订单是否禁止退货] 订单状态为已取消或未支付，禁止退货，orderId: {}, orderStateId: {}", orderId, orderStateId);
return true;
}
if (orderStateId.intValue() == StateCode.ORDER_STATE_RECEIVED ||
orderStateId.intValue() == StateCode.ORDER_STATE_FINISH) {
if (orderStateId == StateCode.ORDER_STATE_RECEIVED ||
orderStateId == StateCode.ORDER_STATE_FINISH) {
// 获取可提现时间戳
Long withdrawTime = shopOrderBaseService.getWithdrawTime();
@ -2665,7 +2667,7 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
// 如果订单成交时间早于可提现时间，说明已过退货期
if (orderDealTime != null && withdrawTime.compareTo(orderDealTime) > 0) {
log.debug("[订单是否禁止退货] 订单已超过退货期限，禁止退货，orderId: {}, orderDealTime: {}, withdrawTime: {}",
log.warn("[订单是否禁止退货] 订单已超过退货期限，禁止退货，orderId: {}, orderDealTime: {}, withdrawTime: {}",
orderId, orderDealTime, withdrawTime);
return true;
}
@ -2677,13 +2679,13 @@ public class ShopOrderReturnServiceImpl extends BaseServiceImpl<ShopOrderReturnM
boolean isLklProcessed = isLklSeparated && isLklDrawed;
if (isLklProcessed) {
log.debug("[订单是否禁止退货] 拉卡拉分账订单已提现，禁止退货，orderId: {}, separated: {}, drawed: {}",
log.warn("[订单是否禁止退货] 拉卡拉分账订单已提现，禁止退货，orderId: {}, separated: {}, drawed: {}",
orderId, isLklSeparated, isLklDrawed);
return true;
}
// 允许退货
log.debug("[订单是否禁止退货] 订单允许退货，orderId: {}", orderId);
log.warn("[订单是否禁止退货] 订单允许退货，orderId: {}", orderId);
return false;
} catch (Exception e) {

192
mall-shop/src/main/java/com/suisung/mall/shop/store/service/impl/ShopStoreSameCityTransportBaseServiceImpl.java
View File

@ -612,8 +612,12 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
// 2.如果能配送，再订单总重量，订单原价金额，订单折后金额，订单实付金额
// 3.根据两点经纬度，计算配送距离，结合订单总重量，计算基础运费。
// 4.查看是否有运费优惠设置，如果有，就直接从基础运费中扣除优惠运费，得出最终的订单配送费。
String tip = isPlatform ? "平台同城配送费" : "商家同城配送费";
logger.info("开始计算{}。", tip);
if (storeId == null || orderLongitude == null || orderLatitude == null || storeId <= 0) {
logger.error("同城配送费计算时，缺少必要参数。");
logger.error("{}计算时，缺少必要参数。", tip);
if (canThrow) {
throw new ApiException(I18nUtil._("同城配送缺少必要参数。"));
}
@ -622,9 +626,9 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
ShopStoreBase storeBase = shopStoreBaseService.get(storeId);
if (storeBase == null) {
logger.error("同城配送费计算时，缺少店铺基本信息。");
logger.error("{}计算时，缺少店铺基本信息。", tip);
if (canThrow) {
throw new ApiException(I18nUtil._("同城配送缺少店铺基本信息。"));
throw new ApiException(tip + I18nUtil._("缺少店铺基本信息。"));
}
return new SameCityDeliveryFeeRespDTO(false, false, BigDecimal.ZERO, BigDecimal.ZERO, BigDecimal.ZERO, "同城配送缺少店铺基本信息。");
}
@ -633,7 +637,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
String storeLng = storeBase.getStore_longitude();
String storeLat = storeBase.getStore_latitude();
if (StrUtil.isBlank(storeLng) || StrUtil.isBlank(storeLat)) {
logger.error("{}同城配送费计算：店铺经纬度为空", storeName);
logger.error("{}{}计算：店铺经纬度为空", storeName, tip);
if (canThrow) {
throw new ApiException(I18nUtil._("无法获取" + storeName + "的具体位置，请联系商家。"));
}
@ -642,7 +646,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
ShopStoreSameCityTransportBase transportBase = getShopStoreSameCityTransportBaseById(storeId, isPlatform ? CommonConstant.Enable : CommonConstant.Disable2);
if (transportBase == null) {
logger.error("{}同城配送费计算：无法获取基础运费设置记录。", storeName);
logger.error("{}{}计算：无法获取基础运费设置记录。", storeName, tip);
if (canThrow) {
throw new ApiException(I18nUtil._("商家尚未完成同城配送设置。"));
}
@ -666,7 +670,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
}
// 实际配送距离，单位米
Integer distance = distanceD.intValue();
logger.debug(storeName + "下单时，店铺与收货地址经纬度是{},{},{},{} 距离为{}米。", storeLng, storeLat, orderLongitude, orderLatitude, distance);
logger.warn(storeName + "下单时，店铺与收货地址经纬度是{},{},{},{} 距离为{}米。", storeLng, storeLat, orderLongitude, orderLatitude, distance);
// ### 基础配送费计算
BigDecimal deliveryBaseFee = Convert.toBigDecimal(transportBase.getDelivery_base_fee(), BigDecimal.ZERO);
@ -676,8 +680,8 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
// 通过配送范围和起送金额，决定使用哪个配送费优惠规则
// 获取运费配送范围和优惠信息
List<ShopStoreSameCityTransport> transportList = shopStoreSameCityTransportService.selectShopStoreSameCityTransportList(storeId);
// List<ShopStoreSameCityTransport> transportList = shopStoreSameCityTransportService.selectShopStoreSameCityTransportList(storeId);
List<ShopStoreSameCityTransport> transportList = shopStoreSameCityTransportService.selectShopStoreSameCityTransportListByTransportBaseId(transportBase.getTransport_base_id());
if (CollUtil.isEmpty(transportList)) {
// 没有配送范围和起配金额规则的时候，直接以基础配送费来配送
return new SameCityDeliveryFeeRespDTO(true, false, deliveryBaseFee, BigDecimal.ZERO, deliveryBaseFee, "");
@ -690,7 +694,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
for (ShopStoreSameCityTransport transport : transportList) {
DeliveryFeeResultDTO deliveryFeeResultDTO = new DeliveryFeeResultDTO();
deliveryFeeResultDTO.setId(transport.getTransport_id());
logger.debug(storeName + "下单时，配送范围/收货实际距离：{}/{}米。", transport.getMax_delivery_radius(), distance);
logger.warn(storeName + "下单时，配送范围/收货实际距离：{}/{}米。", transport.getMax_delivery_radius(), distance);
// 判断订单距离在不在配送范围内？
if (transport.getMax_delivery_radius() < distance) {
@ -767,8 +771,8 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
}
logger.debug(storeName + "下单时，根据商家运费设置规则减免{}元运费", reduceDeliveryFee);
logger.debug(storeName + "下单时，不符合规则的:\n {}\n符合规则的:{}", JSONUtil.toJsonStr(noPassed), JSONUtil.toJsonStr(passed));
logger.warn(storeName + "下单时，根据{}设置规则减免{}元运费", tip, reduceDeliveryFee);
logger.debug(storeName + "下单时，{}不符合规则的数据:\n {}\n符合规则的数据:{}", tip, JSONUtil.toJsonStr(noPassed), JSONUtil.toJsonStr(passed));
boolean canDelivery = true;
if (passed.size() == 0 && noPassed.size() > 0) {
// 没有一个满足起送距离和起送金额的规则订单
@ -827,7 +831,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
}
if (deliveryBaseFee != null && deliveryBaseFee.compareTo(BigDecimal.ZERO) > 0) {
logger.debug(storeName + "下单时，超出基础距离、重量的额外配送费：{}元。", deliveryBaseFee);
logger.warn(storeName + "下单时，{}超出基础距离、重量的额外配送费：{}元。", tip, deliveryBaseFee);
}
}
// #### 额外配送费计算完毕
@ -851,7 +855,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
public Integer computeSameCityInnerDeliveryFeeByOrderId(String orderId) {
// 参数校验
if (orderId == null || orderId.trim().isEmpty()) {
logger.warn("计算同城配送费失败：订单ID不能为空");
logger.warn("计算平台同城配送费失败：订单ID不能为空");
return 0;
}
@ -860,7 +864,7 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
// 检查返回结果是否为空
if (orderCacDeliveryFeeArgs == null) {
logger.warn("计算同城配送费失败：未能获取订单[{}]的配送费计算参数", orderId);
logger.warn("计算平台同城配送费失败：未能获取订单[{}]的配送费计算参数", orderId);
return 0;
}
@ -893,167 +897,13 @@ public class ShopStoreSameCityTransportBaseServiceImpl extends BaseServiceImpl<S
if (sameCityDeliveryFeeRespDTO == null
|| sameCityDeliveryFeeRespDTO.getDeliveryFee() == null
|| sameCityDeliveryFeeRespDTO.getDeliveryFee().compareTo(BigDecimal.ZERO) <= 0) {
logger.warn("计算平台同城配送费失败：配送费计算结果为空");
return 0;
}
return sameCityDeliveryFeeRespDTO.getDeliveryFee().multiply(new BigDecimal(100)).intValue();
logger.warn("计算平台同城配送费成功：{}", sameCityDeliveryFeeRespDTO);
// 参数校验
// if (storeId == null || orderLongitude == null || orderLatitude == null || storeId <= 0) {
// logger.warn("同城配送缺少必要参数，无法计算配送费。");
// return 0;
// }
//
// // 获取店铺基本信息
// ShopStoreBase storeBase = shopStoreBaseService.get(storeId);
// if (storeBase == null) {
// logger.warn("同城配送缺少店铺基本信息，无法计算配送费。");
// return 0;
// }
//
// String storeName = storeBase.getStore_name();
// String storeLng = storeBase.getStore_longitude();
// String storeLat = storeBase.getStore_latitude();
// if (StrUtil.isBlank(storeLng) || StrUtil.isBlank(storeLat)) {
// logger.warn("无法获取{}的具体位置，请联系商家。", storeName);
// return 0;
// }
//
// // 获取平台的基础运费设置记录
// ShopStoreSameCityTransportBase transportBase = getShopStoreSameCityTransportBaseById(Convert.toLong(storeId), CommonConstant.Enable);
// if (transportBase == null) {
// logger.warn("商家{}尚未完成同城配送设置，无法计算配送费。", storeName);
// return 0;
// }
//
// // 设置默认值
// if (transportBase.getDistance_base() == null) {
// transportBase.setDistance_base(0);
// }
// if (transportBase.getWeight_base() == null) {
// transportBase.setWeight_base(0);
// }
// if (transportBase.getDelivery_base_fee() == null) {
// transportBase.setDelivery_base_fee(BigDecimal.ZERO);
// }
//
// // 计算两点的距离(单位米)
// Double distanceD = PositionUtil.getDistance1(Convert.toDouble(storeLng), Convert.toDouble(storeLat), Convert.toDouble(orderLongitude), Convert.toDouble(orderLatitude));
// Integer distance = (distanceD != null) ? distanceD.intValue() : 0;
//
// // 基础配送费计算
// BigDecimal deliveryBaseFee = Convert.toBigDecimal(transportBase.getDelivery_base_fee(), BigDecimal.ZERO);
//
// // 获取运费配送范围信息
// List<ShopStoreSameCityTransport> transportList = shopStoreSameCityTransportService.selectShopStoreSameCityTransportList(Convert.toLong(storeId));
//
// if (CollUtil.isEmpty(transportList)) {
// // 没有配送范围规则的时候，直接以基础配送费来配送
// return deliveryBaseFee.multiply(BigDecimal.valueOf(100)).intValue();
// }
//
// // 判断配送范围和起送金额条件
// String canNotDeliveryReason = "";
// boolean canDelivery = false;
//
// // 优先处理距离和金额都满足的规则
// for (ShopStoreSameCityTransport transport : transportList) {
// // 判断订单距离是否在配送范围内
// if (transport.getMax_delivery_radius() >= distance) {
// // 距离在配送范围内，判断金额是否符合起配金额额度
// boolean moneyPassed = false;
// if (CommonConstant.Delivery_Amount_Comput_Type_Original.equals(transport.getMin_delivery_amount_type())) {
// moneyPassed = orderProductAmount != null && transport.getMin_delivery_amount().compareTo(orderProductAmount) <= 0;
// } else if (CommonConstant.Delivery_Amount_Comput_Type_Discounted.equals(transport.getMin_delivery_amount_type())) {
// moneyPassed = orderDiscountAmount != null && transport.getMin_delivery_amount().compareTo(orderDiscountAmount) <= 0;
// } else if (CommonConstant.Delivery_Amount_Comput_Type_Payment.equals(transport.getMin_delivery_amount_type())) {
// moneyPassed = orderPayAmount != null && transport.getMin_delivery_amount().compareTo(orderPayAmount) <= 0;
// }
//
// // 距离和金额都满足条件
// if (moneyPassed) {
// canDelivery = true;
// break;
// }
// }
// }
//
// // 如果没有找到完全满足条件的规则，再详细检查找出失败原因
// if (!canDelivery) {
// for (ShopStoreSameCityTransport transport : transportList) {
// // 判断订单距离是否在配送范围内
// if (transport.getMax_delivery_radius() < distance) {
// // 记录距离不满足的原因
// canNotDeliveryReason = storeName + "的订单不在配送范围内，订单无法配送。";
// } else {
// // 距离在配送范围内，判断金额是否符合起配金额额度
// if (CommonConstant.Delivery_Amount_Comput_Type_Original.equals(transport.getMin_delivery_amount_type())) {
// if (orderProductAmount != null && transport.getMin_delivery_amount().compareTo(orderProductAmount) > 0) {
// BigDecimal diffMoney = transport.getMin_delivery_amount().subtract(orderProductAmount);
// canNotDeliveryReason = String.format("%s商品原价金额还差%.2f元，才满足配送条件，请检查订单。", storeName, diffMoney);
// } else {
// canDelivery = true;
// break;
// }
// } else if (CommonConstant.Delivery_Amount_Comput_Type_Discounted.equals(transport.getMin_delivery_amount_type())) {
// if (orderDiscountAmount != null && transport.getMin_delivery_amount().compareTo(orderDiscountAmount) > 0) {
// BigDecimal diffMoney = transport.getMin_delivery_amount().subtract(orderDiscountAmount);
// canNotDeliveryReason = String.format("%s订单折后金额还差%.2f元，才满足配送条件，请检查订单。", storeName, diffMoney);
// } else {
// canDelivery = true;
// break;
// }
// } else if (CommonConstant.Delivery_Amount_Comput_Type_Payment.equals(transport.getMin_delivery_amount_type())) {
// if (orderPayAmount != null && transport.getMin_delivery_amount().compareTo(orderPayAmount) > 0) {
// BigDecimal diffMoney = transport.getMin_delivery_amount().subtract(orderPayAmount);
// canNotDeliveryReason = String.format("%s订单应支付金额还差%.2f元，才满足配送条件，请检查订单。", storeName, diffMoney);
// } else {
// canDelivery = true;
// break;
// }
// }
// }
// }
// }
//
// // 如果仍然不能配送，记录日志并返回0
// if (!canDelivery) {
// logger.warn(canNotDeliveryReason.isEmpty() ? (storeName + "订单不在配送范围内或未达起送金额，请检查！") : canNotDeliveryReason);
// return 0;
// }
//
// // 额外配送费计算
// // 每增加一个距离累加运费
// if (transportBase.getDistance_increase_km() != null && transportBase.getDistance_increase_fee() != null && distance > transportBase.getDistance_base() * 1000) {
// // 实际配送距离超出基础距离，单位km
// BigDecimal diffDistanceM = CommonUtil.DecimalRoundHalfUp(BigDecimal.valueOf(distance - transportBase.getDistance_base() * 1000).divide(BigDecimal.valueOf(1000)));
// // 倍数
// BigDecimal times = BigDecimal.ZERO;
// if (transportBase.getDistance_increase_km() > 0 && diffDistanceM.intValue() > transportBase.getDistance_increase_km()) {
// // 末尾非零进位，比如：2.1将是3， 2.0将是2，2.001将是3
// times = NumberUtil.div(diffDistanceM, transportBase.getDistance_increase_km()).setScale(0, RoundingMode.UP);
// }
//
// // 超过基础运费距离后，累加上运费
// deliveryBaseFee = deliveryBaseFee.add(transportBase.getDistance_increase_fee().multiply(times));
// }
//
// // 每增加一个重量累加运费（重量暂时忽略,配置的时候设置0）
// if (transportBase.getWeight_increase_kg() != null && transportBase.getWeight_increase_fee() != null && orderWeightGram != null && orderWeightGram > transportBase.getWeight_base() * 1000) {
// // 实际配送重量超出基础重量，单位kg
// BigDecimal diffWeightKg = CommonUtil.DecimalRoundHalfUp(BigDecimal.valueOf(orderWeightGram - transportBase.getWeight_base() * 1000).divide(BigDecimal.valueOf(1000)));
// // 倍数
// BigDecimal times = BigDecimal.ZERO;
// if (transportBase.getWeight_increase_kg() > 0 && diffWeightKg.intValue() > transportBase.getWeight_increase_kg()) {
// // 末尾非零进位，比如：2.1将是3， 2.0将是2，2.001将是3
// times = NumberUtil.div(diffWeightKg, transportBase.getWeight_increase_kg()).setScale(0, RoundingMode.UP);
// }
//
// deliveryBaseFee = deliveryBaseFee.add(transportBase.getWeight_increase_fee().multiply(times));
// }
//
// // 返回单位为分的配送费
// return deliveryBaseFee.multiply(BigDecimal.valueOf(100)).intValue();
return sameCityDeliveryFeeRespDTO.getDeliveryFee().multiply(new BigDecimal(100)).intValue();
}

16
mall-shop/src/main/java/com/suisung/mall/shop/store/service/impl/ShopStoreSameCityTransportServiceImpl.java
View File

@ -78,19 +78,15 @@ public class ShopStoreSameCityTransportServiceImpl extends BaseServiceImpl<ShopS
return Collections.emptyList();
}
QueryWrapper<ShopStoreSameCityTransport> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("transport_base_id", transportBaseId);
queryWrapper.eq("status", CommonConstant.Enable);
queryWrapper.orderByAsc("transport_id");
LambdaQueryWrapper<ShopStoreSameCityTransport> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(ShopStoreSameCityTransport::getTransport_base_id, transportBaseId)
.eq(ShopStoreSameCityTransport::getStatus, CommonConstant.Enable)
.orderByAsc(ShopStoreSameCityTransport::getTransport_id);
List<ShopStoreSameCityTransport> shopStoreSameCityTransportList = list(queryWrapper);
if (CollectionUtil.isEmpty(shopStoreSameCityTransportList)) {
shopStoreSameCityTransportList = Collections.emptyList();
}
return shopStoreSameCityTransportList;
return list(queryWrapper);
}
/**
* 根据同城配送基础配置自增 Id 获取同城配送扩展设置列表
*

208
mall-shop/src/main/java/com/suisung/mall/shop/user/service/impl/ShopUserCartServiceImpl.java
View File

@ -58,7 +58,6 @@ import com.suisung.mall.shop.user.mapper.ShopUserCartMapper;
import com.suisung.mall.shop.user.service.ShopUserCartService;
import com.suisung.mall.shop.user.service.ShopUserDeliveryAddressService;
import com.suisung.mall.shop.user.service.ShopUserVoucherService;
import io.swagger.models.auth.In;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
@ -435,16 +434,16 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
}
//购物车控制活动的商品数量 todo
if(null!=activity_id&&0!=activity_id){
data= checkActivity(activity_id,activity_item_id,user_id,data,item_id);
}else {
if (null != activity_id && 0 != activity_id) {
data = checkActivity(activity_id, activity_item_id, user_id, data, item_id);
} else {
data.put("activity_id", activity_id);
data.put("activity_item_id", activity_item_id);
}
data.put("item_id", item_id);
data.put("cart_quantity", cart_quantity >= 0 ? Math.max(1, cart_quantity) : Math.min(-1, cart_quantity)); // 购买商品数量
data.put("cart_type", cart_type);
// data.put("activity_id", activity_id);
// data.put("activity_id", activity_id);
//data.put("activity_item_id", activity_item_id);
data.put("cart_file", cart_file);
data.put("chain_id", chain_id);
@ -648,13 +647,13 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
// 直接点击购买，数据检测
if (StrUtil.isNotBlank(cartId)) {
List<String> itemInfoList = StrUtil.split(cartId, ",");
if(0!=activityId){
Map data=new HashMap();
String itemIdStr= itemInfoList.get(0);
if (0 != activityId) {
Map data = new HashMap();
String itemIdStr = itemInfoList.get(0);
long[] itemData = StrUtil.splitToLong(itemIdStr, "|");
if(itemData[1]>0){
data= checkActivity(activityId,0L,currentUserId,data,itemData[0]);
activityId= Convert.toInt(data.get("activity_id"));
if (itemData[1] > 0) {
data = checkActivity(activityId, 0L, currentUserId, data, itemData[0]);
activityId = Convert.toInt(data.get("activity_id"));
}
}
// 购物车行项目列表
@ -1302,74 +1301,74 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
@Override
@Transactional
public Map getListDivideActivity(QueryWrapper<ShopUserCart> queryWrapper, Integer page, Integer rows) {
List<ShopUserCart> cart_rows =null;
if(null!=page&&null!=rows){
Page<ShopUserCart> userCartPage =lists(queryWrapper,page,rows);
cart_rows =userCartPage.getRecords();
}else {
cart_rows = find(queryWrapper);
List<ShopUserCart> cart_rows = null;
if (null != page && null != rows) {
Page<ShopUserCart> userCartPage = lists(queryWrapper, page, rows);
cart_rows = userCartPage.getRecords();
} else {
cart_rows = find(queryWrapper);
}
QueryWrapper<ShopStoreActivityBase> shopStoreActivityBaseQueryWrapper=new QueryWrapper<>();
List<Integer> activityIdList=cart_rows.stream().map(ShopUserCart::getActivity_id).filter(activityId -> activityId !=0).collect(Collectors.toList());
if(!activityIdList.isEmpty()){//把折扣的活动分开，进入shopItem时就会分开处理
shopStoreActivityBaseQueryWrapper.in("activity_id",activityIdList);
List<ShopStoreActivityBase> shopStoreActivityBases= shopStoreActivityBaseService.list(shopStoreActivityBaseQueryWrapper);
Map<Integer,ShopStoreActivityBase> shopStoreActivityBaseHashMap=new HashMap<>();
QueryWrapper<ShopStoreActivityBase> shopStoreActivityBaseQueryWrapper = new QueryWrapper<>();
List<Integer> activityIdList = cart_rows.stream().map(ShopUserCart::getActivity_id).filter(activityId -> activityId != 0).collect(Collectors.toList());
if (!activityIdList.isEmpty()) {//把折扣的活动分开，进入shopItem时就会分开处理
shopStoreActivityBaseQueryWrapper.in("activity_id", activityIdList);
List<ShopStoreActivityBase> shopStoreActivityBases = shopStoreActivityBaseService.list(shopStoreActivityBaseQueryWrapper);
Map<Integer, ShopStoreActivityBase> shopStoreActivityBaseHashMap = new HashMap<>();
shopStoreActivityBases.forEach(shopStoreActivityBase -> {
if(shopStoreActivityBase.getActivity_type_id()==StateCode.ACTIVITY_TYPE_LIMITED_DISCOUNT){
shopStoreActivityBaseHashMap.put(shopStoreActivityBase.getActivity_id(),shopStoreActivityBase);
if (shopStoreActivityBase.getActivity_type_id() == StateCode.ACTIVITY_TYPE_LIMITED_DISCOUNT) {
shopStoreActivityBaseHashMap.put(shopStoreActivityBase.getActivity_id(), shopStoreActivityBase);
}
});
List<ShopUserCart> newShopUserCartList=new ArrayList<>();
Map<Integer,Integer> activityCountLimitMap=new HashMap<>();
List<ShopUserCart> newShopUserCartList = new ArrayList<>();
Map<Integer, Integer> activityCountLimitMap = new HashMap<>();
cart_rows.forEach(shopUserCart -> {
if(null!=shopStoreActivityBaseHashMap.get(shopUserCart.getActivity_id())){
ShopStoreActivityBase shopStoreActivityBase=shopStoreActivityBaseHashMap.get(shopUserCart.getActivity_id());
if (null != shopStoreActivityBaseHashMap.get(shopUserCart.getActivity_id())) {
ShopStoreActivityBase shopStoreActivityBase = shopStoreActivityBaseHashMap.get(shopUserCart.getActivity_id());
//校验扣减逻辑
Integer orderLimit= shopStoreActivityBase.getOrder_limit();//每单限购
Integer cart_quantity= shopUserCart.getCart_quantity();//购物车数量
Integer activity_id= shopStoreActivityBase.getActivity_id();//活动id
if(orderLimit>0){//限购逻辑处理
if(orderLimit>=cart_quantity){//没有超限购
if(null!=activityCountLimitMap.get(activity_id)){//相同的活动有其他购买，可能需要分开
Integer countOrderLimit= activityCountLimitMap.get(activity_id);
int noDiscountLest=orderLimit-countOrderLimit-cart_quantity;
if(noDiscountLest>=0){//没有超出限购，直接加入统计，不用分开
Integer orderLimit = shopStoreActivityBase.getOrder_limit();//每单限购
Integer cart_quantity = shopUserCart.getCart_quantity();//购物车数量
Integer activity_id = shopStoreActivityBase.getActivity_id();//活动id
if (orderLimit > 0) {//限购逻辑处理
if (orderLimit >= cart_quantity) {//没有超限购
if (null != activityCountLimitMap.get(activity_id)) {//相同的活动有其他购买，可能需要分开
Integer countOrderLimit = activityCountLimitMap.get(activity_id);
int noDiscountLest = orderLimit - countOrderLimit - cart_quantity;
if (noDiscountLest >= 0) {//没有超出限购，直接加入统计，不用分开
newShopUserCartList.add(shopUserCart);
activityCountLimitMap.put(activity_id,(countOrderLimit+cart_quantity));
}else {//超出限购，需要分开
noDiscountLest= noDiscountLest*(-1);
ShopUserCart newUserCart=new ShopUserCart();
BeanUtils.copyProperties(shopUserCart,newUserCart);//新建一个分开的购物清单
activityCountLimitMap.put(activity_id, (countOrderLimit + cart_quantity));
} else {//超出限购，需要分开
noDiscountLest = noDiscountLest * (-1);
ShopUserCart newUserCart = new ShopUserCart();
BeanUtils.copyProperties(shopUserCart, newUserCart);//新建一个分开的购物清单
shopUserCart.setCart_quantity(orderLimit);//数量改变，旧的活动依旧
newShopUserCartList.add(newUserCart);
newUserCart.setCart_quantity(noDiscountLest);
newUserCart.setActivity_id(0);//新的购物清单无活动
newShopUserCartList.add(shopUserCart);
if(!activityCountLimitMap.containsKey(activity_id)){
activityCountLimitMap.put(activity_id,orderLimit);
if (!activityCountLimitMap.containsKey(activity_id)) {
activityCountLimitMap.put(activity_id, orderLimit);
}
}
}else {//相同的活动没有其他购买，不用分开
newShopUserCartList.add(shopUserCart);
activityCountLimitMap.put(activity_id,cart_quantity);
} else {//相同的活动没有其他购买，不用分开
newShopUserCartList.add(shopUserCart);
activityCountLimitMap.put(activity_id, cart_quantity);
}
}else {//超出限购范围了，直接分开
int noDiscountLest=cart_quantity-orderLimit;
ShopUserCart newUserCart=new ShopUserCart();
BeanUtils.copyProperties(shopUserCart,newUserCart);//新建一个分开的购物清单
} else {//超出限购范围了，直接分开
int noDiscountLest = cart_quantity - orderLimit;
ShopUserCart newUserCart = new ShopUserCart();
BeanUtils.copyProperties(shopUserCart, newUserCart);//新建一个分开的购物清单
shopUserCart.setCart_quantity(orderLimit);//数量改变，旧的活动依旧
newShopUserCartList.add(newUserCart);
newUserCart.setCart_quantity(noDiscountLest);
newUserCart.setActivity_id(0);//新的购物清单无活动
newShopUserCartList.add(shopUserCart);
if(!activityCountLimitMap.containsKey(activity_id)){
activityCountLimitMap.put(activity_id,orderLimit);
if (!activityCountLimitMap.containsKey(activity_id)) {
activityCountLimitMap.put(activity_id, orderLimit);
}
}
}
}else {
} else {
newShopUserCartList.add(shopUserCart);
}
});
@ -1882,13 +1881,13 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
// 修正价格策略影响
fixPricePolicy(productItemInStore, customerLevelId, userLevelId);
storeInfo.put("policy_discountrate", productItemInStore.get("policy_discountrate"));
if(productItemInStore.get("item_discount_quantity")!=null&&Convert.toInt(productItemInStore.get("item_discount_quantity"))>0){
BigDecimal item_unit_price=Convert.toBigDecimal(productItemInStore.get("item_unit_price"));
BigDecimal num=BigDecimal.valueOf(Convert.toInt(productItemInStore.get("num")));
BigDecimal oldSubTotal=NumberUtil.mul(item_unit_price, num);//原总价
BigDecimal subTotal=NumberUtil.sub(oldSubTotal,Convert.toBigDecimal(productItemInStore.get("item_discount_amount")));//最终价格=原总价-总优惠价
if (productItemInStore.get("item_discount_quantity") != null && Convert.toInt(productItemInStore.get("item_discount_quantity")) > 0) {
BigDecimal item_unit_price = Convert.toBigDecimal(productItemInStore.get("item_unit_price"));
BigDecimal num = BigDecimal.valueOf(Convert.toInt(productItemInStore.get("num")));
BigDecimal oldSubTotal = NumberUtil.mul(item_unit_price, num);//原总价
BigDecimal subTotal = NumberUtil.sub(oldSubTotal, Convert.toBigDecimal(productItemInStore.get("item_discount_amount")));//最终价格=原总价-总优惠价
storeTotalAmount = NumberUtil.add(subTotal, storeTotalAmount);
}else {
} else {
storeTotalAmount = NumberUtil.add(Convert.toBigDecimal(productItemInStore.get("subtotal")), storeTotalAmount);
}
@ -2788,6 +2787,7 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
// 同城配送运费检查和计算(只返回数据，不能配送不抛异常)
SameCityDeliveryFeeRespDTO sameCityDeliveryFeeResp = shopStoreSameCityTransportBaseService.computeSameCityTransportFee(storeId, orderLng, orderLat, 0, productMoneyOriginGoods, orderSelDiscountAmount, orderPaymentAmount, false, canThrow);
logger.info("计算商家同城配送运费成功：{}", sameCityDeliveryFeeResp);
// 是否能配送（在配送范围内）
Boolean canDelivery = sameCityDeliveryFeeResp.getCanDelivery();
@ -3291,37 +3291,39 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
logger.debug("店铺ID为{}，实体商品订单，收取打包费{}元", storeId, packingFee);
return packingFee;
}
/**
* 校验限购
*
* @param activity_id
* @return
*/
private Map checkActivity(Integer activity_id,Long activity_item_id,Integer user_id,Map data,Long item_id){
QueryWrapper<ShopStoreActivityBase> shopStoreActivityBaseQueryWrapper=new QueryWrapper<>();
private Map checkActivity(Integer activity_id, Long activity_item_id, Integer user_id, Map data, Long item_id) {
QueryWrapper<ShopStoreActivityBase> shopStoreActivityBaseQueryWrapper = new QueryWrapper<>();
shopStoreActivityBaseQueryWrapper.eq("activity_id", activity_id);
List<ShopStoreActivityBase> shopStoreActivityBases= shopStoreActivityBaseService.list(shopStoreActivityBaseQueryWrapper);
if(shopStoreActivityBases.isEmpty()){
List<ShopStoreActivityBase> shopStoreActivityBases = shopStoreActivityBaseService.list(shopStoreActivityBaseQueryWrapper);
if (shopStoreActivityBases.isEmpty()) {
throw new ApiException("活动不存在");
}
ShopStoreActivityBase shopStoreActivityBase=shopStoreActivityBases.get(0);
ShopStoreActivityBase shopStoreActivityBase = shopStoreActivityBases.get(0);
//店铺会员等级，店铺会员才能参加
boolean canTakePart=checkStoreMemberLever(user_id,shopStoreActivityBase);
if(!canTakePart){//不能参加活动
data.put("activity_id",0);
data.put("activity_item_id",0);
boolean canTakePart = checkStoreMemberLever(user_id, shopStoreActivityBase);
if (!canTakePart) {//不能参加活动
data.put("activity_id", 0);
data.put("activity_item_id", 0);
return data;
}
if(shopStoreActivityBase.getActivity_type_id()==StateCode.ACTIVITY_TYPE_LIMITED_DISCOUNT){//限时折扣才有这种规则
String is_new_person_shop=shopStoreActivityBase.getIs_new_person_shop();
if(DicEnum.YESORNO_1.getCode().equals(is_new_person_shop)){
Integer store_id=shopStoreActivityBase.getStore_id();
boolean isNewUser=checkoutNewPerson(user_id,store_id);
if(!isNewUser){//不能参加活动
data.put("activity_id",0);
data.put("activity_item_id",0);
if (shopStoreActivityBase.getActivity_type_id() == StateCode.ACTIVITY_TYPE_LIMITED_DISCOUNT) {//限时折扣才有这种规则
String is_new_person_shop = shopStoreActivityBase.getIs_new_person_shop();
if (DicEnum.YESORNO_1.getCode().equals(is_new_person_shop)) {
Integer store_id = shopStoreActivityBase.getStore_id();
boolean isNewUser = checkoutNewPerson(user_id, store_id);
if (!isNewUser) {//不能参加活动
data.put("activity_id", 0);
data.put("activity_item_id", 0);
return data;
// throw new ApiException("店铺新人才能购买");
// throw new ApiException("店铺新人才能购买");
}
// else {
// Integer person_limit=shopStoreActivityBase.getPerson_limit();//每人限购 每单限购不能大于每人限购
@ -3335,22 +3337,22 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
// return data;
// }
// }
}else {//如果不是新人活动，要考虑每人限购问题，就是每人参加活动的次数 todo 按店铺会员等级
Integer person_limit=shopStoreActivityBase.getPerson_limit();//每人限购 每单限购不能大于每人限购
QueryWrapper<ShopOrderItem> shopOrderItemQueryWrapper=new QueryWrapper<>();
} else {//如果不是新人活动，要考虑每人限购问题，就是每人参加活动的次数 todo 按店铺会员等级
Integer person_limit = shopStoreActivityBase.getPerson_limit();//每人限购 每单限购不能大于每人限购
QueryWrapper<ShopOrderItem> shopOrderItemQueryWrapper = new QueryWrapper<>();
shopOrderItemQueryWrapper.eq("activity_id", activity_id);
shopOrderItemQueryWrapper.eq("item_id", item_id);
List<ShopOrderItem> shopOrderItemList= shopOrderItemService.list(shopOrderItemQueryWrapper);//计算用户购买的商品
Integer person_limit_count=shopOrderItemList.stream().mapToInt(ShopOrderItem::getOrder_item_quantity).sum();
if(person_limit_count >= person_limit){//不能参加活动
data.put("activity_id",0);
data.put("activity_item_id",0);
List<ShopOrderItem> shopOrderItemList = shopOrderItemService.list(shopOrderItemQueryWrapper);//计算用户购买的商品
Integer person_limit_count = shopOrderItemList.stream().mapToInt(ShopOrderItem::getOrder_item_quantity).sum();
if (person_limit_count >= person_limit) {//不能参加活动
data.put("activity_id", 0);
data.put("activity_item_id", 0);
return data;
}
}
}
data.put("activity_id",activity_id);
data.put("activity_item_id",activity_item_id);
data.put("activity_id", activity_id);
data.put("activity_item_id", activity_item_id);
// Integer person_limit= shopStoreActivityBase.getPerson_limit();
// Integer order_limit=shopStoreActivityBase.getOrder_limit();
// data.put("person_limit",person_limit);
@ -3360,29 +3362,31 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
/**
* 检查是否为新用户
*
* @param user_id
*/
private boolean checkoutNewPerson(Integer user_id,Integer store_id){
boolean isNewUser=false;
QueryWrapper<ShopStoreMemberLevel> shopStoreMemberLevelQueryWrapper=new QueryWrapper();
shopStoreMemberLevelQueryWrapper.eq("user_id",user_id);
shopStoreMemberLevelQueryWrapper.eq("store_id",store_id);
shopStoreMemberLevelQueryWrapper.eq("",new BigDecimal("0.00"));
long count=shopStoreMemberLevelService.count(shopStoreMemberLevelQueryWrapper);
if(count>0){
isNewUser=true;
private boolean checkoutNewPerson(Integer user_id, Integer store_id) {
boolean isNewUser = false;
QueryWrapper<ShopStoreMemberLevel> shopStoreMemberLevelQueryWrapper = new QueryWrapper();
shopStoreMemberLevelQueryWrapper.eq("user_id", user_id);
shopStoreMemberLevelQueryWrapper.eq("store_id", store_id);
shopStoreMemberLevelQueryWrapper.eq("", new BigDecimal("0.00"));
long count = shopStoreMemberLevelService.count(shopStoreMemberLevelQueryWrapper);
if (count > 0) {
isNewUser = true;
}
return isNewUser;
return isNewUser;
}
/**
* 检查等级是否可以参加
*
* @param user_id
*/
public boolean checkStoreMemberLever(Integer user_id,ShopStoreActivityBase shopStoreActivityBase){
public boolean checkStoreMemberLever(Integer user_id, ShopStoreActivityBase shopStoreActivityBase) {
String activity_use_levels = shopStoreActivityBase.getActivity_use_level();
if(StringUtils.isNotEmpty(activity_use_levels)) {
if (StringUtils.isNotEmpty(activity_use_levels)) {
QueryWrapper<ShopStoreMemberLevel> shopStoreMemberLevelQueryWrapper = new QueryWrapper<>();
shopStoreMemberLevelQueryWrapper.eq("user_id", user_id);
shopStoreMemberLevelQueryWrapper.eq("store_id", shopStoreActivityBase.getStore_id());
@ -3391,7 +3395,7 @@ public class ShopUserCartServiceImpl extends BaseServiceImpl<ShopUserCartMapper,
ShopStoreMemberLevel shopStoreMember = shopStoreMemberLevelList.get(0);
Integer userLeveId = shopStoreMember.getUserLevelId();
List<Integer> activity_use_level = Convert.toList(Integer.class, activity_use_levels);
if(!activity_use_level.contains(userLeveId)){
if (!activity_use_level.contains(userLeveId)) {
return false;
}
}