产品供销存-后端
blame | 历史 | 补丁 | 提交 | 提交对比 | 忽略空白
zss
8 天以前 7eb970282c629c14a28d9f7af3777419bfb290fc 
 src/main/java/com/ruoyi/home/service/impl/HomeServiceImpl.java


@@ -2,6 +2,7 @@




import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;


import com.baomidou.mybatisplus.core.metadata.IPage;


import com.baomidou.mybatisplus.core.toolkit.Wrappers;


import com.baomidou.mybatisplus.extension.plugins.pagination.Page;


import com.ruoyi.approve.mapper.ApproveProcessMapper;


import com.ruoyi.approve.pojo.ApproveProcess;


@@ -31,9 +32,11 @@


import com.ruoyi.production.dto.ProductWorkOrderDto;


import com.ruoyi.production.dto.ProductionProductMainDto;


import com.ruoyi.production.mapper.ProductOrderMapper;


import com.ruoyi.production.mapper.ProductProcessMapper;


import com.ruoyi.production.mapper.ProductWorkOrderMapper;


import com.ruoyi.production.mapper.ProductionProductMainMapper;


import com.ruoyi.production.pojo.ProductOrder;


import com.ruoyi.production.pojo.ProductProcess;


import com.ruoyi.production.pojo.ProductWorkOrder;


import com.ruoyi.project.system.domain.SysDept;


import com.ruoyi.project.system.mapper.SysDeptMapper;


@@ -60,6 +63,7 @@


import java.text.SimpleDateFormat;


import java.time.*;


import java.time.format.DateTimeFormatter;


import java.time.temporal.ChronoUnit;


import java.time.temporal.TemporalAdjusters;


import java.util.*;


import java.util.concurrent.atomic.AtomicInteger;


@@ -114,7 +118,7 @@


    @Autowired


    private ProductOrderMapper productOrderMapper;


    @Autowired


    private ProductionProductMainMapper productionProductMainMapper;


    private ProductProcessMapper productProcessMapper;


    @Autowired


    private ProductWorkOrderMapper productWorkOrderMapper;


    @Autowired


