package com.ruoyi.system.service.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.ruoyi.common.basic.PageInfo;
|
import com.ruoyi.common.constant.Constants;
|
import com.ruoyi.common.constant.OrderNumConstants;
|
import com.ruoyi.common.core.redis.RedisCache;
|
import com.ruoyi.common.exception.ServiceException;
|
import com.ruoyi.common.utils.CodeGenerateUtils;
|
import com.ruoyi.system.domain.*;
|
import com.ruoyi.system.dto.OrderMealGeneratorCountDTO;
|
import com.ruoyi.system.dto.OrderMealGeneratorDTO;
|
import com.ruoyi.system.dto.OrderSaleGeneratorDTO;
|
import com.ruoyi.system.mapper.TDataGeneratorMapper;
|
import com.ruoyi.system.query.*;
|
import com.ruoyi.system.service.*;
|
import com.ruoyi.system.vo.*;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Propagation;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.util.CollectionUtils;
|
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.time.LocalDate;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* <p>
|
* 营业数据生成 服务实现类
|
* </p>
|
*
|
* @author xiaochen
|
* @since 2024-08-27
|
*/
|
@Service
|
public class TDataGeneratorServiceImpl extends ServiceImpl<TDataGeneratorMapper, TDataGenerator> implements TDataGeneratorService {
|
|
@Autowired
|
private TBoardService boardService;
|
@Autowired
|
private TFoundationConfigService foundationConfigService;
|
@Autowired
|
private TGoodsService goodsService;
|
@Autowired
|
private TOrderMealService orderMealService;
|
@Autowired
|
private TOrderMealGoodsService orderMealGoodsService;
|
@Autowired
|
private TOrderSaleService orderSaleService;
|
@Autowired
|
private TOrderSaleGoodsService orderSaleGoodsService;
|
@Autowired
|
private TOrderStockService orderStockService;
|
@Autowired
|
private TOrderStockGoodsService orderStockGoodsService;
|
@Autowired
|
private TStockDataSetService stockDataSetService;
|
@Autowired
|
private TGoodsTypeService goodsTypeService;
|
@Autowired
|
private TShopService shopService;
|
@Autowired
|
private RedisCache redisCache;
|
|
@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
|
@Override
|
public void mealDataGenerator(OrderMealGeneratorDTO dto) {
|
// 存储数据生成数据
|
TDataGenerator dataGenerator = new TDataGenerator();
|
dataGenerator.setUserId(dto.getUserId());
|
dataGenerator.setUserName(dto.getNickName());
|
dataGenerator.setShopId(dto.getShopId());
|
dataGenerator.setStartTime(dto.getStartTime());
|
dataGenerator.setEndTime(dto.getEndTime());
|
dataGenerator.setMinMoney(dto.getMinMoney());
|
dataGenerator.setMaxMoney(dto.getMaxMoney());
|
dataGenerator.setStatus(2);
|
dataGenerator.setOrderType(1);
|
dataGenerator.setWeiXinPay(dto.getWeiXinProportion());
|
dataGenerator.setAliPay(dto.getAliProportion());
|
dataGenerator.setCardPay(dto.getCardProportion());
|
dataGenerator.setMoneyPay(dto.getMoneyProportion());
|
dataGenerator.setOtherPay(dto.getOtherProportion());
|
this.save(dataGenerator);
|
long start = System.currentTimeMillis();
|
// 查询所有的人数用餐标准
|
List<TFoundationConfigVO> foundationConfigs = foundationConfigService.getList();
|
// 查询所有桌子
|
List<TBoard> boards = boardService.list();
|
// 查询所有菜品
|
List<TGoods> goods = goodsService.list();
|
// 循环待生成订单列表，添加到集合中，批量插入
|
List<OrderMealGeneratorCountDTO> orderMealGeneratorCountDTOS = dto.getOrderMealGeneratorCountDTOS();
|
List<TOrderMeal> orderMeals = new ArrayList<>();
|
for (OrderMealGeneratorCountDTO orderMealGeneratorCountDTO : orderMealGeneratorCountDTOS) {
|
TBoard board = boards.stream().filter(e -> e.getId().equals(orderMealGeneratorCountDTO.getBoardId())).findFirst().get();
|
Integer orderCount = orderMealGeneratorCountDTO.getOrderCount();
|
// 查询当前桌的用餐人数
|
for (int i = 1; i <= orderCount; i++) {
|
int random = getRandom(board.getMinPerson(), board.getMaxPerson());
|
TOrderMeal orderMeal = new TOrderMeal();
|
orderMeal.setBoardId(board.getId());
|
orderMeal.setMealType(1);
|
orderMeal.setMealPerson(random);
|
orderMeal.setMealTime(orderMealGeneratorCountDTO.getTime());
|
orderMeal.setOrderNum(OrderNumConstants.MEAL + CodeGenerateUtils.generateVolumeSn());
|
orderMeal.setStatus(2);
|
List<TOrderMealGoods> orderMealGoods = new ArrayList<>();
|
// 获取当前桌的菜品
|
List<TFoundationConfigVO> foundationConfigVOS = foundationConfigs.stream().filter(e -> e.getMealCount().equals(random)).collect(Collectors.toList());
|
// 每种菜品分类需要几个菜的生成
|
foundationConfigVOS.forEach(e -> {
|
int random1 = getRandom(e.getMinCount(), e.getMaxCount());
|
List<TGoods> typeGoods = goods.stream().filter(m -> e.getTypeId().equals(m.getTypeId())).collect(Collectors.toList());
|
typeGoods = randomSelection(typeGoods, random1);
|
for (TGoods typeGood : typeGoods) {
|
int count = 0;
|
for (TOrderMealGoods good : orderMealGoods) {
|
if (good.getGoodsNum().equals(typeGood.getGoodsNum())) {
|
count+=1;
|
good.setGoodsCount(good.getGoodsCount() + 1);
|
break; // 找到后直接跳出循环
|
}
|
}
|
if (count==0) {
|
TOrderMealGoods tOrderMealGoods = new TOrderMealGoods();
|
tOrderMealGoods.setGoodsNum(typeGood.getGoodsNum());
|
tOrderMealGoods.setGoodsName(typeGood.getGoodsName());
|
tOrderMealGoods.setGoodsPicture(typeGood.getGoodsPicture());
|
tOrderMealGoods.setGoodsSalePrice(typeGood.getSalePrice());
|
tOrderMealGoods.setGoodsCount(1);
|
tOrderMealGoods.setTypeId(typeGood.getTypeId());
|
tOrderMealGoods.setGoodsId(typeGood.getId());
|
orderMealGoods.add(tOrderMealGoods);
|
}
|
}
|
});
|
orderMeal.setMealOrderGoods(orderMealGoods);
|
orderMeal.setOrderMoney(orderMealGoods.stream().map(TOrderMealGoods::getGoodsSalePrice).reduce(BigDecimal::add).get());
|
orderMeal.setPayMoney(orderMealGoods.stream().map(TOrderMealGoods::getGoodsSalePrice).reduce(BigDecimal::add).get());
|
orderMeals.add(orderMeal);
|
}
|
}
|
BigDecimal sumMoney = orderMeals.stream().map(TOrderMeal::getPayMoney).reduce(BigDecimal::add).get();
|
if(sumMoney.compareTo(dto.getMinMoney()) >= 0 || sumMoney.compareTo(dto.getMaxMoney()) <= 0){
|
int weiXin = getRandomPayType(orderMeals.size(), dto.getWeiXinProportion());
|
int ali = getRandomPayType(orderMeals.size(), dto.getAliProportion());
|
int card = getRandomPayType(orderMeals.size(), dto.getCardProportion());
|
int money = getRandomPayType(orderMeals.size(), dto.getMoneyProportion());
|
int other = getRandomPayType(orderMeals.size(), dto.getOtherProportion());
|
switch (orderMeals.size()-(weiXin+ali+card+money+other)){
|
case 1:
|
weiXin += 1;
|
break;
|
case 2:
|
weiXin += 1;
|
ali += 1;
|
break;
|
case 3:
|
weiXin += 1;
|
ali += 1;
|
card += 1;
|
break;
|
case 4:
|
weiXin += 1;
|
ali += 1;
|
card += 1;
|
money += 1;
|
break;
|
case 5:
|
weiXin += 1;
|
ali += 1;
|
card += 1;
|
money += 1;
|
other += 1;
|
break;
|
}
|
List<TOrderMeal> weiXinOrderMeals = orderMeals.subList(0, weiXin);
|
List<TOrderMeal> aliOrderMeals = orderMeals.subList(weiXin, weiXin+ali);
|
List<TOrderMeal> cardOrderMeals = orderMeals.subList(weiXin+ali, weiXin+ali+card);
|
List<TOrderMeal> moneyOrderMeals = orderMeals.subList(weiXin+ali+card, weiXin+ali+card+money);
|
List<TOrderMeal> otherOrderMeals = orderMeals.subList(weiXin+ali+card+money, weiXin+ali+card+money+other);
|
weiXinOrderMeals.forEach(e->e.setPayType(3));
|
aliOrderMeals.forEach(e->e.setPayType(2));
|
cardOrderMeals.forEach(e->e.setPayType(4));
|
moneyOrderMeals.forEach(e->e.setPayType(1));
|
otherOrderMeals.forEach(e->e.setPayType(5));
|
List<TOrderMeal> allOrderMeals = new ArrayList<>();
|
allOrderMeals.addAll(weiXinOrderMeals);
|
allOrderMeals.addAll(aliOrderMeals);
|
allOrderMeals.addAll(cardOrderMeals);
|
allOrderMeals.addAll(moneyOrderMeals);
|
allOrderMeals.addAll(otherOrderMeals);
|
allOrderMeals.forEach(e->{
|
e.setIsCover(0);
|
e.setShopId(dataGenerator.getShopId());
|
e.setGeneratorId(dataGenerator.getId());
|
});
|
|
// 判断是否进行了终止操作
|
if(redisCache.hasKey(OrderNumConstants.MEAL+"_"+dto.getShopId())){
|
redisCache.deleteObject(OrderNumConstants.MEAL+"_"+dto.getShopId());
|
return;
|
}
|
|
orderMealService.saveBatch(allOrderMeals);
|
|
for (TOrderMeal orderMeal : allOrderMeals) {
|
orderMeal.getMealOrderGoods().forEach(e->e.setOrderId(orderMeal.getId()));
|
}
|
List<TGoodsType> list = goodsTypeService.list();
|
List<TOrderMealGoods> collect = allOrderMeals.stream().map(TOrderMeal::getMealOrderGoods).flatMap(Collection::stream).collect(Collectors.toList());
|
collect.forEach(e->e.setTypeName(list.stream().filter(m->m.getId().equals(e.getTypeId())).findFirst().get().getTypeName()));
|
orderMealGoodsService.saveBatch(collect);
|
// 存储
|
long end = System.currentTimeMillis() - start;
|
System.err.println("相差时间========="+end);
|
}else {
|
throw new ServiceException("数据生成不在营业额范围内");
|
}
|
|
}
|
|
@Transactional(rollbackFor = Exception.class,propagation = Propagation.REQUIRED)
|
@Override
|
public void saleDataGenerator(OrderSaleGeneratorDTO dto) {
|
// 查询上一次的数据生成时间
|
TDataGenerator lastDataGenerator = this.getOne(new LambdaQueryWrapper<TDataGenerator>().eq(TDataGenerator::getShopId, dto.getShopId()).orderByDesc(TDataGenerator::getCreateTime).last("limit 1"));
|
if(Objects.nonNull(lastDataGenerator) && lastDataGenerator.getEndTime().isAfter(dto.getStartTime())){
|
throw new ServiceException("数据生成时间不能小于上次生成时间");
|
}
|
// 查询上次生成最后一次的时间 后续涛哥不用这个类，可以改成TOrderStock的最后一条数据
|
TStockDataSet stockDataSet = stockDataSetService.getOne(new LambdaQueryWrapper<TStockDataSet>()
|
.eq(TStockDataSet::getShopId, dto.getShopId())
|
.orderByDesc(TStockDataSet::getStockDate)
|
.last("limit 1"));
|
// 存储数据生成数据
|
TDataGenerator dataGenerator = new TDataGenerator();
|
dataGenerator.setUserId(dto.getUserId());
|
dataGenerator.setUserName(dto.getNickName());
|
dataGenerator.setShopId(dataGenerator.getShopId());
|
dataGenerator.setStartTime(dto.getStartTime());
|
dataGenerator.setEndTime(dto.getEndTime());
|
dataGenerator.setStatus(2);
|
dataGenerator.setShopId(dto.getShopId());
|
dataGenerator.setOrderType(2);
|
this.save(dataGenerator);
|
|
// 存储进货数据设置
|
List<TStockDataSet> stockDataSets = dto.getStockDataSets();
|
stockDataSets.forEach(e->e.setGeneratorId(dataGenerator.getId()));
|
stockDataSetService.saveBatch(stockDataSets);
|
|
// 添加销售订单数
|
List<TOrderSale> orderSales = dto.getOrderSales();
|
orderSales.forEach(e->{
|
e.setGeneratorId(dataGenerator.getId());
|
e.setOrderNum(OrderNumConstants.SALE + CodeGenerateUtils.generateVolumeSn());
|
});
|
List<TOrderSaleGoods> orderSaleGoods = orderSales.stream().map(TOrderSale::getOrderSaleGoods).flatMap(Collection::stream).collect(Collectors.toList());
|
|
// 生成进货数据
|
List<TOrderStock> stockList = new ArrayList<>();
|
stockDataSets.stream().sorted(Comparator.comparing(TStockDataSet::getStockDate));
|
for (int i = 0; i < stockDataSets.size(); i++) {
|
TStockDataSet start = stockDataSets.get(i);
|
LocalDate startTime = start.getStockDate();
|
if(i==stockDataSets.size()-1){
|
// 最后一次
|
LocalDate endTime = LocalDate.now();
|
List<Long> saleIds = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) <= 0).map(TOrderSale::getId).collect(Collectors.toList());
|
List<TOrderSaleGoods> orderSaleGoodsList = orderSaleGoods.stream().filter(e -> saleIds.contains(e.getOrderId())).collect(Collectors.toList());
|
// 根据商品新生成一条数据
|
TOrderStock orderStock = new TOrderStock();
|
orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
|
orderStock.setStockTime(startTime);
|
orderStock.setIsCover(0);
|
orderStock.setGeneratorId(dataGenerator.getId());
|
orderStock.setShopId(dto.getShopId());
|
|
Map<String, List<TOrderSaleGoods>> goodsList = orderSaleGoodsList.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
|
List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
|
goodsList.forEach((k,v)->{
|
TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
|
tOrderStockGoods.setGoodsName(k);
|
tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
|
tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
|
tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
|
tOrderStockGoods.setThisSalePrice(v.get(0).getThisSalePrice());
|
tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
|
tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
|
tOrderStockGoods.setStockCount(v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum());
|
orderStockGoods.add(tOrderStockGoods);
|
});
|
orderStock.setOrderStockGoods(orderStockGoods);
|
stockList.add(orderStock);
|
|
}else if(i==0 && Objects.nonNull(stockDataSet)){
|
// 第一次 第一次的进货时间为上一次的结束时间 开始时间为上一次的开始时间
|
LocalDate startTime1 = stockDataSet.getStockDate();
|
List<Long> saleIds = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) < 0).map(TOrderSale::getId).collect(Collectors.toList());
|
List<TOrderSaleGoods> orderSaleGoodsList = orderSaleGoods.stream().filter(e -> saleIds.contains(e.getOrderId())).collect(Collectors.toList());
|
// 查询上一次开始之后的订单数据
|
List<TOrderSale> orderSales1 = orderSaleService.list(new LambdaQueryWrapper<TOrderSale>().gt(TOrderSale::getOrderTime, startTime1));
|
List<Long> saleIds1 = orderSales1.stream().map(TOrderSale::getId).collect(Collectors.toList());
|
// 查询上一次的商品
|
List<TOrderSaleGoods> list = orderSaleGoodsService.list(new LambdaQueryWrapper<TOrderSaleGoods>().in(TOrderSaleGoods::getOrderId, saleIds1));
|
// 结合上次最后一次的数据
|
list.addAll(orderSaleGoodsList);
|
// 删除上一次的数据生成 新生成一条数据
|
TOrderStock orderStock = new TOrderStock();
|
orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
|
orderStock.setStockTime(startTime);
|
orderStock.setIsCover(0);
|
orderStock.setGeneratorId(dataGenerator.getId());
|
orderStock.setShopId(dto.getShopId());
|
|
Map<String, List<TOrderSaleGoods>> goodsList = list.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
|
List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
|
goodsList.forEach((k,v)->{
|
TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
|
tOrderStockGoods.setGoodsName(k);
|
tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
|
tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
|
tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
|
tOrderStockGoods.setThisSalePrice(v.get(0).getThisSalePrice());
|
tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
|
tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
|
tOrderStockGoods.setStockCount(v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum());
|
orderStockGoods.add(tOrderStockGoods);
|
});
|
orderStock.setOrderStockGoods(orderStockGoods);
|
stockList.add(orderStock);
|
|
// 处理第一次到下一次的数据
|
TStockDataSet end = stockDataSets.get(i + 1);
|
LocalDate endTime = end.getStockDate();
|
List<Long> saleIds2 = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) < 0).map(TOrderSale::getId).collect(Collectors.toList());
|
List<TOrderSaleGoods> orderSaleGoodsList2 = orderSaleGoods.stream().filter(e -> saleIds2.contains(e.getOrderId())).collect(Collectors.toList());
|
// 根据商品新生成一条数据
|
TOrderStock orderStock1 = new TOrderStock();
|
orderStock1.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
|
orderStock1.setStockTime(startTime);
|
orderStock1.setIsCover(0);
|
orderStock1.setGeneratorId(dataGenerator.getId());
|
orderStock1.setShopId(dto.getShopId());
|
|
Map<String, List<TOrderSaleGoods>> goodsList1 = orderSaleGoodsList2.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
|
List<TOrderStockGoods> orderStockGoods1 = new ArrayList<>();
|
goodsList1.forEach((k,v)->{
|
TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
|
tOrderStockGoods.setGoodsName(k);
|
tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
|
tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
|
tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
|
tOrderStockGoods.setThisSalePrice(v.get(0).getThisSalePrice());
|
tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
|
tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
|
tOrderStockGoods.setStockCount(v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum());
|
orderStockGoods1.add(tOrderStockGoods);
|
});
|
orderStock1.setOrderStockGoods(orderStockGoods1);
|
stockList.add(orderStock1);
|
|
}else {
|
TStockDataSet end = stockDataSets.get(i + 1);
|
LocalDate endTime = end.getStockDate();
|
List<Long> saleIds = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) >= 0 && e.getOrderTime().compareTo(endTime) < 0).map(TOrderSale::getId).collect(Collectors.toList());
|
List<TOrderSaleGoods> orderSaleGoodsList = orderSaleGoods.stream().filter(e -> saleIds.contains(e.getOrderId())).collect(Collectors.toList());
|
// 根据商品新生成一条数据
|
TOrderStock orderStock = new TOrderStock();
|
orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());
|
orderStock.setStockTime(startTime);
|
orderStock.setIsCover(0);
|
orderStock.setGeneratorId(dataGenerator.getId());
|
orderStock.setShopId(dto.getShopId());
|
|
Map<String, List<TOrderSaleGoods>> goodsList = orderSaleGoodsList.stream().collect(Collectors.groupingBy(TOrderSaleGoods::getGoodsName));
|
List<TOrderStockGoods> orderStockGoods = new ArrayList<>();
|
goodsList.forEach((k,v)->{
|
TOrderStockGoods tOrderStockGoods = new TOrderStockGoods();
|
tOrderStockGoods.setGoodsName(k);
|
tOrderStockGoods.setGoodsNum(v.get(0).getGoodsNum());
|
tOrderStockGoods.setCostPrice(v.get(0).getGoodsCostPrice());
|
tOrderStockGoods.setSalePrice(v.get(0).getGoodsSalePrice());
|
tOrderStockGoods.setThisSalePrice(v.get(0).getThisSalePrice());
|
tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
|
tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());
|
tOrderStockGoods.setStockCount(v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum());
|
orderStockGoods.add(tOrderStockGoods);
|
});
|
orderStock.setOrderStockGoods(orderStockGoods);
|
stockList.add(orderStock);
|
}
|
}
|
// 判断是否进行了终止操作
|
if(redisCache.hasKey(OrderNumConstants.STOCK+"_"+dto.getShopId())){
|
redisCache.deleteObject(OrderNumConstants.STOCK+"_"+dto.getShopId());
|
return;
|
}
|
// 删除上一次的数据生成
|
TOrderStock orderStock = orderStockService.getOne(Wrappers.lambdaQuery(TOrderStock.class)
|
.eq(TOrderStock::getShopId, dto.getShopId())
|
.orderByDesc(TOrderStock::getStockTime)
|
.last("LIMIT 1"));
|
if(Objects.nonNull(orderStock)){
|
orderStockService.removeById(orderStock);
|
}
|
orderSaleService.saveBatch(orderSales);
|
for (TOrderSale orderSale : orderSales) {
|
orderSale.getOrderSaleGoods().forEach(e->e.setOrderId(orderSale.getId()));
|
}
|
List<TGoodsType> list = goodsTypeService.list();
|
// orderSaleGoods.forEach(e->e.setTypeName(list.stream().filter(m->m.getId().equals(e.getTypeId())).findFirst().get().getTypeName()));
|
orderSaleGoods.forEach(e->{
|
e.setId(null);
|
});
|
orderSaleGoodsService.saveBatch(orderSaleGoods);
|
// 添加数据
|
stockList.forEach(e->e.setShopId(dataGenerator.getShopId()));
|
orderStockService.saveBatch(stockList);
|
for (TOrderStock stock : stockList) {
|
stock.getOrderStockGoods().forEach(e->e.setOrderId(stock.getId()));
|
}
|
List<TOrderStockGoods> orderStockGoods = stockList.stream().map(TOrderStock::getOrderStockGoods).flatMap(Collection::stream).collect(Collectors.toList());
|
orderStockGoodsService.saveBatch(orderStockGoods);
|
}
|
|
@Override
|
public PageInfo<TDataGeneratorVO> pageList(TDataGeneratorQuery query) {
|
PageInfo<TDataGeneratorVO> pageInfo = new PageInfo<>(query.getPageNum(), query.getPageSize());
|
List<TDataGeneratorVO> list = this.baseMapper.pageList(query,pageInfo);
|
List<Long> ids = list.stream().map(TDataGeneratorVO::getId).collect(Collectors.toList());
|
if(CollectionUtils.isEmpty(ids)){
|
return new PageInfo<>();
|
}
|
if(query.getOrderType() == 1){
|
List<TOrderMeal> orderMeals = orderMealService.list(Wrappers.lambdaQuery(TOrderMeal.class)
|
.in(TOrderMeal::getGeneratorId, ids));
|
List<Long> mealIds = orderMeals.stream().map(TOrderMeal::getId).collect(Collectors.toList());
|
if(!CollectionUtils.isEmpty(mealIds)){
|
List<TOrderMealGoods> mealGoods = orderMealGoodsService.list(Wrappers.lambdaQuery(TOrderMealGoods.class)
|
.in(TOrderMealGoods::getOrderId, mealIds));
|
for (TDataGeneratorVO tDataGeneratorVO : list) {
|
List<Long> collect = orderMeals.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).map(TOrderMeal::getId).collect(Collectors.toList());
|
BigDecimal money = mealGoods.stream().filter(e -> collect.contains(e.getOrderId()))
|
.reduce(BigDecimal.ZERO, (x, y) -> x.add(y.getGoodsSalePrice().multiply(new BigDecimal(y.getGoodsCount()))), BigDecimal::add);
|
tDataGeneratorVO.setTotalRevenue(money);
|
}
|
}
|
}else {
|
List<TOrderSale> orderSales = orderSaleService.list(Wrappers.lambdaQuery(TOrderSale.class)
|
.in(TOrderSale::getGeneratorId, ids));
|
// List<Long> saleIds = orderSales.stream().map(TOrderSale::getId).collect(Collectors.toList());
|
// List<TOrderSaleGoods> orderSaleGoods = orderSaleGoodsService.list(Wrappers.lambdaQuery(TOrderSaleGoods.class)
|
// .in(TOrderSaleGoods::getOrderId, saleIds));
|
for (TDataGeneratorVO tDataGeneratorVO : list) {
|
// List<Long> collect = orderSales.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).map(TOrderSale::getId).collect(Collectors.toList());
|
// BigDecimal money = orderSaleGoods.stream().filter(e -> collect.contains(e.getOrderId()))
|
// .reduce(BigDecimal.ZERO, (x, y) -> x.add(y.getGoodsCostPrice().multiply(new BigDecimal(y.getGoodsCount()))), BigDecimal::add);
|
if(!CollectionUtils.isEmpty(orderSales)){
|
BigDecimal money = orderSales.stream().map(TOrderSale::getPayMoney).reduce(BigDecimal::add).get();
|
tDataGeneratorVO.setTotalRevenue(money);
|
}
|
}
|
}
|
pageInfo.setRecords(list);
|
return pageInfo;
|
}
|
|
@Override
|
public void dataCoverage(Long id) {
|
TDataGenerator dataGenerator = this.getOne(Wrappers.lambdaQuery(TDataGenerator.class)
|
.eq(TDataGenerator::getId, id));
|
if(dataGenerator.getOrderType() == 1){
|
// 删除时间段的数据
|
orderMealService.remove(Wrappers.lambdaQuery(TOrderMeal.class)
|
.gt(TOrderMeal::getCreateTime, dataGenerator.getStartTime())
|
.lt(TOrderMeal::getCreateTime, dataGenerator.getEndTime()));
|
// 修改覆盖类型为已覆盖
|
orderMealService.update(Wrappers.lambdaUpdate(TOrderMeal.class).set(TOrderMeal::getIsCover, 1).eq(TOrderMeal::getGeneratorId, id));
|
}else {
|
// 删除时间段的数据
|
orderStockService.remove(Wrappers.lambdaQuery(TOrderStock.class)
|
.gt(TOrderStock::getCreateTime, dataGenerator.getStartTime())
|
.lt(TOrderStock::getCreateTime, dataGenerator.getEndTime()));
|
// 修改覆盖类型为已覆盖
|
orderStockService.update(Wrappers.lambdaUpdate(TOrderStock.class).set(TOrderStock::getIsCover, 1).eq(TOrderStock::getGeneratorId, id));
|
}
|
dataGenerator.setStatus(3);
|
this.updateById(dataGenerator);
|
}
|
|
@Override
|
public TDataGeneratorMealDetailVO mealGeneratorDataDetail(TDataGeneratorMealQuery query) {
|
// 查询餐饮数据生成详情
|
TDataGenerator dataGenerator = this.getById(query.getGeneratorId());
|
TDataGeneratorMealDetailVO data = new TDataGeneratorMealDetailVO();
|
BeanUtils.copyProperties(dataGenerator,data);
|
// 查询店铺
|
TShop shop = shopService.getById(dataGenerator.getShopId());
|
if(Objects.nonNull(shop)){
|
data.setShopName(shop.getShopName());
|
}
|
// 查询订单
|
PageInfo<TOrderMealVO> pageInfo = orderMealService.pageListGenerator(query);
|
data.setOrderMealList(pageInfo);
|
// 统计支付金额
|
Map<String, Double> map = orderMealService.getDataGeneratorMealDetail(query);
|
BigDecimal money = new BigDecimal(map.get("moneyPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal card = new BigDecimal(map.get("cardPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal weiXin = new BigDecimal(map.get("weiXinPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal ali = new BigDecimal(map.get("aliPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal other = new BigDecimal(map.get("otherPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
data.setMoneyPayAmount(money);
|
data.setCardPayAmount(card);
|
data.setWeiXinPayAmount(weiXin);
|
data.setAliPayAmount(ali);
|
data.setOtherPayAmount(other);
|
return data;
|
}
|
|
@Override
|
public TDataGeneratorSaleDetailVO saleGeneratorDataDetail(TDataGeneratorSaleQuery query) {
|
// 查询餐饮数据生成详情
|
TDataGeneratorSaleDetailVO data = new TDataGeneratorSaleDetailVO();
|
// 查询订单
|
TOrderSaleQuery orderSaleQuery = new TOrderSaleQuery();
|
orderSaleQuery.setTimeType(query.getTimeType());
|
orderSaleQuery.setPayType(query.getPayType());
|
orderSaleQuery.setOrderNum(query.getOrderNum());
|
orderSaleQuery.setGeneratorId(query.getGeneratorId());
|
PageInfo<TOrderSaleVO> pageInfo = orderSaleService.pageList(orderSaleQuery);
|
data.setOrderMealList(pageInfo);
|
// 统计支付金额
|
Map<String, Double> map = orderSaleService.getDataGeneratorSaleDetail(query);
|
BigDecimal money = new BigDecimal(map.get("moneyPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal card = new BigDecimal(map.get("cardPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal weiXin = new BigDecimal(map.get("weiXinPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal ali = new BigDecimal(map.get("aliPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
BigDecimal other = new BigDecimal(map.get("otherPay")).setScale(2,BigDecimal.ROUND_HALF_UP);
|
data.setMoneyPayAmount(money);
|
data.setCardPayAmount(card);
|
data.setWeiXinPayAmount(weiXin);
|
data.setAliPayAmount(ali);
|
data.setOtherPayAmount(other);
|
return data;
|
}
|
|
@Override
|
public TDataGeneratorStockDetailVO stockGeneratorDataDetail(TDataGeneratorStockQuery query) {
|
// 查询餐饮数据生成详情
|
TDataGeneratorStockDetailVO data = new TDataGeneratorStockDetailVO();
|
// 查询订单
|
TOrderStockQuery orderStockQuery = new TOrderStockQuery();
|
orderStockQuery.setGeneratorId(query.getGeneratorId());
|
orderStockQuery.setTimeType(query.getTimeType());
|
orderStockQuery.setStockNum(query.getOrderNum());
|
PageInfo<TOrderStockVO> pageInfo = orderStockService.pageList(orderStockQuery);
|
data.setOrderStockVOList(pageInfo);
|
// 统计支付金额
|
Map<String, Object> map = orderStockService.getDataGeneratorStockDetail(query);
|
Integer totalStock = Integer.parseInt(map.get("totalStock").toString());
|
BigDecimal stockAmountSum = new BigDecimal(map.get("stockAmountSum").toString());
|
data.setTotalStock(totalStock);
|
data.setStockAmountSum(stockAmountSum);
|
return data;
|
}
|
|
@Override
|
public List<TOrderSaleVO> mealGeneratorExport(TDataGeneratorMealQuery query) {
|
return null;
|
}
|
|
private int getRandomPayType(Integer size,BigDecimal count) {
|
BigDecimal bigDecimal = new BigDecimal(size).multiply(count.divide(new BigDecimal(100))).setScale(0, BigDecimal.ROUND_FLOOR);
|
return Integer.parseInt(bigDecimal.toString());
|
}
|
|
private int getRandom(int min,int max) {
|
// 生成一个min到max之间的随机数
|
return new Random().nextInt(max - min + 1) + min;
|
}
|
|
private static <T> List<T> randomSelection(List<T> list, int size) {
|
List<T> selected = new ArrayList<>();
|
int length = list.size();
|
for (int i = 0; i < size; i++) {
|
Collections.shuffle(list);
|
// 如果需求的大小超过了集合的长度，则只能取到集合的全部元素
|
int subListSize = Math.min(size - selected.size(), length);
|
selected.addAll(list.subList(0, subListSize));
|
}
|
return selected;
|
}
|
|
}
|
