废品情况分析——报表接口开发

分享一个1000行代码的报表接口

1 controller

package cn.cncommdata.report.controller;

import cn.cncommdata.form.vo.BaseVO;
import cn.cncommdata.report.service.IWasteAnalysisService;
import cn.cncommdata.report.service.IXianFengScreenService;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

/**
 * @author meihongliang
 * @since 2020/4/10 10:13 下午
 * 险峰大屏展示需要接口
 */
@RestController
public class ScreenController {

    /**
     * 引入service 接口
     */
    @Resource
    private IWasteAnalysisService wasteAnalysisService;
    /**
     * 废品情况分析——hour/kg
     * <p>
     * 数据来源
     * 工票信息：工票号、计量单位、车间完成工时
     * 不合格品通知单：工票号、生产项目、废品原因分析（10大原因）、综合回用量、责任回用量
     * 不合格品指标管理：废品率-指标、责任废品率-指标、综合回用率-指标、责任回用率-指标
     * <p>
     * 201测试数据
     * tenantId//1189773091425882112
     * grantId//1192291334245978112
     * formIds//{"工票信息": 1237569872439939104,"不合格品通知单": 1237569872439939100,"不合格品指标管理": 1255764697836294144}
     *
     *  202测试数据
     *  tenantId//1189773091425882112
     *  grantId//1192291334245978112
     *  formIds//{"工票信息": 1237569872439939104,"不合格品通知单": 1237569872439939100,"不合格品指标管理": 1257869474644758528}
     *
     * @param tenantId 企业id
     * @param grantId  操作员
     * @param formIds  所需表单id的json对象字符串（内部研发项目、外部研发项目、生产技术准备、产品安装调试、进度计划维护）
     * @return 查询结果
     * @author leimin
     */
    @ApiOperation("废品情况分析——工时/重量")
    @PostMapping("/scm/screen/loss")
    public BaseVO<List<Map<String, Object>>> getLossAnalysis(
            @ApiParam(value = "租户Id", required = true) @RequestHeader("tenant_id") Long tenantId,
            @ApiParam(value = "操作者Id", required = true) @RequestHeader("grant_id") Long grantId,
            @ApiParam(value = "表单id的json对象字符串", required = true) @RequestParam("form_ids") String formIds) {

        return wasteAnalysisService.getLossAnalysis(tenantId, grantId, formIds);
    }
}

2 service

package cn.cncommdata.report.service;

import cn.cncommdata.form.vo.BaseVO;

import java.util.List;
import java.util.Map;

/**
 * @author: leimin
 * @description: 废品分析接口方法
 * @date: 2020-04-28
 */
public interface IWasteAnalysisService {
    /**
     * 工时损失废品分析——小时(hour)
     * <p>
     * 数据来源
     * 工票信息：工票号、计量单位、车间完成工时
     * 不合格品通知单：工票号、生产项目、废品原因分析（10大原因）、综合回用量、责任回用量
     * 各种指标：废品率-指标、责任废品率-指标、综合回用率-指标、责任回用率-指标
     *
     * @param tenantId 企业id
     * @param grantId  操作员
     * @param formIds  所需表单id的json对象字符串（内部研发项目、外部研发项目、生产技术准备、产品安装调试、进度计划维护）
     * @return 查询结果
     * @author leimin
     */
    BaseVO<List<Map<String, Object>>> getLossAnalysis(Long tenantId, Long grantId, String formIds);
}

3 serviceImpl

package cn.cncommdata.report.service.impl;

import cn.cncommdata.form.vo.BaseVO;
import cn.cncommdata.form.vo.FormDataVO;
import cn.cncommdata.form.vo.fielddata.CommonDataVO;
import cn.cncommdata.form.vo.fielddata.DataBaseVO;
import cn.cncommdata.form.vo.fielddata.SelectDataVO;
import cn.cncommdata.form.vo.fielddata.TableDataVO;
import cn.cncommdata.form.vo.fielddata.TableRowVO;
import cn.cncommdata.report.service.IWasteAnalysisService;
import cn.cncommdata.report.util.ReportUtil;
import cn.cncommdata.report.util.TimeUtil;
import cn.cncommdata.report.util.constant.Const;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * @author: leimin
 * @description: 废品分析实现方法
 * @date: 2020-04-28
 */
@Slf4j
@Service
public class WasteAnalysisServiceImpl implements IWasteAnalysisService {
    /**
     * 引入表单工具
     */
    @Resource
    private ReportUtil reportUtil;