@@ -528,37 +532,55 @@


    @Override


    public ProductionProgressDto productionProgress() {


        ProductionProgressDto productionProgressDto = new ProductionProgressDto();


        List<ProductOrder> productOrderList = productOrderMapper.selectList(new LambdaQueryWrapper<ProductOrder>());


        List<ProductOrderDto> productOrderDtoList = new ArrayList<>();


        productOrderList.forEach(productOrder -> {


            ProductOrderDto productOrderDto = productOrderMapper.productMainByOrderId(productOrder);


//            if (productOrderDto != null && productOrderDto.getPlanQuantity() != null && productOrderDto.getQuantity() != null) {


//                productOrderDto.setCompletionStatus((productOrderDto.getPlanQuantity().subtract(productOrderDto.getQuantity())).divide(productOrderDto.getPlanQuantity(), 2, RoundingMode.HALF_UP));


//            }


            productOrderDtoList.add(productOrderDto);


        });


        productionProgressDto.setCompletedOrderDetails(productOrderDtoList);


        // 1. 查询所有生产订单（可根据需求添加过滤条件，如排除已删除、已取消的订单）


        IPage<ProductOrderDto> productOrderDtoIPage = productOrderMapper.pageProductOrder(new Page<>(1, -1), new ProductOrderDto());




        // 2. 初始化汇总数据


        int totalCount = productOrderDtoIPage.getRecords().size();


        int completedCount = (int) productOrderDtoIPage.getRecords().stream().map(productOrderDto -> productOrderMapper.productMainByOrderId(productOrderDto)).filter(productOrderDto1 -> productOrderDto1.getQuantity() != null && productOrderDto1.getQuantity().compareTo(BigDecimal.ZERO) == 0).count();




        // 6. 赋值汇总数据


        ProductOrderDto orderDto = new ProductOrderDto();


        orderDto.setStartTime(LocalDateTime.now().minusMonths(1));


        orderDto.setEndTime(LocalDateTime.now());


        List<ProductOrderDto> productOrderDtos = productOrderMapper.pageProductOrder(new Page<>(1, -1), orderDto).getRecords();


        productionProgressDto.setCompletedOrderDetails(productOrderDtos);


        long totalCount = productOrderDtos.size();


        long count = productOrderDtos.stream().filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(productOrderDto.getQuantity()) >= 0).count();


        long count2 = productOrderDtos.stream().filter(productOrderDto -> productOrderDto.getCompleteQuantity().compareTo(BigDecimal.ZERO) == 0).count();


        productionProgressDto.setTotalOrderCount(totalCount);


        productionProgressDto.setCompletedOrderCount(completedCount);


        productionProgressDto.setUncompletedOrderCount(totalCount - completedCount);


        productionProgressDto.setCompletedProgressCount(BigDecimal.valueOf(completedCount).divide(BigDecimal.valueOf(totalCount), 2, RoundingMode.HALF_UP));


        productionProgressDto.setCompletedOrderCount(count);


        productionProgressDto.setUncompletedOrderCount(count2);


        productionProgressDto.setPartialCompletedOrderCount(totalCount-count-count2);


        return productionProgressDto;


    }


    @Override


    public Map<Integer, List<ProductWorkOrderDto>> workInProcessTurnover() {


        List<ProductWorkOrderDto> productWorkOrderDtoList = productWorkOrderMapper.selectProductWorkOrderDtoList();


       //根据状态区分工单的各个状态


        Map<Integer, List<ProductWorkOrderDto>> productWorkOrderDtoMap = productWorkOrderDtoList.stream().collect(Collectors.groupingBy(ProductWorkOrderDto::getStatus));




        return productWorkOrderDtoMap;


    public ProductionTurnoverDto workInProcessTurnover() {


        ProductionTurnoverDto productionTurnoverDto = new ProductionTurnoverDto();


        ProductWorkOrderDto workOrder = new ProductWorkOrderDto();


        workOrder.setPlanStartTime(LocalDate.now().minusMonths(1));


        workOrder.setPlanEndTime(LocalDate.now());


        List<ProductWorkOrderDto> productWorkOrders = productWorkOrderMapper.pageProductWorkOrder(new Page<>(1, -1), workOrder).getRecords();


        long sum = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getPlanQuantity().compareTo(productWorkOrder.getCompleteQuantity()) > 0)


                .map(ProductWorkOrder::getPlanQuantity)


                .mapToLong(BigDecimal::longValue)


                .sum();


        if (sum == 0)return null;


        productionTurnoverDto.setTotalOrderCount(sum);//总在制品数量


        productionTurnoverDto.setAverageTurnoverDays(BigDecimal.valueOf(sum).divide(BigDecimal.valueOf(ChronoUnit.DAYS.between(LocalDateTime.now().minusMonths(1), LocalDateTime.now())),2,RoundingMode.HALF_UP));


        long completeQuantity = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getCompleteQuantity().compareTo(productWorkOrder.getPlanQuantity()) >= 0)


                .map(ProductWorkOrder::getCompleteQuantity)


                .mapToLong(BigDecimal::longValue)


                .sum();


        productionTurnoverDto.setTurnoverEfficiency(BigDecimal.valueOf(completeQuantity).divide(BigDecimal.valueOf(sum),2,RoundingMode.HALF_UP));


        Map<String, List<ProductWorkOrderDto>> map = productWorkOrders.stream()


                .filter(productWorkOrder -> productWorkOrder.getPlanQuantity().compareTo(productWorkOrder.getCompleteQuantity()) > 0)


                .collect(Collectors.groupingBy(ProductWorkOrderDto::getProcessName));


        List<String> strings = new ArrayList<>();


        List<Long> processQuantityDetails = new ArrayList<>();


        map.entrySet().stream().forEach(entry -> {


            String key = entry.getKey();


            long completeSum = entry.getValue().stream().map(ProductWorkOrderDto::getCompleteQuantity).mapToLong(BigDecimal::longValue).sum();


            strings.add(key);


            processQuantityDetails.add(completeSum);


        });


        productionTurnoverDto.setProcessDetails(strings);


        productionTurnoverDto.setProcessQuantityDetails(processQuantityDetails);


        return productionTurnoverDto;




    }


}