绵阳收银系统
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
xuhy
3 天以前 508f3e225df87e0da974424981e7782fc5ce875c 
 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/TDataGeneratorServiceImpl.java


@@ -9,6 +9,7 @@


import com.ruoyi.common.core.redis.RedisCache;


import com.ruoyi.common.exception.ServiceException;


import com.ruoyi.common.utils.CodeGenerateUtils;


import com.ruoyi.common.utils.DateUtils;


import com.ruoyi.system.domain.*;


import com.ruoyi.system.dto.OrderMealGeneratorCountDTO;


import com.ruoyi.system.dto.OrderMealGeneratorDTO;


@@ -26,6 +27,8 @@




import java.math.BigDecimal;


import java.math.RoundingMode;


import java.text.ParseException;


import java.text.SimpleDateFormat;


import java.time.LocalDate;


import java.util.*;


import java.util.stream.Collectors;


@@ -45,6 +48,8 @@


    private TBoardService boardService;


    @Autowired


    private TFoundationConfigService foundationConfigService;


    @Autowired


    private TFoundationPersonService foundationPersonService;


    @Autowired


    private TGoodsService goodsService;


    @Autowired


@@ -89,10 +94,10 @@


        dataGenerator.setOtherPay(dto.getOtherProportion());


        this.save(dataGenerator);


        long start = System.currentTimeMillis();


        // 查询所有的人数用餐标准


        List<TFoundationConfigVO> foundationConfigs = foundationConfigService.getList(dto.getShopId());


        TShop shop = shopService.getById(dto.getShopId());


        List<TFoundationConfigVO> foundationConfigs = foundationConfigService.getList(shop.getMealType());


        if(CollectionUtils.isEmpty(foundationConfigs)){


            throw new ServiceException("请先添加该店铺用餐标准");


            throw new ServiceException("请先添加中餐或火锅用餐标准");


        }


        // 查询所有桌子


        List<TBoard> boards = boardService.list(Wrappers.lambdaQuery(TBoard.class)


@@ -110,8 +115,14 @@


        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();


            TBoard board = boards.stream().filter(e -> e.getId().equals(orderMealGeneratorCountDTO.getBoardId())).findFirst().orElse(null);


            if(Objects.isNull(board)){


                throw new ServiceException("该桌台信息不存在");


            }


            Integer orderCount = orderMealGeneratorCountDTO.getOrderCount();


            if(orderCount == 0){


                continue;


            }


            // 查询当前桌的用餐人数


            for (int i = 1; i <= orderCount; i++) {


                int random = getRandom(board.getMinPerson(), board.getMaxPerson());


@@ -120,22 +131,36 @@


                orderMeal.setMealType(1);


                orderMeal.setMealPerson(random);


                orderMeal.setMealTime(orderMealGeneratorCountDTO.getTime());


                orderMeal.setOrderNum(OrderNumConstants.MEAL + CodeGenerateUtils.generateVolumeSn());


                String num = OrderNumConstants.MEAL + CodeGenerateUtils.generateVolumeSn();


//                long count1 = orderMealService.count(Wrappers.lambdaQuery(TOrderMeal.class)


//                        .eq(TOrderMeal::getOrderNum, num));


//                if(count1>0){


//                    num = CodeGenerateUtils.generateVolumeSn();


//                }


                orderMeal.setOrderNum(num);


                orderMeal.setStatus(2);


                List<TOrderMealGoods> orderMealGoods = new ArrayList<>();


                // 获取当前桌的菜品


                List<TFoundationConfigVO> foundationConfigVOS = foundationConfigs.stream().filter(e -> e.getMealCount().equals(random)).collect(Collectors.toList());


                if(CollectionUtils.isEmpty(foundationConfigVOS)){


                    throw new ServiceException("桌台"+random+"人餐，人数配置不存在");


                }


                // 每种菜品分类需要几个菜的生成


                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);


                    List<TGoods> typeGoodsList = goods.stream().filter(m -> e.getTypeId().equals(m.getTypeId())).collect(Collectors.toList());


                    List<TGoods> typeGoods = randomSelection(typeGoodsList, random1);


                    if(typeGoods.size() != random1){


                        List<TGoods> goods1 = randomSelection(typeGoodsList, random1 - typeGoods.size());


                        typeGoods.addAll(goods1);


                    }


                    for (TGoods typeGood : typeGoods) {


                        int count = 0;


                        for (TOrderMealGoods good : orderMealGoods) {


                            if (good.getGoodsNum().equals(typeGood.getGoodsNum())) {


                                count+=1;


                                good.setGoodsCount(good.getGoodsCount() + 1);


//                                good.setGoodsSalePrice(good.getGoodsSalePrice().add(typeGood.getSalePrice()));


                                break; // 找到后直接跳出循环


                            }


                        }


@@ -294,9 +319,13 @@


            e.setGeneratorId(dataGenerator.getId());


            e.setOrderNum(OrderNumConstants.SALE + CodeGenerateUtils.generateVolumeSn());


            e.setIsCover(0);


            e.setStatus(2);


        });


        List<TOrderSaleGoods> orderSaleGoods = orderSales.stream().map(TOrderSale::getOrderSaleGoods).flatMap(Collection::stream).collect(Collectors.toList());




        TOrderStock orderStockLast = orderStockService.getOne(Wrappers.lambdaQuery(TOrderStock.class)


                .eq(TOrderStock::getShopId, dto.getShopId())


                .orderByDesc(TOrderStock::getStockTime)


                .last("LIMIT 1"));


        // 生成进货数据


        List<TOrderStock> stockList = new ArrayList<>();


        stockDataSets.stream().sorted(Comparator.comparing(TStockDataSet::getStockDate));


