java/cashier.git

			@@ -1,22 +1,30 @@
			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.exception.ServiceException;
			import com.ruoyi.common.utils.CodeGenerateUtils;
			import com.ruoyi.framework.web.service.TokenService;
			import com.ruoyi.system.domain.*;
			import com.ruoyi.system.dto.OrderMealGeneratorCountDTO;
			import com.ruoyi.system.dto.OrderMealGeneratorDTO;
			import com.ruoyi.system.dto.TOrderMealDTO;
			import com.ruoyi.system.dto.*;
			import com.ruoyi.system.mapper.TDataGeneratorMapper;
			import com.ruoyi.system.query.TDataGeneratorQuery;
			import com.ruoyi.system.service.*;
			import com.ruoyi.system.vo.SysUserVO;
			import com.ruoyi.system.vo.TDataGeneratorVO;
			import com.ruoyi.system.vo.TFoundationConfigVO;
			import org.apache.poi.ss.formula.functions.T;
			import org.springframework.beans.BeanUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;

			import java.math.BigDecimal;
			import java.math.RoundingMode;
			import java.time.LocalDate;
			import java.util.*;
			import java.util.stream.Collectors;

			@@ -41,9 +49,38 @@
			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 TokenService tokenService;
			@Autowired
			private TStockDataSetService stockDataSetService;

			@Override
			public void dataGenerator(OrderMealGeneratorDTO dto) {
			public void mealDataGenerator(OrderMealGeneratorDTO dto) {
			// 存储数据生成数据
			TDataGenerator dataGenerator = new TDataGenerator();
			dataGenerator.setUserId(tokenService.getLoginUser().getUserId());
			dataGenerator.setUserName(tokenService.getLoginUser().getNickName());
			dataGenerator.setShopId(dataGenerator.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();
			@@ -99,7 +136,7 @@
			}
			}
			BigDecimal sumMoney = orderMeals.stream().map(TOrderMeal::getPayMoney).reduce(BigDecimal::add).get();
			if(sumMoney.compareTo(dto.getMinTurnover()) >= 0 \|\| sumMoney.compareTo(dto.getMaxTurnover()) <= 0){
			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());
			@@ -148,12 +185,17 @@
			allOrderMeals.addAll(cardOrderMeals);
			allOrderMeals.addAll(moneyOrderMeals);
			allOrderMeals.addAll(otherOrderMeals);
			allOrderMeals.forEach(e->{
			e.setIsCover(0);
			e.setGeneratorId(dataGenerator.getId());
			});
			orderMealService.saveBatch(allOrderMeals);

			for (TOrderMeal weiXinOrderMeal : allOrderMeals) {
			weiXinOrderMeal.getMealOrderGoods().forEach(e->e.setOrderId(weiXinOrderMeal.getId()));
			for (TOrderMeal orderMeal : allOrderMeals) {
			orderMeal.getMealOrderGoods().forEach(e->e.setOrderId(orderMeal.getId()));
			}
			orderMealGoodsService.saveBatch(allOrderMeals.stream().map(TOrderMeal::getMealOrderGoods).flatMap(Collection::stream).collect(Collectors.toList()));
			// 存储
			long end = System.currentTimeMillis() - start;
			System.err.println("相差时间========="+end);
			}else {
			@@ -162,6 +204,237 @@

			}

			@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(tokenService.getLoginUser().getUserId());
			dataGenerator.setUserName(tokenService.getLoginUser().getNickName());
			dataGenerator.setShopId(dataGenerator.getShopId());
			dataGenerator.setStartTime(dto.getStartTime());
			dataGenerator.setEndTime(dto.getEndTime());
			dataGenerator.setStatus(2);
			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();
			orderSaleService.saveBatch(orderSales);
			for (TOrderSale orderSale : orderSales) {
			orderSale.getOrderSaleGoods().forEach(e->e.setOrderId(orderSale.getId()));
			}
			List<TOrderSaleGoods> orderSaleGoods = orderSales.stream().map(TOrderSale::getOrderSaleGoods).flatMap(Collection::stream).collect(Collectors.toList());
			orderSaleGoodsService.saveBatch(orderSaleGoods);

			// 生成进货数据
			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).getSalePrice());
			tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
			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).getSalePrice());
			tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
			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).getSalePrice());
			tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
			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).getSalePrice());
			tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());
			tOrderStockGoods.setStockCount(v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum());
			orderStockGoods.add(tOrderStockGoods);
			});
			orderStock.setOrderStockGoods(orderStockGoods);
			stockList.add(orderStock);
			}
			}
			// 删除上一次的数据生成
			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);
			}
			// 添加数据
			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(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());
			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<TOrderStock> orderStocks = orderStockService.list(Wrappers.lambdaQuery(TOrderStock.class)
			.in(TOrderStock::getGeneratorId, ids));
			List<Long> stockIds = orderStocks.stream().map(TOrderStock::getId).collect(Collectors.toList());
			List<TOrderStockGoods> stockGoods = orderStockGoodsService.list(Wrappers.lambdaQuery(TOrderStockGoods.class)
			.in(TOrderStockGoods::getOrderId, stockIds));
			for (TDataGeneratorVO tDataGeneratorVO : list) {
			List<Long> collect = orderStocks.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).map(TOrderStock::getId).collect(Collectors.toList());
			BigDecimal money = stockGoods.stream().filter(e -> collect.contains(e.getOrderId()))
			.reduce(BigDecimal.ZERO, (x, y) -> x.add(y.getStockPrice().multiply(new BigDecimal(y.getStockCount()))), BigDecimal::add);
			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.update(Wrappers.lambdaUpdate(TOrderStock.class).set(TOrderStock::getIsCover, 1).eq(TOrderStock::getGeneratorId, id));
			}
			}

			private int getRandomPayType(Integer size,BigDecimal count) {
			BigDecimal bigDecimal = new BigDecimal(size).multiply(count.divide(new BigDecimal(100))).setScale(0, RoundingMode.HALF_UP);
			return Integer.parseInt(bigDecimal.toString());