package com.ruoyi.inspect.service.impl;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.ruoyi.basic.dto.IfsInventoryQuantitySupplierDto;
import com.ruoyi.common.constant.InsOrderTypeConstants;
import com.ruoyi.framework.exception.ErrorException;
import com.ruoyi.inspect.dto.DataAnalysisDto;
import com.ruoyi.inspect.dto.SampleProductRawAnalysisDto;
import com.ruoyi.inspect.mapper.DataAnalysisMapper;
import com.ruoyi.inspect.mapper.InsProductMapper;
import com.ruoyi.inspect.service.DataAnalysisService;
import com.ruoyi.inspect.vo.DeviationAnalyzeVo;
import com.ruoyi.inspect.vo.RawMaterialSupplierVo;
import com.ruoyi.inspect.vo.RawProductAnalysisVo;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.math.MathContext;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 数据分析
 *
 * @Author zhuo
 * @Date 2024/10/16
 */
@Service
@AllArgsConstructor
public class DataAnalysisServiceImpl implements DataAnalysisService {

    private DataAnalysisMapper dataAnalysisMapper;

    private InsProductMapper insProductMapper;

    /**
     * 查询原材料柱状统计
     * @return searchTime  时间
     * @return passRate  合格率
     * @return sum  总数
     */
    @Override
    public List<Map<String, Object>> getRawPassRateByBarChart(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        // 获取当前日期
        DateTime now = DateUtil.date();
        if (StrUtil.isNotBlank(dataAnalysisDto.getBeginDate()) && StrUtil.isNotBlank(dataAnalysisDto.getEndDate())) {
            return dataAnalysisMapper.getRawPassRateByBarChartByDay(dataAnalysisDto);
        } else if (dataAnalysisDto.getDateType().equals("1")) {
            // 获取本周的开始时间（周一 00:00:00）
            DateTime beginOfWeek = DateUtil.beginOfWeek(now);
            // 获取本周的结束时间（周日 23:59:59）
            // 获取本周的结束时间（周日 23:59:59）
            DateTime endOfWeek = DateUtil.endOfWeek(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfWeek, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfWeek, "yyyy-MM-dd HH:mm:ss"));
            return dataAnalysisMapper.getRawPassRateByBarChartByWeek(dataAnalysisDto);
        } else if (dataAnalysisDto.getDateType().equals("2")) {
            // 获取当前月的开始时间（每月1号 00:00:00）
            DateTime beginOfMonth = DateUtil.beginOfMonth(now);
            // 获取当前月的结束时间（本月最后一天 23:59:59）
            DateTime endOfMonth = DateUtil.endOfMonth(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfMonth, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfMonth, "yyyy-MM-dd HH:mm:ss"));
            return dataAnalysisMapper.getRawPassRateByBarChartByDay(dataAnalysisDto);
        } else if (dataAnalysisDto.getDateType().equals("3")) {
            // 获取当前年的开始时间（每年1月1日 00:00:00）
            DateTime beginOfYear = DateUtil.beginOfYear(now);
            // 获取当前年的结束时间（每年12月31日 23:59:59）
            DateTime endOfYear = DateUtil.endOfYear(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfYear, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfYear, "yyyy-MM-dd HH:mm:ss"));
            return dataAnalysisMapper.getRawPassRateByBarChartByYear(dataAnalysisDto);
        }

        return null;
    }

    /**
     * 查询原材料饼状图
     * @param dataAnalysisDto
     * @return
     * sum          : 总数
     * unQualified  : 不合格数量
     * qualified  : 合格数量
     * passRate  : 合格率
     */
    @Override
    public Map<String, Object> getRawPassRateByCake(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        // 获取当前日期
        DateTime now = DateUtil.date();
        if (StrUtil.isNotBlank(dataAnalysisDto.getBeginDate()) && StrUtil.isNotBlank(dataAnalysisDto.getEndDate())) {

        } else if (dataAnalysisDto.getDateType().equals("1")) {
            // 获取本周的开始时间（周一 00:00:00）
            DateTime beginOfWeek = DateUtil.beginOfWeek(now);
            // 获取本周的结束时间（周日 23:59:59）
            DateTime endOfWeek = DateUtil.endOfWeek(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfWeek, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfWeek, "yyyy-MM-dd HH:mm:ss"));
        } else if (dataAnalysisDto.getDateType().equals("2")) {
            // 获取当前月的开始时间（每月1号 00:00:00）
            DateTime beginOfMonth = DateUtil.beginOfMonth(now);
            // 获取当前月的结束时间（本月最后一天 23:59:59）
            DateTime endOfMonth = DateUtil.endOfMonth(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfMonth, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfMonth, "yyyy-MM-dd HH:mm:ss"));
        } else if (dataAnalysisDto.getDateType().equals("3")) {
            // 获取当前年的开始时间（每年1月1日 00:00:00）
            DateTime beginOfYear = DateUtil.beginOfYear(now);
            // 获取当前年的结束时间（每年12月31日 23:59:59）
            DateTime endOfYear = DateUtil.endOfYear(now);
            dataAnalysisDto.setBeginDate(DateUtil.format(beginOfYear, "yyyy-MM-dd HH:mm:ss"));
            dataAnalysisDto.setEndDate(DateUtil.format(endOfYear, "yyyy-MM-dd HH:mm:ss"));
        }
        return dataAnalysisMapper.getRawPassRateByCake(dataAnalysisDto);
    }


    /**
     * 查询检验项名称
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public List<String> getRawItemNames(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        List<IfsInventoryQuantitySupplierDto> analysisList = dataAnalysisMapper.getRawProductAnalysisAllSample(dataAnalysisDto);
        // 根据样品id查询检测参数
        if (CollectionUtils.isEmpty(analysisList)) {
            return null;
        }
        List<Integer> sampleIds = analysisList.stream().map(IfsInventoryQuantitySupplierDto::getSampleId).collect(Collectors.toList());
        // 查询检验项目

        return insProductMapper.selectItemNameBySampleIds(sampleIds);
    }

    /**
     * 查询原材料项检分析
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public RawProductAnalysisVo getRawProductAnalysis(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        List<IfsInventoryQuantitySupplierDto> analysisList = dataAnalysisMapper.getRawProductAnalysisAllSample(dataAnalysisDto);
        // 根据样品id查询检测参数
        if (CollectionUtils.isEmpty(analysisList)) {
            return null;
        }
        List<Integer> sampleIds = analysisList.stream().map(IfsInventoryQuantitySupplierDto::getSampleId).collect(Collectors.toList());
        // 查询检验项目
        List<SampleProductRawAnalysisDto> sampleProductList = insProductMapper.selectListBySampleIds(sampleIds);

        List<String> itemNames = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(dataAnalysisDto.getItemNames())) {
            itemNames = dataAnalysisDto.getItemNames();
        } else {
            itemNames = insProductMapper.selectItemNameBySampleIds(sampleIds);
        }

        // 根据样品分组
        List<Map<String, Object>> productList = new ArrayList<>();

        Map<Integer, List<SampleProductRawAnalysisDto>> collect = sampleProductList.stream().collect(Collectors.groupingBy(SampleProductRawAnalysisDto::getInsSampleId));
        List<String> finalItemNames = itemNames;
        collect.forEach((integer, rawAnalysisDtos) -> {
            // 检验项目名称转换成map
            Map<String, Object> itemMap = new HashMap<>();
            for (String itemName : finalItemNames) {
                itemMap.put(itemName, null);
            }
            // 遍历检验项
            for (SampleProductRawAnalysisDto rawAnalysisDto : rawAnalysisDtos) {
                itemMap.put(rawAnalysisDto.getInspectionItem(), rawAnalysisDto.getLastValue());
            }
            itemMap.put("product", rawAnalysisDtos.get(0).getSampleCode());
            productList.add(itemMap);
        });

        RawProductAnalysisVo rawProductAnalysisVo = new RawProductAnalysisVo();
        rawProductAnalysisVo.setItemNames(itemNames);
        rawProductAnalysisVo.setProductList(productList);

        return rawProductAnalysisVo;
    }

    /**
     * 查询检测项分析列表
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public List<IfsInventoryQuantitySupplierDto> getRawProductAnalysisAllList(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        return dataAnalysisMapper.getRawProductAnalysisList(dataAnalysisDto);
    }

    /**
     * 查询项检分析合格率
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public RawProductAnalysisVo getRawProductAnalysisRawPass(DataAnalysisDto dataAnalysisDto) {
        // 格式化字段, 避免报错
        this.formatDataAnalysisDto(dataAnalysisDto);
        List<IfsInventoryQuantitySupplierDto> analysisList = dataAnalysisMapper.getRawProductAnalysisAllSample(dataAnalysisDto);
        // 根据样品id查询检测参数
        if (CollectionUtils.isEmpty(analysisList)) {
            return null;
        }
        List<Integer> sampleIds = analysisList.stream().map(IfsInventoryQuantitySupplierDto::getSampleId).collect(Collectors.toList());
        // 查询检验项目
        List<SampleProductRawAnalysisDto> sampleProductList = insProductMapper.selectListBySampleIds(sampleIds);
        List<String> itemNames = new ArrayList<>();
        List<String> finalItemNames = itemNames;
        if (CollectionUtils.isNotEmpty(dataAnalysisDto.getItemNames())) {
            itemNames = dataAnalysisDto.getItemNames();
        } else {
            itemNames = insProductMapper.selectItemNameBySampleIds(sampleIds);
        }
        // 分组
        List<Map<String, Object>> productList = new ArrayList<>();

        Map<String, List<SampleProductRawAnalysisDto>> groupList = new HashMap<>();

        switch (dataAnalysisDto.getGroupType()) {
            case "0":  // 默认样品区分
                groupList = sampleProductList.stream()
                        .collect(Collectors.groupingBy(SampleProductRawAnalysisDto::getSample));

                break;
            case "1":  // 批次号区分
                groupList = sampleProductList.stream()
                        .collect(Collectors.groupingBy(SampleProductRawAnalysisDto::getUpdateBatchNo));

                break;
            case "2":  // 厂家区分
                groupList = sampleProductList.stream()
                        .collect(Collectors.groupingBy(SampleProductRawAnalysisDto::getSupplierName));

                break;
        }

        groupList.forEach((groupName, rawAnalysisDtos) -> {
            // 按照检验项区分
            // 检验项目名称转换成map
            Map<String, Object> itemMap = new HashMap<>();

            for (String itemName : finalItemNames) {
                itemMap.put(itemName, null);
            }

            Map<String, List<SampleProductRawAnalysisDto>> groupItemList = rawAnalysisDtos.stream().collect(Collectors.groupingBy(SampleProductRawAnalysisDto::getInspectionItem));


            groupItemList.forEach((itemName, dtos) -> {
                // 统计合格总数
                long qualifiedCount = dtos.stream()
                        .filter(dto -> dto.getInsResult() != null && dto.getInsResult().equals(1))
                        .count();
                long totalCount = dtos.size();
                BigDecimal passRate = new BigDecimal(qualifiedCount).divide(new BigDecimal(totalCount), 4, RoundingMode.HALF_UP)
                        .multiply(new BigDecimal(100))
                        .setScale(2, RoundingMode.HALF_UP);
                itemMap.put(itemName, passRate);
            });

            itemMap.put("product", groupName);
            productList.add(itemMap);
        });


        RawProductAnalysisVo rawProductAnalysisVo = new RawProductAnalysisVo();
        rawProductAnalysisVo.setItemNames(itemNames);
        rawProductAnalysisVo.setProductList(productList);

        return rawProductAnalysisVo;
    }

    @Override
    public DeviationAnalyzeVo getRawSupplierCompare(DataAnalysisDto dataAnalysisDto) {
        // 判断订单id是否有五个
        if (CollectionUtils.isEmpty(dataAnalysisDto.getOrderIds()) || dataAnalysisDto.getOrderIds().size() != 5) {
            throw new ErrorException("请选择五条数据");
        }
        if (CollectionUtils.isEmpty(dataAnalysisDto.getItemNames()) || dataAnalysisDto.getItemNames().size() != 1) {
            throw new ErrorException("请选择一个检验项检验项");
        }
        if (CollectionUtils.isNotEmpty(dataAnalysisDto.getSupplierDataList())) {
            if (dataAnalysisDto.getSupplierDataList().size() != 5) {
                throw new ErrorException("厂家数据请输入完整5条");
            }
        }

        List<RawMaterialSupplierVo> rawMaterialSupplierVoList = dataAnalysisMapper.getItemValueByOrderIds(dataAnalysisDto.getOrderIds(), dataAnalysisDto.getItemNames().get(0));
        // 判断厂家材料名称规格型号是否是一样的
        RawMaterialSupplierVo rawMaterialSupplierVo = rawMaterialSupplierVoList.get(0);
        for (RawMaterialSupplierVo materialSupplierVo : rawMaterialSupplierVoList) {
            if (!materialSupplierVo.getSupplierName().equals(rawMaterialSupplierVo.getSupplierName()) ||
                    !materialSupplierVo.getSample().equals(rawMaterialSupplierVo.getSample()) ||
                    !materialSupplierVo.getModel().equals(rawMaterialSupplierVo.getModel())) {
                throw new ErrorException("选择的检验信息不匹配");
            }
        }

        List<String> lastValues = rawMaterialSupplierVoList.stream().map(RawMaterialSupplierVo::getLastValue).collect(Collectors.toList());

        // 计算本地数据
        Map<String, List<Object>> localData = dataCompute(lastValues);


        DeviationAnalyzeVo deviationAnalyzeVo = new DeviationAnalyzeVo();
        deviationAnalyzeVo.setLocalData(localData.get("data"));
        deviationAnalyzeVo.setLocalULC(localData.get("uclData"));
        deviationAnalyzeVo.setLocalLCL(localData.get("lclData"));
        deviationAnalyzeVo.setLocalAverage(localData.get("averageData"));
        deviationAnalyzeVo.setLocalRange(localData.get("rangeData"));


        // 判断是否有厂家数据
        if (CollectionUtils.isNotEmpty(dataAnalysisDto.getSupplierDataList())) {
            List<String> supplierValues = dataAnalysisDto.getSupplierDataList();
            List<Object> absoluteDeviation = new ArrayList<>();
            List<Object> averageList = new ArrayList<>();

            for (int i = 0; i < lastValues.size(); i++) {
                // 判断有值是否为空
                if (StringUtils.isNotBlank(lastValues.get(i)) ||
                        StringUtils.isNotBlank(supplierValues.get(i))) {
                    BigDecimal laseValue = new BigDecimal(lastValues.get(i));
                    BigDecimal supplierValue = new BigDecimal(supplierValues.get(i));

                    // 计算 (B3 - B2)
                    BigDecimal result = laseValue.subtract(supplierValue)
                            .divide(laseValue, 10, RoundingMode.HALF_UP)
                            .abs()
                            .setScale(2, RoundingMode.HALF_UP);

                    absoluteDeviation.add(result);
                } else {
                    absoluteDeviation.add(null);
                }
            }
            // 计算平均值
            List<String> stringList = absoluteDeviation.stream()
                    .map(obj -> obj == null ? "null" : obj.toString())
                    .collect(Collectors.toList());
            BigDecimal average = computeAverage(stringList);
            absoluteDeviation.add(average);
            for (int i = 0; i < 5; i++) {
                averageList.add(average);
            }

            // 计算厂家数据
            Map<String, List<Object>> supplierData = dataCompute(supplierValues);
            deviationAnalyzeVo.setSupplierData(supplierData.get("data"));
            deviationAnalyzeVo.setSupplierULC(supplierData.get("uclData"));
            deviationAnalyzeVo.setSupplierLCL(supplierData.get("lclData"));
            deviationAnalyzeVo.setSupplierAverage(supplierData.get("averageData"));
            deviationAnalyzeVo.setSupplierRange(supplierData.get("rangeData"));
            deviationAnalyzeVo.setAbsoluteDeviation(absoluteDeviation);
            deviationAnalyzeVo.setAverage(averageList);
        }


        return deviationAnalyzeVo;
    }

    /**
     * 查询本月与上月合格率对比
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public List<Map<String, Object>> getRawUpMonth(DataAnalysisDto dataAnalysisDto) {
        return dataAnalysisMapper.getRawUpMonth();
    }

    /**
     * 查询检验项类型饼图
     * @param dataAnalysisDto
     * @return
     */
    @Override
    public Map<String, Object> getOrderTypeCookie(DataAnalysisDto dataAnalysisDto) {
        return dataAnalysisMapper.getOrderTypeCookie();
    }

    /**
     * 计算返回数据
     * @param lastValues
     * @return
     */
    private static Map<String, List<Object>> dataCompute(List<String> lastValues) {
        // 平均值
        BigDecimal average = computeAverage(lastValues);

        // 标准偏差
        BigDecimal standardDeviation = computeStandardDeviation(lastValues);

        // 相对偏差
        BigDecimal relativeDeviation = standardDeviation.divide(average, 2, RoundingMode.HALF_UP);

        // 平均相对偏差
        BigDecimal sqrt5 = BigDecimal.valueOf(Math.sqrt(5));
        BigDecimal averageRelativeDeviation = standardDeviation.divide(sqrt5, 2, RoundingMode.HALF_UP);

        // ucl
        BigDecimal ucl = average.add(new BigDecimal("3").multiply(standardDeviation)).setScale(2, RoundingMode.HALF_UP);

        // lcl
        BigDecimal lcl = average.subtract(new BigDecimal("3").multiply(standardDeviation)).setScale(2, RoundingMode.HALF_UP);

        // 极差
        BigDecimal range = computeRange(lastValues);

        // 数据拼接
        // 检测数据
        List<Object> data = new ArrayList<>();
        for (String lastValue : lastValues) {
            data.add(lastValue);
        }
        data.add(average);
        data.add(standardDeviation);
        data.add(relativeDeviation);
        data.add(averageRelativeDeviation);

        //ucl
        List<Object> uclData = new ArrayList<>();

        //lcl
        List<Object> lclData = new ArrayList<>();

        //平均值
        List<Object> averageData = new ArrayList<>();

        //极差
        List<Object> rangeData = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            uclData.add(ucl);
            lclData.add(lcl);
            averageData.add(average);
            rangeData.add(range);
        }
        Map<String, List<Object>> map = new HashMap<>();
        map.put("data", data);
        map.put("uclData", uclData);
        map.put("lclData", lclData);
        map.put("averageData", averageData);
        map.put("rangeData", rangeData);

        return map;
    }


    /**
     * 计算极差
     * @param lastValues
     * @return
     */
    public static BigDecimal computeRange(List<String> lastValues) {
        int count = 0;

        BigDecimal min = null;
        BigDecimal max = null;

        for (String value : lastValues) {
            if (StrUtil.isNotBlank(value)) {
                BigDecimal bigDecimalValue = new BigDecimal(value);

                if (min == null || bigDecimalValue.compareTo(min) < 0) {
                    min = bigDecimalValue;
                }

                if (max == null || bigDecimalValue.compareTo(max) > 0) {
                    max = bigDecimalValue;
                }
                count++;
            }

        }

        if (count == 0 || min == null || max == null) {
            return BigDecimal.ZERO;
        }

        BigDecimal range = max.subtract(min);

        return range.setScale(2, RoundingMode.HALF_UP);
    }

    /**
     * 计算平均值
     * @param values
     * @return
     */
    private static BigDecimal computeAverage(List<String> values) {
        BigDecimal sum = BigDecimal.ZERO;
        int count = 0;

        for (String value : values) {
            if (StrUtil.isNotBlank(value)) {

                BigDecimal number = new BigDecimal(value);
                sum = sum.add(number);
                count++;

            }
        }

        return count == 0 ? BigDecimal.ZERO : sum.divide(BigDecimal.valueOf(count), 2, BigDecimal.ROUND_HALF_UP);
    }

    /**
     * 计算标准偏差
     * @return
     */
    private static BigDecimal computeStandardDeviation(List<String> lastValues) {
        int count = 0;

        // 将字符串转换为 BigDecimal 列表
        List<BigDecimal> values = new ArrayList<>();
        for (String value : lastValues) {
            if (StrUtil.isNotBlank(value)) {
                values.add(new BigDecimal(value));
                count++;
            }
        }

        if (count == 0) {
            return BigDecimal.ZERO;
        }

        // 计算平均值
        BigDecimal sum = BigDecimal.ZERO;
        for (BigDecimal value : values) {
            sum = sum.add(value);
        }
        BigDecimal mean = sum.divide(new BigDecimal(values.size()), MathContext.DECIMAL128);

        // 计算每个数值与平均值的差的平方
        BigDecimal squaredDifferenceSum = BigDecimal.ZERO;
        for (BigDecimal value : values) {
            BigDecimal difference = value.subtract(mean);
            BigDecimal squaredDifference = difference.multiply(difference);
            squaredDifferenceSum = squaredDifferenceSum.add(squaredDifference);
        }

        // 计算标准差，注意这里使用的是样本标准差计算公式
        BigDecimal variance = squaredDifferenceSum.divide(new BigDecimal(values.size() - 1), MathContext.DECIMAL128);
        BigDecimal stddev = sqrt(variance);

        // 保留两位小数
        return stddev.setScale(2, RoundingMode.HALF_UP);
    }

    private static BigDecimal sqrt(BigDecimal value) {
        // 使用 Heron's method 计算平方根
        BigDecimal x = value;
        BigDecimal tolerance = new BigDecimal("1E-10");
        BigDecimal guess = value.divide(BigDecimal.valueOf(2), MathContext.DECIMAL128);

        while (x.subtract(guess).abs().compareTo(tolerance) > 0) {
            x = guess;
            guess = x.add(value.divide(x, MathContext.DECIMAL128)).divide(new BigDecimal("2"), MathContext.DECIMAL128);
        }

        return guess;
    }

    /**
     * *****格式化字段****
     * @param dataAnalysisDto
     */
    private void formatDataAnalysisDto(DataAnalysisDto dataAnalysisDto) {
        // 格式话字段, 避免报错
        if (StrUtil.isBlank(dataAnalysisDto.getOrderType())) {
            dataAnalysisDto.setOrderType("1");
        }
        if (dataAnalysisDto.getOrderType().equals("2")) {
            // 季度检验
            dataAnalysisDto.setOrderType(InsOrderTypeConstants.QUARTERLY_TEST);
        } else {
            // 进厂检验
            dataAnalysisDto.setOrderType(InsOrderTypeConstants.ENTER_THE_FACTORY);
        }
        if (StrUtil.isBlank(dataAnalysisDto.getDateType())) {
            dataAnalysisDto.setDateType("1");
        }
        if (StrUtil.isBlank(dataAnalysisDto.getGroupType())) {
            dataAnalysisDto.setGroupType("0");
        }
    }

}