@@ -329,8 +358,8 @@


                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());


                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());


                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();


                    BigDecimal rate = start.getLossRate().divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate).setScale(0, BigDecimal.ROUND_HALF_UP);


                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);


                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));


                    orderStockGoods.add(tOrderStockGoods);


                });


@@ -338,45 +367,57 @@


                stockList.add(orderStock);




            }else if(i==0 && Objects.nonNull(stockDataSet)){


                // 第一次 第一次的进货时间为上一次的结束时间  开始时间为上一次的开始时间


                LocalDate startTime1 = stockDataSet.getStockDate();


                List<TOrderSale> collect = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) < 0).collect(Collectors.toList());


                List<TOrderSaleGoods> orderSaleGoodsList = new ArrayList<>();


                collect.forEach(e->orderSaleGoodsList.addAll(e.getOrderSaleGoods()));


                // 查询上一次开始之后的订单数据


                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());


                if(Objects.nonNull(orderStockLast)){


                    // 查询商品进价


                    List<TOrderStockGoods> orderStockGoodsList = orderStockGoodsService.list(Wrappers.lambdaQuery(TOrderStockGoods.class).eq(TOrderStockGoods::getOrderId, orderStockLast.getId()));


                    // 第一次 第一次的进货时间为上一次的结束时间  开始时间为上一次的开始时间


                    LocalDate startTime1 = stockDataSet.getStockDate();


                    List<TOrderSale> collect = orderSales.stream().filter(e -> e.getOrderTime().compareTo(startTime) < 0).collect(Collectors.toList());


                    List<TOrderSaleGoods> orderSaleGoodsList = new ArrayList<>();


                    collect.forEach(e->orderSaleGoodsList.addAll(e.getOrderSaleGoods()));


                    // 查询上一次开始之后的订单数据


                    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;


                    if(CollectionUtils.isEmpty(saleIds1)){


                        // 查询上一次的商品


                        list = orderSaleGoodsService.list(new LambdaQueryWrapper<TOrderSaleGoods>().in(TOrderSaleGoods::getOrderId, saleIds1));


                        // 结合上次最后一次的数据


                        list.addAll(orderSaleGoodsList);


                    }else {


                        list = orderSaleGoodsList;


                    }


                    // 删除上一次的数据生成   新生成一条数据


                    TOrderStock orderStock = new TOrderStock();


                    orderStock.setStockNum(OrderNumConstants.STOCK + CodeGenerateUtils.generateVolumeSn());


                    orderStock.setStockTime(orderStockLast.getStockTime());


                    orderStock.setIsCover(0);


                    orderStock.setGeneratorId(orderStockLast.getGeneratorId());


                    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.setThisCostPrice(v.get(0).getThisSalePrice());


                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());


                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());


                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();


                    BigDecimal rate = start.getLossRate().divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate).setScale(0, BigDecimal.ROUND_HALF_UP);


                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));


                    orderStockGoods.add(tOrderStockGoods);


                });


                orderStock.setOrderStockGoods(orderStockGoods);


                stockList.add(orderStock);


                    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 orderStockGoods1 = orderStockGoodsList.stream().filter(e -> e.getGoodsName().equals(k)).findFirst().orElse(null);


                        if(Objects.nonNull(orderStockGoods1)){


                            tOrderStockGoods.setThisCostPrice(orderStockGoods1.getThisCostPrice());


                        }


                        tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());


                        tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());


                        int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();


                        BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                        BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);


                        tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));


                        orderStockGoods.add(tOrderStockGoods);


                    });


                    orderStock.setOrderStockGoods(orderStockGoods);


                    stockList.add(orderStock);


                }




                // 处理第一次到下一次的数据


                TStockDataSet end = stockDataSets.get(i + 1);