    /**
     * 工时损失废品分析——小时(hour)
     * <p>
     * 数据来源
     * 工票信息：工票号、计量单位、车间完成工时
     * 不合格品通知单：工票号、生产项目、废品原因分析（10大原因）、综合回用量、责任回用量
     * 各种指标：废品率-指标、责任废品率-指标、综合回用率-指标、责任回用率-指标
     *
     * @param tenantId 企业id
     * @param grantId  操作员
     * @param formIds  所需表单id的json对象字符串（内部研发项目、外部研发项目、生产技术准备、产品安装调试、进度计划维护）
     * @return 查询结果
     * @author leimin
     */
    @Override
    public BaseVO<List<Map<String, Object>>> getLossAnalysis(Long tenantId, Long grantId, String formIds) {

        // 查询所有，按年分，再按月分
        // 1。表单有不合格品通知单、工票信息
        // 2。查询所有的不合格品通知单、工票，塞选不匹配的数据（不合格品通知单.工票号 不为空）
        // 3。按yyyy-mm-生产项目作为数据的键，然后获取可以直接获取到的数据，同键的数据累加；
        // 4。通过计算规则计算其余的字段；

        // 1。查询表单数据
        List<Object> unqualifiedList, workTicketList, indexList;

        JSONObject metadataIds = JSONObject.parseObject(formIds);
        if (CollectionUtils.isEmpty(metadataIds)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        Long unqualifiedFormId = metadataIds.getLong(Const.NOTICE_OF_UNQUALIFIED_PRODUCT);
        Long workTicketFormId = metadataIds.getLong(Const.WORK_ORDER);
        if (unqualifiedFormId == null || workTicketFormId == null) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        unqualifiedList = reportUtil.getDataList(tenantId, grantId, unqualifiedFormId);
        if (CollectionUtils.isEmpty(unqualifiedList)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }
        workTicketList = reportUtil.getDataList(tenantId, grantId, workTicketFormId);
        if (CollectionUtils.isEmpty(workTicketList)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        Long indexFormId = metadataIds.getLong(Const.INDEX_OF_UNQUALIFIED_PRODUCT);
        if (indexFormId == null) {
            new BaseVO<>(BaseVO.SUCCESS_CODE, "校验成功！");
        }
        indexList = reportUtil.getDataList(tenantId, grantId, indexFormId);


        // 2。筛选数据
        List<FormDataVO> defects = new ArrayList<>();
        List<FormDataVO> workTickets = new ArrayList<>();

        BaseVO baseVo = filterData(unqualifiedList, workTicketList, defects, workTickets);
        if (BaseVO.SUCCESS_CODE != baseVo.getCode()) {
            return baseVo;
        }
        // 组合为所需的数据结构
        HashMap map = new HashMap(Const.SIXTEEN);
        range(defects, workTickets, map);


        // 3。按yyyy-mm-生产项目，作为数据的键，然后获取可以直接获取到的数据，同键的数据累加；
        Map<String, Map<String, Object>> result = new HashMap<>(Const.SIXTEEN);
        middleAnalysis(result, map);

        // 4。计算最终的数据
        lastAnalysis(result, indexList);
        List<Map<String, Object>> list = sortMap(result);
        return new BaseVO<>(BaseVO.SUCCESS_CODE, "校验成功！", list);
    }

    /**
     * 按照给出的顺序排序
     *
     * @param result 排序前
     * @return 排序后
     */
    private List<Map<String, Object>> sortMap(Map<String, Map<String, Object>> result) {

        // 1。找出所有的月分；set
        // 2。然后可以先对所有的月份排序，重新封装
        // 3。遍历月份，解析项目名称和该条数据，加入同类的list；
        // 4。合并

        Set<String> sortSet = new TreeSet<String>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);//降序排列
            }
        });
        Set<String> intKeys = getYearMonth(result, "");
        sortSet.addAll(intKeys);


        List<Map<String, Object>> list = new ArrayList<>();
        for (String key : sortSet) {

            // 生成key
            String yearMonth = key.substring(0, 4) + "-" + key.substring(4);
            for (String project : Const.SORTED_LIST) {
                String finalKey = yearMonth + "-" + project;

                Map<String, Object> map = result.get(finalKey);
                if (CollectionUtils.isEmpty(map)) {
                    continue;
                }
                map.put("key", finalKey);
                list.add(map);
            }

        }
        return list;
    }

    /**
     * 计算最终的数据
     * 1。合并行
     * 2。注入单元格公式计算
     * 3。注入指标
     *
     * @param middle 半成品数据
     */
    private void lastAnalysis(Map<String, Map<String, Object>> middle, List<Object> indexList) {

        if (CollectionUtils.isEmpty(middle)) {
            return;
        }

        // 1。合并行
        mergeRows(middle);
        // 2。注入单元格公式计算
        calculateByCell(middle);
        // 3。注入指标
        setStandard(middle, indexList);

    }

    /**
     * 给数据中的每一行注入指标
     *
     * @param middle    数据
     * @param indexList 指标对象
     */
    private void setStandard(Map<String, Map<String, Object>> middle, List<Object> indexList) {

        if (CollectionUtils.isEmpty(indexList)) {
            return;
        }

        // 每年的指标必须对应
        // 解析指标，每年，的指标
        Map<String, Map<String, Object>> allIndex = setAllYearIndex(indexList);

        // 遍历每一行：
        // 获取每一行对应的指标
        // 给每一行注入指标
        for (Map.Entry<String, Map<String, Object>> entry : middle.entrySet()) {

            Map<String, Object> row = entry.getValue();
            if (StringUtils.isEmpty(row)) {
                continue;
            }

            String indexKey = intelligenceMatch(row);
            if (StringUtils.isEmpty(indexKey)) {
                continue;
            }

            row.putAll(allIndex.get(indexKey));

        }

    }

    /**
     * 只能获取目标指标的key
     *
     * @param row 当前行数据
     * @return 目标指标的key
     */
    private String intelligenceMatch(Map<String, Object> row) {

        //
        String projectName = (String) row.get(Const.PROJECT);
        String year = (String) row.get(Const.YEAR);

        for (String indexName : Const.PROJECTS) {
            if (indexName.substring(0, 2).equals(projectName.substring(0, 2))) {
                return year + "-" + indexName;
            }
        }
        return null;
    }

    /**
     * 解析每一年的指标，采用健值对形式存储，key=年+行名称，value =每一行的指标
     *
     * @param indexList 所有的指标原属数据
     * @return 解析后的指标，便于读取
     */
    private Map<String, Map<String, Object>> setAllYearIndex(List<Object> indexList) {

        Map<String, Map<String, Object>> allIndex = new HashMap<>(Const.SIXTEEN);

        for (Object object : indexList) {
            if (object == null) {
                continue;
            }

            FormDataVO formDataVO = (FormDataVO) object;
            String timestamp = reportUtil.getStringFromData(formDataVO, Const.YEAR_NUMBER);
            String yearDate = TimeUtil.getStringYear(timestamp);

            //遍历注入指标
            for (String firstField : Const.PROJECTS) {
                Map<String, Object> row = new HashMap<>(Const.SIXTEEN);
                String rowKey = yearDate + "-" + firstField;

                TableDataVO tableDataVO = (TableDataVO) formDataVO.getData().get(firstField);
                TableRowVO tableRowVO = tableDataVO.getValue().get(0);
                for (Map.Entry<String, DataBaseVO> entry : tableRowVO.getValue().entrySet()) {

                    CommonDataVO commonDataVO = (CommonDataVO) entry.getValue();
                    String value = commonDataVO.getValue();

                    row.put(entry.getKey(), stob(value));
                }

                allIndex.put(rowKey, row);
            }

        }

        return allIndex;
    }

    /**
     * 注入单元格公式计算，更具单元格之间的计算规则，计算未知的单元格的值
     *
     * @param middle 已知的单于格
     */
    private void calculateByCell(Map<String, Map<String, Object>> middle) {

        for (Map.Entry<String, Map<String, Object>> entry : middle.entrySet()) {

            Map<String, Object> row = entry.getValue();
            if (CollectionUtils.isEmpty(row)) {
                continue;
            }

            String projectName = (String) row.get(Const.PROJECT);
            boolean isWeight = isWeight(projectName);

            // 1。责任废品量(21)
            // 2。废品量(4)
            // 3。实际工作量(5)
            // 4。实际 废品率(7)

            setResponseWasteAmount(isWeight, row);
            setWasteAmount(isWeight, row);
            setActualWorkAmount(row);
            setDivideValue(row, Const.ACTUAL_WASTE_RATE, Const.WASTE_NUMBER, Const.ACTUAL_WORK_AMOUNT);

            // 5。实际 责任废品率(23)
            // 6。实际 综合回用率(26)
            // 7。实际 责任回用率(29)

            setDivideValue(row, Const.ACTUAL_RESPONSIBLE_WASTE_RATE, Const.RESPONSIBLE_WASTE_AMOUNT, Const.ACTUAL_WORK_AMOUNT);
            setDivideValue(row, Const.ACTUAL_COMPREHENSIVE_REUSE_RATE, Const.COMPREHENSIVE_AMOUNT, Const.ACTUAL_WORK_AMOUNT);
            setDivideValue(row, Const.ACTUAL_RESPONSIBLE_REUSE_RATE, Const.RESPONSIBLE_AMOUNT, Const.ACTUAL_WORK_AMOUNT);

        }
    }

    /**
     * 计算son/mom的结果，再放入row，target健对应的值
     *
     * @param row    map
     * @param target 健
     * @param son    分子的健
     * @param mom    分母的健
     */
    private void setDivideValue(Map<String, Object> row, String target, String son, String mom) {

        // 计算需要的子数据
        // 计算主数据
        // 封装主数据
        BigDecimal sonValue = getRowValue(row, son);
        BigDecimal momValue = getRowValue(row, mom);
        if (BigDecimal.ZERO.equals(momValue)) {

            if (BigDecimal.ZERO.equals(sonValue)) {
                row.put(target, BigDecimal.ZERO);
            } else {
                row.put(target, BigDecimal.ONE);
            }
        } else {
            row.put(target, sonValue.divide(momValue, 2, RoundingMode.UP));
        }

    }

    /**
     * 计算并封装实际工作量
     *
     * @param row 封装数据对象
     */
    private void setActualWorkAmount(Map<String, Object> row) {


        // 计算需要的子数据
        // 计算主数据
        // 封装主数据
        BigDecimal workAmount = getRowValue(row, Const.WORKSHOP_TASK);
        BigDecimal wasteAmount = getRowValue(row, Const.WASTE_NUMBER);

        row.put(Const.ACTUAL_WORK_AMOUNT, workAmount.add(wasteAmount));
    }

    /**
     * 获取健值对的值
     *
     * @param row map
     * @param key 健
     * @return 值
     */
    private BigDecimal getRowValue(Map<String, Object> row, String key) {

        Object o = row.get(key);
        if (o == null) {
            return BigDecimal.ZERO;
        } else {
            String valueString = o.toString();
            if (StringUtils.isEmpty(valueString)) {
                return BigDecimal.ZERO;
            } else {
                return new BigDecimal(valueString);
            }
        }
    }

    /**
     * 计算并封装责任废品量
     *
     * @param isWeight 操作类型
     * @param row      封装对象
     */
    private void setWasteAmount(boolean isWeight, Map<String, Object> row) {

        // 计算需要的子数据
        // 计算主数据
        // 封装主数据

        BigDecimal wasteAmount;
        if (isWeight) {
            wasteAmount = getRowValue(row, Const.RESPONSIBLE_WASTE_AMOUNT);
        } else {
            BigDecimal badDesign = getRowValue(row, Const.POOR_DESIGNER);
            BigDecimal poorSpecif = getRowValue(row, Const.POOR_SPECIFICATION);
            BigDecimal poorFix = getRowValue(row, Const.POOR_FIXTURE);
            BigDecimal poorHeatTreat = getRowValue(row, Const.POOR_HEAT_TREATMENT);
            BigDecimal improperInspect = getRowValue(row, Const.IMPROPER_INSPECTION);

            BigDecimal equipmentFail = getRowValue(row, Const.EQUIPMENT_FAILURE);
            BigDecimal poorRaw = getRowValue(row, Const.POOR_RAW_MATERIAL);
            BigDecimal poorForge = getRowValue(row, Const.POOR_FORGING_BLANK);
            BigDecimal others = getRowValue(row, Const.OTHER_ELSE);
            BigDecimal poorCast = getRowValue(row, Const.POOR_CASTING_BLANK);

            BigDecimal responseAmount = getRowValue(row, Const.RESPONSIBLE_WASTE_AMOUNT);

            wasteAmount = badDesign.add(poorSpecif).add(poorFix).add(poorHeatTreat).add(improperInspect).
                    add(equipmentFail).add(poorRaw).add(poorForge).add(others).add(poorCast).add(responseAmount);

        }

        row.put(Const.WASTE_NUMBER, wasteAmount);
    }

    /**
     * 计算并封装责任废品量
     *
     * @param isWeight 操作类型
     * @param row      封装对象
     */
    private void setResponseWasteAmount(boolean isWeight, Map<String, Object> row) {

        // 计算需要的子数据
        // 计算主数据
        // 封装主数据

        BigDecimal responseWasteAmount;
        if (isWeight) {
            //内废/外废求和
            BigDecimal in = getRowValue(row, Const.INTERNAL_WASTE);
            BigDecimal out = getRowValue(row, Const.EXTERNAL_WASTE);
            responseWasteAmount = in.add(out);
        } else {

            BigDecimal careless = getRowValue(row, Const.CARELESS);
            BigDecimal orderViolate = getRowValue(row, Const.SPECIFICATION_VIOLATION);
            BigDecimal poorLeader = getRowValue(row, Const.POOR_LEADER);

            responseWasteAmount = careless.add(orderViolate).add(poorLeader);
        }

        row.put(Const.RESPONSIBLE_WASTE_AMOUNT, responseWasteAmount);
    }

    /**
     * 获取年月
     *
     * @param middle 数据源
     * @return 结果
     */
    private Set<String> getYearMonth(Map<String, Map<String, Object>> middle, String tag) {

        Set<String> yearMonth = new HashSet<>(Const.SIXTEEN);
        if (CollectionUtils.isEmpty(middle)) {
            return yearMonth;
        }

        for (Map.Entry<String, Map<String, Object>> entry : middle.entrySet()) {

            if (CollectionUtils.isEmpty(entry.getValue())) {
                continue;
            }
            Object yObj = entry.getValue().get(Const.YEAR);
            Object mObj = entry.getValue().get(Const.MONTH);
            if (yObj == null && mObj == null) {
                continue;
            }
            String year = yObj == null ? "0000" : (String) yObj;
            String month = mObj == null ? "00" : (String) mObj;
            String key = "-".equals(tag) ? year + "-" + month : year + month;
            yearMonth.add(key);
        }
        return yearMonth;
    }

    /**
     * 合并 每个月的金一、金二
     *
     * @param middle 数据
     */
    private void mergeRows(Map<String, Map<String, Object>> middle) {

        // 1。先找出所有的月
        // 2。找出每个月中的厂，及他们的数据
        // 3。合并每个月对应的厂，重新封装
        // 4。返回
        Set<String> yearMonth = getYearMonth(middle, "-");

        for (String key : yearMonth) {

            // 生成key
            String keyOne = key + "-" + Const.METAL_WORKSHOP_ONE;
            String keyTwo = key + "-" + Const.METAL_WORKSHOP_TWO;

            // 取出来
            Map<String, Object> rowOne = middle.get(keyOne);
            Map<String, Object> rowTwo = middle.get(keyTwo);
            if (CollectionUtils.isEmpty(rowOne) && CollectionUtils.isEmpty(rowTwo)) {
                continue;
            }
            // 组合
            Map<String, Object> rowLast = mergeTwo(rowOne, rowTwo);
            // 放回去
            middle.put(key + "-" + Const.REJECT_RATE_OF_MECHINING, rowLast);
        }

    }

    /**
     * 合并两行数据
     *
     * @param rowOne 第一行
     * @param rowTwo 第二行
     * @return 合并后的数据
     */
    private Map<String, Object> mergeTwo(Map<String, Object> rowOne, Map<String, Object> rowTwo) {


        // 深度复制
        if (CollectionUtils.isEmpty(rowOne) && !CollectionUtils.isEmpty(rowTwo)) {

            return deepCopy(rowTwo);
        }
        if (!CollectionUtils.isEmpty(rowOne) && CollectionUtils.isEmpty(rowTwo)) {

            return deepCopy(rowOne);
        }

        // 深度复制
        Map<String, Object> rowLast = new HashMap<>(Const.SIXTEEN);
        for (Map.Entry<String, Object> entry : rowOne.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (Const.ONCE_LIST.contains(key)) {

                String valueString = value == null ? "" : value.toString();
                rowLast.put(key, valueString);

            } else {
                BigDecimal valueOne;
                if (value == null) {
                    valueOne = BigDecimal.ZERO;
                } else {
                    valueOne = new BigDecimal(value.toString());
                }

                BigDecimal valueTwo;
                if (rowTwo.get(key) == null) {
                    valueTwo = BigDecimal.ZERO;
                } else {
                    valueTwo = new BigDecimal(rowTwo.get(key).toString());
                }

                if (valueOne.equals(BigDecimal.ZERO) && valueTwo.equals(BigDecimal.ZERO)) {
                    continue;
                }

                rowLast.put(key, valueOne.add(valueTwo));
            }
        }

        rowLast.put(Const.PROJECT, Const.REJECT_RATE_OF_MECHINING);
        return rowLast;
    }

    /**
     * 深度复制map
     *
     * @param rowOne 原始的map
     * @return 复制的对象
     */
    private Map<String, Object> deepCopy(Map<String, Object> rowOne) {

        //
        Map<String, Object> rowNew = new HashMap<>(Const.SIXTEEN);
        for (Map.Entry<String, Object> entry : rowOne.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();

            if (Const.ONCE_LIST.contains(key)) {
                // new string
                String valueString = value == null ? "" : value.toString();
                rowNew.put(key, valueString);

            } else {
                // new BigDecimal
                BigDecimal valueOne;
                if (value == null) {
                    valueOne = BigDecimal.ZERO;
                } else {
                    valueOne = new BigDecimal(value.toString());
                }
                rowNew.put(key, valueOne);
            }
        }

        rowNew.put(Const.PROJECT, Const.REJECT_RATE_OF_MECHINING);
        return rowNew;
    }

    /**
     * 初步解析数据
     * <p>
     * 工时损失废品分析——小时(hour)
     * <p>
     * 数据来源
     * 工票信息：工票号、计量单位、车间完成工时
     * 不合格品通知单：工票号、生产项目、废品原因分析（10大原因）、综合回用量、责任回用量
     * 各种指标：废品率-指标、责任废品率-指标、综合回用率-指标、责任回用率-指标
     *
     * @param middle  结果封装
     * @param results 工票信息和不合格品数据
     */
    private void middleAnalysis(Map<String, Map<String, Object>> middle, Map<String, Map<String, FormDataVO>> results) {

        if (CollectionUtils.isEmpty(results)) {
            return;
        }

        // 需要计算的数据
        // 1。总工时=准备工时+加工工时*生产数量
        // 2。综合回用量（h）=总工时/派工数量*车间总回用数量(四个回用数求和)-责任回用工时(不合格品通知单)
        //    综合回用量（kg）=加工工时*车间总回用数量（截图包括的回用数）-责任回用重量
        // 3。责任回用量（h）=责任回用工时
        //    责任回用重量（kg）=责任回用数*加工工时
        // 4。内废/外废（kg） = 报废数量*工票上加工工时


        //封装数据类型
        for (Map.Entry<String, Map<String, FormDataVO>> entry : results.entrySet()) {


            FormDataVO defectData = entry.getValue().get(Const.NOTICE_OF_UNQUALIFIED_PRODUCT);
            FormDataVO ticketData = entry.getValue().get(Const.WORK_ORDER);
            String projectName = reportUtil.getStringFromData(defectData, Const.PROJECT);
            if (StringUtils.isEmpty(projectName)) {
                continue;
            }

            boolean isWeight = isWeight(projectName);

            String timeStamp = reportUtil.getStringFromData(defectData, Const.CREATE_DATE);
            String year = TimeUtil.getStringYear(timeStamp);
            String month = TimeUtil.getStringMonth(timeStamp);
            String finalKey = year + "-" + month + "-" + projectName;


            Map<String, Object> map = middle.get(finalKey);
            boolean isEmpty = false;
            if (CollectionUtils.isEmpty(map)) {
                isEmpty = true;
                map = new HashMap<>(Const.SIXTEEN);

                map.put(Const.YEAR, year);
                map.put(Const.MONTH, month);
                map.put(Const.PROJECT, projectName);
                map.put(Const.UNIT, isWeight ? Const.KG : Const.HOUR);
            }

            // 1。总工时=准备工时+加工工时*派工数量
            BigDecimal totalHour = countAndSetWorkHour(ticketData, isEmpty, map);
            // 2。设置综合回用量
            setComprehensiveAmount(defectData, ticketData, isEmpty, map, isWeight, totalHour);
            // 3。责任回用工时;责任回用重量=“责任回用数”*加工工时
            setResponseAmount(defectData, ticketData, isEmpty, map, isWeight);

            // 4。
            if (isWeight) {
                //内废/外废（kg） = 报废数量*工票上加工工时
                setWeight(defectData, ticketData, isEmpty, map);

            } else {
                // 十大原因
                for (String fieldName : Const.HOUR_WASTE_CASE) {
                    setSecondDataIntoMap(isEmpty, map, fieldName, defectData);
                }
            }

            middle.put(finalKey, map);
        }

    }

    /**
     * 计算并设置责任回用量
     *
     * @param defectData 不合格品数据
     * @param ticketData 工票信息
     * @param isEmpty    唯一主键是否有值，true 有值，增量操作，false全量操作
     * @param map        数据封装对象
     * @param isWeight   重量计算还是工时计算，true 重量
     */
    private void setResponseAmount(FormDataVO defectData, FormDataVO ticketData, boolean isEmpty, Map<String, Object> map,
                                   boolean isWeight) {

        BigDecimal workDecimal = getBigDecimalFromData(ticketData, Const.MAN_HOUR);

        BigDecimal responseAmount;

        if (isWeight) {
            responseAmount = getResponseReuseWeight(workDecimal, defectData);
        } else {
            responseAmount = getBigDecimalFromData(defectData, Const.RESPONSIBLE_REUSE_HOUR);

        }

        setMap(isEmpty, map, Const.RESPONSIBLE_AMOUNT, responseAmount);

    }

    /**
     * 获取数字类型的值
     *
     * @param formDataVO 所有数据
     * @param fieldName  字段名称
     * @return 数字类型的值
     */
    private BigDecimal getBigDecimalFromData(FormDataVO formDataVO, String fieldName) {

        String responseReuseHour = reportUtil.getStringFromData(formDataVO, fieldName);
        return stob(responseReuseHour);
    }

    /**
     * 计算并设置综合回用量
     *
     * @param defectData 不合格品数据
     * @param ticketData 工票信息
     * @param isEmpty    唯一主键是否有值，true 有值，增量操作，false全量操作
     * @param map        数据封装对象
     * @param isWeight   重量计算还是工时计算，true 重量
     * @param totalHour  当前工票的总工时
     */
    private void setComprehensiveAmount(FormDataVO defectData, FormDataVO ticketData, boolean isEmpty, Map<String, Object> map,
                                        boolean isWeight, BigDecimal totalHour) {

        // 重量计算时：综合回用量=总工时/派工数量*车间总回用数量(四个回用数求和)-责任回用工时(不合格品通知单)
        // 以公斤为单位时，综合回用量=加工工时*车间总回用数量（截图包括的回用数）-责任回用重量

        BigDecimal workNum = getBigDecimalFromData(ticketData, Const.TASK_NUMBER);

        BigDecimal directReuseNum = getBigDecimalFromData(defectData, Const.DIRECT_REUSE_NUMBER);
        BigDecimal applyReuseNum = getBigDecimalFromData(defectData, Const.APPLY_REUSE_NUMBER);
        BigDecimal partReuseNum = getBigDecimalFromData(defectData, Const.PART_REUSE_NUMBER);
        BigDecimal repairReuseNum = getBigDecimalFromData(defectData, Const.REPAIR_REUSE_NUMBER);

        BigDecimal totalReuseNumber = directReuseNum.add(applyReuseNum).add(partReuseNum).add(repairReuseNum);

        BigDecimal comprehensiveAmount;
        if (isWeight) {
            BigDecimal responseNum = getBigDecimalFromData(defectData, Const.RESPONSIBLE_REUSE_HOUR);

            comprehensiveAmount = totalHour.divide(workNum, 2, RoundingMode.HALF_UP).multiply(totalReuseNumber).subtract(responseNum);
        } else {
            BigDecimal workDecimal = getBigDecimalFromData(ticketData, Const.MAN_HOUR);

            comprehensiveAmount = workDecimal.multiply(totalReuseNumber).
                    subtract(getResponseReuseWeight(workDecimal, defectData));
        }

        setMap(isEmpty, map, Const.COMPREHENSIVE_AMOUNT, comprehensiveAmount);
    }

    /**
     * 获取责任回用重量
     *
     * @param workDecimal 加工工时
     * @param defectData  不合格品通知单
     * @return 责任回用重量
     */
    private BigDecimal getResponseReuseWeight(BigDecimal workDecimal, FormDataVO defectData) {

        BigDecimal responseNum = getBigDecimalFromData(defectData, Const.RESPONSIBLE_REUSE_NUMBER);

        return workDecimal.multiply(responseNum);
    }

    /**
     * 计算并新增总工时
     *
     * @param ticketData 工票数据
     * @param isEmpty    之前是否有key相同的数据，true没有
     * @param map        封装的数据对象
     * @return 当前工票总工时
     */
    private BigDecimal countAndSetWorkHour(FormDataVO ticketData, boolean isEmpty, Map<String, Object> map) {

        // 总工时=准备工时+加工工时*派工数量

        BigDecimal prepareTime = getBigDecimalFromData(ticketData, Const.PREPARE_HOUR);
        BigDecimal workTime = getBigDecimalFromData(ticketData, Const.MAN_HOUR);
        BigDecimal workNum = getBigDecimalFromData(ticketData, Const.TASK_NUMBER);


        BigDecimal totalTime = workTime.multiply(workNum).add(prepareTime);

        setMap(isEmpty, map, Const.TOTAL_WORK_HOUR, totalTime);

        return totalTime;
    }

    /**
     * 设置内废外废重量
     *
     * @param defectData 不合格品通知单
     * @param ticketData 工票
     * @param isEmpty    之前是否有key相同的数据，true没有
     * @param map        封装的数据对象
     */
    private void setWeight(FormDataVO defectData, FormDataVO ticketData, boolean isEmpty, Map<String, Object> map) {

        String occurrenceWorkshop = reportUtil.getStringFromData(defectData, Const.OCCURRENCE_WORKSHOP);
        String responsibleWorkshop = reportUtil.getStringFromData(defectData, Const.RESPONSIBLE_WORKSHOP);

        BigDecimal number = getBigDecimalFromData(defectData, Const.WASTE_AMOUNT);
        BigDecimal singleWeight = getBigDecimalFromData(ticketData, Const.MAN_HOUR);
        BigDecimal wasteWeight = singleWeight.multiply(number);

        // 外废
        if (occurrenceWorkshop.equals(responsibleWorkshop)) {
            if (isEmpty) {
                // 加入操作
                map.put(Const.INTERNAL_WASTE, BigDecimal.ZERO);
                map.put(Const.EXTERNAL_WASTE, wasteWeight);
            } else {
                // 增量操作
                BigDecimal out = getRowValue(map, Const.EXTERNAL_WASTE);

                map.put(Const.EXTERNAL_WASTE, wasteWeight.add(out));
            }

            // 内废
        } else {
            if (isEmpty) {
                // 加入操作
                map.put(Const.INTERNAL_WASTE, wasteWeight);
                map.put(Const.EXTERNAL_WASTE, BigDecimal.ZERO);
            } else {
                // 增量操作
                BigDecimal out = getRowValue(map, Const.INTERNAL_WASTE);
                map.put(Const.INTERNAL_WASTE, wasteWeight.add(out));
            }
        }
    }

    /**
     * 判断操作类型
     *
     * @param projectName 项目类型
     * @return true 按kg计算，false 按小时计算
     */
    private Boolean isWeight(String projectName) {

        for (String project : Const.WEIGHT_LIST) {
            if (project.contains(projectName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 向map中加入数据
     *
     * @param isEmpty    是否已经存在数据，（指定key的数据）
     * @param map        数据对象
     * @param key        数据的键
     * @param formDataVO 数据对象
     */
    private void setSecondDataIntoMap(boolean isEmpty, Map<String, Object> map, String key, FormDataVO formDataVO) {

        if (Const.ONCE_LIST.contains(key)) {
            return;
        }

        TableDataVO tableDataVO = (TableDataVO) formDataVO.getData().get(Const.WASTE_REASON_ANALYSIS);
        if (tableDataVO == null) {
            setMap(isEmpty, map, key, BigDecimal.ZERO);
            return;
        }

        String value = "0";
        for (TableRowVO tableRowVO : tableDataVO.getValue()) {

            SelectDataVO selectData = (SelectDataVO) tableRowVO.getValue().get(Const.WASTE_REASON);
            List<String> oneItemList = selectData.getValue();
            if (CollectionUtils.isEmpty(oneItemList)) {
                continue;
            }
            if (key.equals(oneItemList.get(0))) {

                CommonDataVO hour = (CommonDataVO) tableRowVO.getValue().get(Const.WORK_HOUR);
                value = hour.getValue();
                break;
            }
        }

        BigDecimal outValue = stob(value);
        setMap(isEmpty, map, key, outValue);
    }

    /**
     * 方法名称：StringToBigDecimal,简写stob
     * 字符串转BigDecimal
     *
     * @param str 字符串
     * @return 数字类型的值
     */
    private BigDecimal stob(String str) {

        if (StringUtils.isEmpty(str)) {
            return BigDecimal.ZERO;
        } else {
            if (str.contains(Const.HOUR)) {
                return new BigDecimal(str.substring(0, str.length() - 2));
            } else {
                return new BigDecimal(str);
            }
        }
    }

    /**
     * 直接设置数据到map
     *
     * @param isEmpty 唯一主键是否有值，true 有值，增量操作，false全量操作
     * @param map     数据封装map对象
     * @param key     健
     * @param value   值
     */
    private void setMap(boolean isEmpty, Map<String, Object> map, String key, BigDecimal value) {

        if (isEmpty) {
            map.put(key, value);
        } else {
            // 增量操作
            BigDecimal out = getRowValue(map, key);

            map.put(key, value.add(out));
        }
    }

    /**
     * 重新组织数据结构
     *
     * @param defects     不合格品通知单
     * @param workTickets 工票信息
     * @param results     组织结果
     * @return 整理后的数据
     */
    private BaseVO<Map<String, Long>> range(List<FormDataVO> defects, List<FormDataVO> workTickets, Map<String, Map<String, FormDataVO>> results) {

        if (CollectionUtils.isEmpty(workTickets) || CollectionUtils.isEmpty(defects)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        for (FormDataVO formDataVO : defects) {
            String temp = reportUtil.getStringFromData(formDataVO, Const.TICKET);
            if (StringUtils.isEmpty(temp)) {
                continue;
            }
            Map<String, FormDataVO> defMap = new HashMap<>(Const.FOUR);
            for (FormDataVO vo : workTickets) {
                String ticket = reportUtil.getStringFromData(vo, Const.TICKET);
                if (StringUtils.isEmpty(ticket) || !temp.equals(ticket)) {
                    continue;
                }
                defMap.put(Const.NOTICE_OF_UNQUALIFIED_PRODUCT, formDataVO);
                defMap.put(Const.WORK_ORDER, vo);
                break;

            }

            if (CollectionUtils.isEmpty(defMap)) {
                continue;
            }
            results.put(temp, defMap);
        }

        return new BaseVO<>(BaseVO.SUCCESS_CODE, "校验成功！");
    }

    /**
     * 检验参数，并获取原始数据
     *
     * @param unqualifiedList 所有的不合格品通知单
     * @param workTicketList  所有的工票数据
     * @param defects         过滤后的不合格品通知单
     * @param workTickets     过滤后的工票信息
     * @return 校验结果
     */
    private BaseVO<String> filterData(List<Object> unqualifiedList, List<Object> workTicketList,
                                      List<FormDataVO> defects, List<FormDataVO> workTickets) {

        if (CollectionUtils.isEmpty(unqualifiedList) || CollectionUtils.isEmpty(workTicketList)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        Set<String> tickets = new HashSet<>(Const.SIXTEEN);
        for (Object object : unqualifiedList) {
            FormDataVO formDataVO = (FormDataVO) object;
            String temp = reportUtil.getStringFromData(formDataVO, Const.TICKET);
            if (StringUtils.isEmpty(temp)) {
                continue;
            }
            tickets.add(temp);
            defects.add(formDataVO);
        }

        if (CollectionUtils.isEmpty(tickets) || CollectionUtils.isEmpty(defects)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        for (Object object : workTicketList) {
            FormDataVO formDataVO = (FormDataVO) object;
            String temp = reportUtil.getStringFromData(formDataVO, Const.TICKET);
            if (StringUtils.isEmpty(temp) || !tickets.contains(temp)) {
                continue;
            }
            workTickets.add(formDataVO);
        }

        if (CollectionUtils.isEmpty(workTickets)) {
            return new BaseVO<>(BaseVO.ILLEGAL_PARAM_CODE, "参数错误！");
        }

        return new BaseVO<>(BaseVO.SUCCESS_CODE, "校验成功！");
    }

}

4 util

package cn.cncommdata.report.util;

import cn.cncommdata.FormClient;
import cn.cncommdata.form.vo.FormDataVO;
import cn.cncommdata.form.vo.Page;
import cn.cncommdata.form.vo.fielddata.CommonDataVO;
import cn.cncommdata.form.vo.fielddata.DataBaseVO;
import cn.cncommdata.form.vo.fielddata.QuoteDataVO;
import cn.cncommdata.form.vo.fielddata.SelectDataVO;
import cn.cncommdata.metadata.MetadataClient;
import cn.cncommdata.metadata.vo.FormVO;
import cn.cncommdata.report.util.constant.Const;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;
import java.util.Calendar;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 物料统计报表需求form_id
 *
 * @author weihong.zhu
 */
@Component
public class ReportUtil {

    /**
     * 引入元数据
     */
    @Autowired
    private MetadataClient metadataClient;
    /**
     * 引入FormId的Cache
     */
    @Resource
    private FormIdCache idCache;
    /**
     * 导入form客户端
     */
    @Resource
    private FormClient formClient;


    /**
     * 获取表单id
     *
     * @param tenantId     企业id
     * @param formName     表单名称
     * @param reportFormId 报表的formId
     * @return formId
     */
    public Long getFormId(Long tenantId, String formName, Long reportFormId) {

        Long formId = idCache.get(tenantId, formName, reportFormId);
        if (!Objects.isNull(formId)) {
            return formId;
        }
        FormVO formVO = metadataClient.getForm(tenantId, 0L, reportFormId);
        if (Objects.isNull(formVO)) {
            return null;
        }

        Map<String, Long> source = formVO.getSource();
        if (!CollectionUtils.isEmpty(source)) {
            Long sourceFormId = source.get(formName);
            // 存入缓存
            idCache.put(tenantId, formName, reportFormId, sourceFormId);
            return sourceFormId;
        }
        return null;
    }

    /**
     * 获取数据列表
     *
     * @param tenantId 企业id
     * @param grantId  操作员 id
     * @param formId   表单id
     * @return 数据列表
     */
    public List<Object> getDataList(Long tenantId, Long grantId, Long formId) {

        Page<Object> dataList = formClient.getDataList(tenantId, grantId, Const.ALL, formId, null,
                null, null, null, null, Const.ZERO, Const.ZERO, null);
        List<Object> rowsData = dataList.getRows();
        if (StringUtils.isEmpty(rowsData)) {
            return null;
        }

        return rowsData;
    }
    /**
     * 获取数据对象的值
     *
     * @param formDataVO 数据
     * @param fieldName  字段名称
     * @return 字段值
     */
    public String getStringFromData(FormDataVO formDataVO, String fieldName) {
        if (formDataVO.getData().get(fieldName) == null) {
            return "";
        }
        DataBaseVO dataBaseVO = formDataVO.getData().get(fieldName);

        String deliveryTime = "交货时间";
        if (deliveryTime.equals(fieldName)) {
            CommonDataVO commonDataVO = (CommonDataVO) dataBaseVO;
            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(Long.parseLong(commonDataVO.getValue()));

            int month = calendar.get(Calendar.MONTH) + 1;
            String monthStr = month < 10 ? "0" + month : "" + month;
            int day = calendar.get(Calendar.DAY_OF_MONTH);
            String dayStr = day < 10 ? "0" + day : "" + day;

            String dateStr = calendar.get(Calendar.YEAR) + "-" + monthStr + "-" + dayStr;
            return dateStr.substring(2);
        }
        if (Const.SELECT.equals(dataBaseVO.getType())) {
            SelectDataVO selectData = (SelectDataVO) dataBaseVO;
            List<String> oneItemList = selectData.getValue();
            if (!CollectionUtils.isEmpty(oneItemList)) {
                return oneItemList.get(0);
            }else{
                return "";
            }

        } else if (Const.QUOTE.equals(dataBaseVO.getType())) {
            QuoteDataVO quoteData = (QuoteDataVO) dataBaseVO;
            return quoteData.getValue();

        } else {
            CommonDataVO commonDataVO = (CommonDataVO) dataBaseVO;
            return commonDataVO.getValue();
        }
    }

}

5 const

package cn.cncommdata.report.util.constant;

import java.util.Arrays;
import java.util.List;

/**
 * @author LiuLuhao
 * @since 2019/10/22 18:12
 */
public final class Const {

    /**
     * 常量0
     */
    public static final int ZERO = 0;
    /**
     * 常量1
     */
    public static final int ONE = 1;
    /**
     * 常量2
     */
    public static final int TWO = 2;
    /**
     * 常量4
     */
    public static final int FOUR = 4;
    /**
     * 常量9
     */
    public static final int NINE = 9;
    /**
     * 常量10
     */
    public static final int TEN = 10;
    /**
     * 常量12
     */
    public static final int TWELVE = 12;
    /**
     * 常量16
     */
    public static final int SIXTEEN = 16;

    /**
     * 工票信息：工票号、计量单位、车间完成工时
     */
    public static final String WORK_ORDER = "工票信息";
    public static final String TICKET = "工票号";
    public static final String UNIT = "工时单位";
    public static final String WORKSHOP_TASK = "车间完成任务";
    public static final String HOUR = "小时";
    public static final String KG = "kg";

    /**
     * 不合格品指标管理：
     */
    public static final String INDEX_OF_UNQUALIFIED_PRODUCT = "不合格品指标管理";

    /**
     * 不合格品通知单：工票号、生产项目、废品原因分析（10大原因）、综合回用量、责任回用量
     */
    public static final String NOTICE_OF_UNQUALIFIED_PRODUCT = "不合格品通知单";
    public static final String PROJECT = "生产项目";
    public static final String COMPREHENSIVE_AMOUNT = "综合回用量";
    public static final String ACTUAL_COMPREHENSIVE_REUSE_RATE = "实际综合回用率";
    public static final String ACTUAL_RESPONSIBLE_REUSE_RATE = "实际责任回用率";

    public static final String RESPONSIBLE_AMOUNT = "责任回用量";
    public static final String RESPONSIBLE_REUSE_NUMBER = "责任回用数";

    public static final String WASTE_REASON_ANALYSIS = "废品原因分析";
    public static final String WASTE_REASON = "废品原因";

    public static final String WORK_HOUR = "工时";
    public static final String MAN_HOUR = "加工工时";
    public static final String PREPARE_HOUR = "准备工时";
    public static final String TOTAL_WORK_HOUR = "总工时";
    public static final String RESPONSIBLE_REUSE_HOUR = "责任回用工时";

    public static final String TASK_NUMBER = "派工数量";
    public static final String DIRECT_REUSE_NUMBER = "直接回用数";
    public static final String APPLY_REUSE_NUMBER = "申请回用数";
    public static final String PART_REUSE_NUMBER = "配件回用数";
    public static final String REPAIR_REUSE_NUMBER = "返修回用数";
    public static final String WASTE_AMOUNT = "报废数量";
    public static final String WASTE_NUMBER = "废品量";

    public static final String ACTUAL_WORK_AMOUNT = "实际工作量";
    public static final String ACTUAL_WASTE_RATE = "实际废品率";
    public static final String ACTUAL_RESPONSIBLE_WASTE_RATE = "实际责任废品率";

    public static final String OCCURRENCE_WORKSHOP = "发生车间";
    public static final String RESPONSIBLE_WORKSHOP = "责任车间";
    public static final String INTERNAL_WASTE = "内废";
    public static final String EXTERNAL_WASTE = "外废";
    public static final String REJECT_RATE_OF_MECHINING = "机加工工废品率";

    public static final String METAL_WORKSHOP_ONE = "金一";
    public static final String METAL_WORKSHOP_TWO = "金二";
    public static final String RESPONSIBLE_WASTE_AMOUNT = "责任废品量";

    public static final String CARELESS = "粗心大意";
    public static final String SPECIFICATION_VIOLATION = "违反工艺规程";
    public static final String POOR_LEADER = "不真确的指导工作";
    public static final String POOR_DESIGNER = "设计不真确及更改不及时";
    public static final String POOR_SPECIFICATION = "工艺规程不真确";
    public static final String POOR_FIXTURE = "工夹具不良";
    public static final String POOR_HEAT_TREATMENT = "热处理不良";
    public static final String IMPROPER_INSPECTION = "前步检查失当";
    public static final String EQUIPMENT_FAILURE = "设备故障精度不良";
    public static final String POOR_RAW_MATERIAL = "原材料半成品不良";
    public static final String POOR_FORGING_BLANK = "锻件毛坯不良";
    public static final String OTHER_ELSE = "其他";
    public static final String POOR_CASTING_BLANK = "铸件毛坯不良";

    public static final String CREATE_DATE = "创建时间";
    public static final String YEAR = "year";
    public static final String YEAR_NUMBER = "年份";

    public static final String MONTH = "month";

    public static final List<String> PROJECTS = Arrays.asList("机加工工废指标", "金一指标", "金二指标", "机修指标", "工具指标",
            "铆焊指标", "热处理指标", "总铸铁指标", "产铸铁指标", "有色指标", "锻钢指标");
    public static final List<String> WEIGHT_LIST = Arrays.asList("热处理废品率", "总铸铁废品率", "产铸铁废品率", "有色废品率", "锻钢件废品率");
    public static final List<String> SORTED_LIST = Arrays.asList(
            "机加工工废品率", "金一", "金二", "机修废品率", "工具废品率", "铆焊废品率",
            "热处理废品率", "总铸铁废品率", "产铸铁废品率", "有色废品率", "锻钢件废品率");

    public static final List<String> ONCE_LIST = Arrays.asList(Const.YEAR, Const.MONTH, Const.PROJECT, Const.UNIT);

    /**
     * 十大原因
     */
    public static final List<String> HOUR_WASTE_CASE = Arrays.asList(
            Const.CARELESS, Const.SPECIFICATION_VIOLATION, Const.POOR_LEADER, Const.POOR_DESIGNER, Const.POOR_SPECIFICATION,
            Const.POOR_FIXTURE, Const.POOR_HEAT_TREATMENT, Const.IMPROPER_INSPECTION, Const.EQUIPMENT_FAILURE, Const.POOR_RAW_MATERIAL,
            Const.POOR_FORGING_BLANK, Const.OTHER_ELSE, Const.POOR_CASTING_BLANK);

    private Const() {
    }
}