282 lines
13 KiB
Java
282 lines
13 KiB
Java
package com.syzb.business.service;
|
|
|
|
import cn.hutool.core.collection.CollUtil;
|
|
import cn.hutool.core.util.StrUtil;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
|
import com.google.common.collect.HashBasedTable;
|
|
import com.google.common.collect.Table;
|
|
import com.syzb.business.entity.AppOrder;
|
|
import com.syzb.business.mapper.AppOrderMapper;
|
|
import com.syzb.business.vo.order.OrderStatCollect;
|
|
import com.syzb.common.constant.IsOrNot;
|
|
import com.syzb.common.constant.ProductType;
|
|
import com.syzb.video.vo.statistic.ProductSaleVO;
|
|
import org.springframework.stereotype.Service;
|
|
|
|
import javax.annotation.Resource;
|
|
import javax.validation.constraints.NotNull;
|
|
import java.math.BigDecimal;
|
|
import java.util.*;
|
|
import java.util.stream.Collectors;
|
|
|
|
@Service
|
|
public class OrderQueryService {
|
|
|
|
@Resource
|
|
private AppOrderMapper appOrderMapper;
|
|
|
|
public OrderStatCollect queryOrderCollect(Integer productId, ProductType productType) {
|
|
return queryOrderCollect(productId, null, productType);
|
|
}
|
|
|
|
public OrderStatCollect queryOrderCollect(Collection<Integer> productIds, ProductType productType) {
|
|
return queryOrderCollect(null, productIds, productType);
|
|
}
|
|
|
|
/**
|
|
* 查询订单支付状态Map
|
|
*
|
|
* @param productId 产品ID
|
|
* @param productType 产品类型
|
|
* @return 订单支付状态Map key: 是否支付 value: 订单统计
|
|
*/
|
|
public OrderStatCollect queryOrderCollect(Integer productId, Collection<Integer> productIds, @NotNull ProductType productType) {
|
|
// 计算订单汇总
|
|
QueryWrapper<AppOrder> orderWrapper = Wrappers.<AppOrder>query()
|
|
// 用sale_user_id保存订单数量
|
|
.select("pay_status",
|
|
"ifnull(count(1), 0) as sale_user_id",
|
|
"IFNULL(SUM(original_price), 0) AS original_price",
|
|
"IFNULL(SUM(received_amount), 0) AS received_amount",
|
|
"IFNULL(COUNT(distinct user_id), 0) AS product_type")
|
|
.eq(productId != null, "product_id", productId)
|
|
.in(CollUtil.isNotEmpty(productIds), "product_id", productIds)
|
|
.eq("product_type", productType.value)
|
|
.isNotNull("pay_status")
|
|
.groupBy("pay_status WITH ROLLUP");
|
|
List<AppOrder> orders = appOrderMapper.selectList(orderWrapper);
|
|
|
|
OrderStatCollect result = new OrderStatCollect();
|
|
for (AppOrder order : orders) {
|
|
if (IsOrNot.IS.value.equals(order.getPayStatus())) {
|
|
result.setPayCount(order.getSaleUserId());
|
|
result.setPayAmount(order.getReceivedAmount());
|
|
result.setPayUserCount(order.getProductType());
|
|
} else if (IsOrNot.NOT.value.equals(order.getPayStatus())) {
|
|
result.setUnPayCount(order.getSaleUserId());
|
|
result.setUnPayAmount(order.getOriginalPrice());
|
|
result.setUnPayUserCount(order.getProductType());
|
|
} else if (order.getPayStatus() == null) {
|
|
result.setCount(order.getSaleUserId());
|
|
result.setOrderAmount(order.getOriginalPrice());
|
|
result.setUserCount(order.getProductType());
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* 查询某位营销人员产生的订阅用户ID集合
|
|
*
|
|
* @param saleUserId 营销人员ID
|
|
* @return 订阅用户ID集合
|
|
*/
|
|
public Set<String> querySubUserBySaleUser(Integer saleUserId) {
|
|
QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
|
|
.select("distinct user_id")
|
|
.eq(saleUserId != null && saleUserId != 0, "sale_user_id", saleUserId);
|
|
List<AppOrder> orders = appOrderMapper.selectList(wrapper);
|
|
return orders.stream().map(order -> order.getUserId()).collect(Collectors.toSet());
|
|
}
|
|
|
|
/**
|
|
* 查询某些用户的已支付订单统计
|
|
*
|
|
* @param userIds 用户ID集合
|
|
* @return 用户订单统计Map key: 用户ID value: 订单统计
|
|
*/
|
|
public Map<String, OrderStatCollect> queryUserPayOrderCollect(Set<String> userIds) {
|
|
if (CollUtil.isEmpty(userIds)) {
|
|
return Collections.emptyMap();
|
|
}
|
|
QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
|
|
.select("user_name",
|
|
"IFNULL(SUM(original_price), 0) AS original_price",
|
|
"IFNULL(SUM(received_amount), 0) AS received_amount",
|
|
"IFNULL(COUNT(1), 0) AS sale_user_id")
|
|
.in("user_name", userIds)
|
|
.eq("pay_status", IsOrNot.IS.value)
|
|
.groupBy("user_name");
|
|
List<AppOrder> orders = appOrderMapper.selectList(wrapper);
|
|
return orders.stream().collect(Collectors.toMap(order -> order.getUserId(), order -> {
|
|
OrderStatCollect orderStatCollect = new OrderStatCollect();
|
|
orderStatCollect.setOrderAmount(order.getOriginalPrice());
|
|
orderStatCollect.setPayAmount(order.getReceivedAmount());
|
|
orderStatCollect.setPayCount(order.getSaleUserId());
|
|
return orderStatCollect;
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* 查询某位用户各产品的订阅订单
|
|
*
|
|
* @param userId 用户ID
|
|
* @return Table row:产品类型 column:产品ID value:订单列表
|
|
*/
|
|
public Table<Integer, Integer, List<AppOrder>> queryUserSignProductOrders(String userId) {
|
|
Table<Integer, Integer, List<AppOrder>> table = HashBasedTable.create();
|
|
if (StrUtil.isEmpty(userId)) {
|
|
return table;
|
|
}
|
|
QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
|
|
.eq("user_name", userId)
|
|
.eq("pay_status", IsOrNot.IS.value);
|
|
List<AppOrder> orders = appOrderMapper.selectList(wrapper);
|
|
for (AppOrder order : orders) {
|
|
Integer productType = order.getProductType();
|
|
Integer productId = order.getProductId();
|
|
List<AppOrder> list = table.get(productType, productId);
|
|
if (list == null) {
|
|
list = CollUtil.newArrayList();
|
|
table.put(productType, productId, list);
|
|
}
|
|
list.add(order);
|
|
}
|
|
return table;
|
|
}
|
|
|
|
/**
|
|
* 查询某些产品的订单周期汇总数据
|
|
*
|
|
* @param productType 产品类型
|
|
* @param productIds 产品ID集合
|
|
* @param format 周期格式
|
|
* @return 订单周期汇总Map key:周期 value:订单统计
|
|
*/
|
|
public Map<String, OrderStatCollect> queryCycleOrderCollect(@NotNull ProductType productType, Set<Integer> productIds, CycleFormat format) {
|
|
QueryWrapper<AppOrder> totalWrapper = Wrappers.<AppOrder>query()
|
|
.select("DATE_FORMAT(order_time, '" + format + "') AS product_name",
|
|
"IFNULL(SUM(original_price), 0) AS original_price",
|
|
"IFNULL(COUNT(1), 0) AS sale_user_id")
|
|
.in(CollUtil.isNotEmpty(productIds), "product_id", productIds)
|
|
.eq(productType != null, "product_type", productType.value)
|
|
.groupBy("DATE_FORMAT(order_time, '" + format.format + "')")
|
|
// 必须用last替代orderBy不然MyBatis会移除格式里面的空格
|
|
.last("ORDER BY DATE_FORMAT(order_time, '" + format.format + "')");
|
|
List<AppOrder> totalOrders = appOrderMapper.selectList(totalWrapper);
|
|
|
|
QueryWrapper<AppOrder> paidWrapper = Wrappers.<AppOrder>query()
|
|
.select("DATE_FORMAT(order_time, '" + format.format + "') AS product_name",
|
|
"IFNULL(SUM(received_amount), 0) AS received_amount",
|
|
"IFNULL(COUNT(1), 0) AS sale_user_id")
|
|
.in(CollUtil.isNotEmpty(productIds), "product_id", productIds)
|
|
.eq(productType != null, "product_type", productType.value)
|
|
.eq("pay_status", IsOrNot.IS.value)
|
|
.groupBy("DATE_FORMAT(order_time, '" + format.format + "')")
|
|
// 必须用last替代orderBy不然MyBatis会移除格式里面的空格
|
|
.last("ORDER BY DATE_FORMAT(order_time, '" + format.format + "')");
|
|
List<AppOrder> paidOrders = appOrderMapper.selectList(paidWrapper);
|
|
Map<Integer, AppOrder> paidOrderMap = paidOrders.stream().collect(Collectors.toMap(AppOrder::getOrderId, order -> order));
|
|
return totalOrders.stream().collect(Collectors.toMap(AppOrder::getProductName, order -> {
|
|
OrderStatCollect orderStatCollect = new OrderStatCollect();
|
|
orderStatCollect.setCount(order.getSaleUserId());
|
|
orderStatCollect.setOrderAmount(order.getOriginalPrice());
|
|
AppOrder paidOrder = paidOrderMap.get(order.getOrderId());
|
|
if (paidOrder != null) {
|
|
orderStatCollect.setPayCount(paidOrder.getSaleUserId());
|
|
orderStatCollect.setPayAmount(paidOrder.getReceivedAmount());
|
|
orderStatCollect.setUnPayCount(order.getSaleUserId() - paidOrder.getSaleUserId());
|
|
} else {
|
|
orderStatCollect.setPayCount(0);
|
|
orderStatCollect.setPayAmount(BigDecimal.ZERO);
|
|
orderStatCollect.setUnPayCount(order.getSaleUserId());
|
|
}
|
|
return orderStatCollect;
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* 查询某些产品的订单统计数据
|
|
*/
|
|
public Map<Integer, OrderStatCollect> queryProductOrderCollect(ProductType productType, Set<Integer> productIds) {
|
|
QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
|
|
.select("product_id",
|
|
"IFNULL(SUM(original_price), 0) AS original_price",
|
|
"IFNULL(SUM(received_amount), 0) AS received_amount",
|
|
"IFNULL(COUNT(1), 0) AS sale_user_id")
|
|
.in(CollUtil.isNotEmpty(productIds), "product_id", productIds)
|
|
.eq(productType != null, "product_type", productType.value)
|
|
.eq("pay_status", IsOrNot.IS.value)
|
|
.groupBy("product_id");
|
|
List<AppOrder> orders = appOrderMapper.selectList(wrapper);
|
|
return orders.stream().collect(Collectors.toMap(AppOrder::getProductId, order -> {
|
|
OrderStatCollect orderStatCollect = new OrderStatCollect();
|
|
orderStatCollect.setCount(order.getSaleUserId());
|
|
orderStatCollect.setPayCount(order.getSaleUserId());
|
|
orderStatCollect.setOrderAmount(order.getOriginalPrice());
|
|
orderStatCollect.setPayAmount(order.getReceivedAmount());
|
|
return orderStatCollect;
|
|
}));
|
|
}
|
|
|
|
/**
|
|
* 查询直播间产品销量
|
|
*/
|
|
public List<ProductSaleVO> queryVideoLiveProductSale(Integer productId) {
|
|
QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
|
|
.select("product_id, product_name",
|
|
"IFNULL(SUM(received_amount), 0) AS received_amount",
|
|
"IFNULL(COUNT(1), 0) AS sale_user_id")
|
|
.eq("product_id", productId)
|
|
.eq("product_type", ProductType.VIDEO_SINGLE.value)
|
|
.eq("pay_status", IsOrNot.IS.value)
|
|
.groupBy("product_id", "product_name")
|
|
.orderByDesc("IFNULL(COUNT(1), 0)");
|
|
List<AppOrder> orders = appOrderMapper.selectList(wrapper);
|
|
return orders.stream().map(order -> new ProductSaleVO(order.getProductName(), order.getSaleUserId(), order.getReceivedAmount())).collect(Collectors.toList());
|
|
}
|
|
|
|
/**
|
|
* 查询某产品的订单用户订阅的产品名称
|
|
*
|
|
* @param productId 产品ID
|
|
* @param payStatus 支付状态
|
|
* @return 用户订阅的产品名称Map key: 用户名 value: 产品名称列表
|
|
*/
|
|
public Map<String, List<String>> calUserOrderName(Integer productId, Integer payStatus) {
|
|
LambdaQueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>lambdaQuery()
|
|
.eq(AppOrder::getProductId, productId)
|
|
.isNotNull(IsOrNot.IS.value.equals(payStatus), AppOrder::getReceivedAmount);
|
|
List<AppOrder> orderList = appOrderMapper.selectList(wrapper);
|
|
return orderList.stream()
|
|
.collect(Collectors.groupingBy(order -> order.getUserId(),
|
|
Collectors.mapping(AppOrder::getProductName, Collectors.toList())));
|
|
}
|
|
|
|
/**
|
|
* 订单周期格式
|
|
* 符合MySQL DATE_FORMAT函数格式
|
|
*/
|
|
public static class CycleFormat {
|
|
private final String format;
|
|
|
|
private CycleFormat(String format) {
|
|
this.format = format;
|
|
}
|
|
|
|
public static final CycleFormat YEAR = new CycleFormat("%Y");
|
|
public static final CycleFormat MONTH = new CycleFormat("%Y-%m");
|
|
public static final CycleFormat DAY = new CycleFormat("%Y-%m-%d");
|
|
public static final CycleFormat HOUR = new CycleFormat("%Y-%m-%d %H");
|
|
public static final CycleFormat MINUTE = new CycleFormat("%Y-%m-%d %H:%i");
|
|
|
|
@Override
|
|
public String toString() {
|
|
return format;
|
|
}
|
|
}
|
|
|
|
}
|