@@ -404,8 +445,8 @@


                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());


                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());


                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();


                    BigDecimal rate = start.getLossRate().divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate).setScale(0, BigDecimal.ROUND_HALF_UP);


                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);


                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));


                    orderStockGoods1.add(tOrderStockGoods);


                });


@@ -438,8 +479,8 @@


                    tOrderStockGoods.setGoodsPicture(v.get(0).getGoodsPicture());


                    tOrderStockGoods.setGoodsId(v.get(0).getGoodsId());


                    int sum = v.stream().mapToInt(TOrderSaleGoods::getGoodsCount).sum();


                    BigDecimal rate = start.getLossRate().divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate).setScale(0, BigDecimal.ROUND_HALF_UP);


                    BigDecimal rate = new BigDecimal(100).subtract(start.getLossRate()).divide(new BigDecimal(100)).setScale(2, BigDecimal.ROUND_HALF_UP);


                    BigDecimal bigDecimal = new BigDecimal(sum).divide(rate,2,BigDecimal.ROUND_HALF_UP).setScale(0, BigDecimal.ROUND_HALF_UP);


                    tOrderStockGoods.setStockCount(Integer.parseInt(bigDecimal.toString().split("\\.")[0]));


                    orderStockGoods.add(tOrderStockGoods);


                });


@@ -453,12 +494,8 @@


            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);


        if(Objects.nonNull(orderStockLast) && Objects.nonNull(stockDataSet) && stockDataSets.size() > 1){


            orderStockService.removeById(orderStockLast);


        }


        orderSaleService.saveBatch(orderSales);


        for (TOrderSale orderSale : orderSales) {


@@ -493,12 +530,14 @@


                    .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));


//                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);


//                    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);


                    BigDecimal money = orderMeals.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId()))


                            .map(TOrderMeal::getPayMoney).reduce(BigDecimal.ZERO, BigDecimal::add);


                    tDataGeneratorVO.setTotalRevenue(money);


                }


            }


@@ -513,7 +552,11 @@


//                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();


                    List<TOrderSale> collect = orderSales.stream().filter(e -> e.getGeneratorId().equals(tDataGeneratorVO.getId())).collect(Collectors.toList());


                    BigDecimal money = BigDecimal.ZERO;


                    if(!CollectionUtils.isEmpty(collect)){


                        money = collect.stream().map(TOrderSale::getPayMoney).reduce(BigDecimal::add).get();


                    }


                    tDataGeneratorVO.setTotalRevenue(money);


                }


            }


@@ -530,20 +573,36 @@


            // 删除时间段的数据


            orderMealService.remove(Wrappers.lambdaQuery(TOrderMeal.class)


                    .ge(TOrderMeal::getMealTime, dataGenerator.getStartTime())


                    .le(TOrderMeal::getMealTime, dataGenerator.getEndTime()));


                    .le(TOrderMeal::getMealTime, dataGenerator.getEndTime())


                    .eq(TOrderMeal::getIsCover,1));


            // 修改覆盖类型为已覆盖


            orderMealService.update(Wrappers.lambdaUpdate(TOrderMeal.class).set(TOrderMeal::getIsCover, 1).eq(TOrderMeal::getGeneratorId, id));


        }else {


            List<TOrderStock> list = orderStockService.list(Wrappers.lambdaQuery(TOrderStock.class)


                    .eq(TOrderStock::getGeneratorId, id));


            List<Long> stockIds = list.stream().map(TOrderStock::getId).collect(Collectors.toList());


            if(!CollectionUtils.isEmpty(stockIds)){


                List<TOrderStockGoods> list1 = orderStockGoodsService.list(Wrappers.lambdaQuery(TOrderStockGoods.class)


                        .in(TOrderStockGoods::getOrderId, stockIds));


                // 判断集合中的进价是否为0


                for (TOrderStockGoods tOrderStockGoods : list1) {


                    if(tOrderStockGoods.getThisCostPrice().compareTo(BigDecimal.ZERO) == 0){


                        throw new ServiceException("进价不能为0");


                    }


                }


            }


            // 删除时间段的数据


            orderSaleService.remove(Wrappers.lambdaQuery(TOrderSale.class)


                    .ge(TOrderSale::getOrderTime, dataGenerator.getStartTime())


                    .le(TOrderSale::getOrderTime, dataGenerator.getEndTime()));


                    .le(TOrderSale::getOrderTime, dataGenerator.getEndTime())


                    .eq(TOrderSale::getIsCover,1));


            // 修改覆盖类型为已覆盖


            orderStockService.update(Wrappers.lambdaUpdate(TOrderStock.class).set(TOrderStock::getIsCover, 1).eq(TOrderStock::getGeneratorId, id));


            orderSaleService.update(Wrappers.lambdaUpdate(TOrderSale.class).set(TOrderSale::getIsCover, 1).eq(TOrderSale::getGeneratorId, id));


            // 删除时间段的数据


            orderStockService.remove(Wrappers.lambdaQuery(TOrderStock.class)


                    .ge(TOrderStock::getStockTime, dataGenerator.getStartTime())


                    .le(TOrderStock::getStockTime, dataGenerator.getEndTime()));


                    .le(TOrderStock::getStockTime, dataGenerator.getEndTime())


                    .eq(TOrderStock::getIsCover,1));


            // 修改覆盖类型为已覆盖


            orderStockService.update(Wrappers.lambdaUpdate(TOrderStock.class).set(TOrderStock::getIsCover, 1).eq(TOrderStock::getGeneratorId, id));


        }


@@ -590,6 +649,14 @@


        orderSaleQuery.setPayType(query.getPayType());


        orderSaleQuery.setOrderNum(query.getOrderNum());


        orderSaleQuery.setGeneratorId(query.getGeneratorId());


        try {


            if (Objects.nonNull(query.getStartTime()) && Objects.nonNull(query.getEndTime())){


                orderSaleQuery.setStartTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getStartTime()));


                orderSaleQuery.setEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getEndTime()));


            }


        } catch (ParseException e) {


            throw new ServiceException(e.getMessage());


        }


        PageInfo<TOrderSaleVO> pageInfo = orderSaleService.pageList(orderSaleQuery);


        data.setOrderMealList(pageInfo);


        // 统计支付金额


@@ -616,14 +683,28 @@


        orderStockQuery.setGeneratorId(query.getGeneratorId());


        orderStockQuery.setTimeType(query.getTimeType());


        orderStockQuery.setStockNum(query.getOrderNum());


        try {


            if(Objects.nonNull(query.getStartTime()) && Objects.nonNull(query.getEndTime())){


                orderStockQuery.setStartTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getStartTime()));


                orderStockQuery.setEndTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(query.getEndTime()));


            }


        } catch (ParseException e) {


            throw new ServiceException(e.getMessage());


        }


        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());


//        BigDecimal stockAmountSum = new BigDecimal(map.get("stockAmountSum").toString());


        data.setTotalStock(totalStock);


        data.setStockAmountSum(stockAmountSum);


        List<TOrderStock> list = orderStockService.list(Wrappers.lambdaQuery(TOrderStock.class)


                .eq(TOrderStock::getGeneratorId, query.getGeneratorId()));


        if(CollectionUtils.isEmpty(list)){


            data.setStockAmountSum(BigDecimal.ZERO);


        }else {


            data.setStockAmountSum(list.stream().filter(e->Objects.nonNull(e.getStockTotalPrice())).map(TOrderStock::getStockTotalPrice).reduce(BigDecimal.ZERO, BigDecimal::add));


        }


        return data;


    }




@@ -632,6 +713,11 @@


        return null;


    }




    @Override


    public void deleteByShopId(Long shopId) {


        this.baseMapper.deleteByShopId(shopId);


    }




    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());