Merge remote-tracking branch 'origin/master'

czt

5 天以前 b688c3fe1ecdf645cbc8658139d29f1340acbf4e

 fzzy-igdss-core/src/main/java/com/fzzy/igds/utils/GrainDataBuilder.java

@@ -3,10 +3,7 @@
import com.alibaba.fastjson.JSONObject;
import com.fzzy.igds.constant.Constant;
import com.fzzy.igds.constant.DepotType;
import com.fzzy.igds.data.GrainData;
import com.fzzy.igds.data.GrainLay;
import com.fzzy.igds.data.GrainPoint;
import com.fzzy.igds.data.GrainRow;
import com.fzzy.igds.data.*;
import com.fzzy.igds.domain.DepotConf;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
@@ -19,6 +16,27 @@
 */
@Slf4j
public class GrainDataBuilder {

    /**
     * @param report
     * @param conf   注意当前参数只是为了获取其全局配置参数，不考虑是否与当前粮情信息是否匹配
     * @return
     */
    public static GrainDataReport updateReport(GrainDataReport report, DepotConf conf) {
        // 根据仓库类型不同进行不同调整
        if (DepotType.TYPE_02.getCode().equals(report.getDepotType())) {// 浅圆仓
            buildLays2(report, conf);
        } else if (DepotType.TYPE_03.getCode().equals(report.getDepotType())) {
            buildLays2(report, conf);
        } else if (DepotType.TYPE_04.getCode().equals(report.getDepotType())) {
            buildLays2(report, conf);
        } else {
            buildLays(report);
        }

        report.setPoints(null);
        return report;
    }

    /**
     * 根据单个粮情的数据信息，包括采集点和层信息
@@ -633,4 +651,440 @@

        return temp + "";
    }

    /**
     * 筒仓报表数据封装
     *
     * @param result
     * @param depotConf
     */
    private static void buildLays2(GrainDataReport result, DepotConf depotConf) {

        String points = result.getPoints();
        String cableRule = result.getCable();
        String cableCir = result.getCableCir();
        // 获取布线规则
        if (StringUtils.isEmpty(cableRule) || StringUtils.isEmpty(cableCir)) {
            return;
        }
        if (StringUtils.isEmpty(points)) {
            return;
        }

        // 每一圈列数
        String[] cableRuleAtt = result.getCable().split("-");
        // 每一圈层数
        String[] cableCirAtt = result.getCableCir().split("-");

        if (cableRuleAtt.length != cableCirAtt.length) {
            return;
        }

        // 获取最大的层配置--默认每一圈都一样
        int layMax = Integer.valueOf(cableCirAtt[0]);
        for (int i = 0; i < cableCirAtt.length; i++) {
            if (Integer.valueOf(cableCirAtt[i]) >= layMax) layMax = Integer.valueOf(cableCirAtt[i]);
        }
        result.setMaxZ(layMax);
        List<GrainLay> listLays = new ArrayList<>();// 层数据
        List<GrainPoint> listPoints = new ArrayList<>();
        // 根据层更新层列表信息
        updateListLaysCir(listLays, cableRuleAtt, cableCirAtt, layMax);

        String[] attr = points.split(",");

        GrainPoint point;
        Double tempT;
        GrainLay lay;
        int x = 0, y = 0, z = 1, fz = 0;// x=所在圈，从0开始；y代表电缆根号从0开始，z=代表所在层从1开始
        List<Integer> listErrorTag = new ArrayList<>();// 故障或者错误的点
        List<Integer> listHighTag = new ArrayList<>();// 高温点

        int layNum = layMax;// 当前圈的层数
        int rowNum = 1;// 当前圈的根数
        int index = 0;// 当前温度点的位置
        int startRow = 0;//当前粮情电缆根号
        for (int i = 0; i < cableRuleAtt.length; i++) {
            x = i;
            rowNum = Integer.valueOf(cableRuleAtt[i]);// 根数
            for (int k = 0; k < rowNum; k++) {
                y = k;
                for (int j = 0; j < layNum; j++) {
                    z = j;
                    fz = j + 1;
                    tempT = Double.valueOf(attr[index]);
                    index++;

                    point = new GrainPoint(tempT, x, startRow, z, fz);

                    // 统计每层数据 --初始化数据
                    lay = listLays.get(z);
                    point.setTemp(tempT);
                    listPoints.add(point);

                    if (tempT <= Constant.ERROR_TEMP) {
                        if (tempT != Constant.ADD_TEMP) {
                            lay.setSumNum(lay.getSumNum() - 1);
                        }
                    } else {
                        //判断是否高温优化
                        if (null != depotConf && Constant.YN_Y.equals(depotConf.getGrainAuto())) {

                            lay.setSumTemp(lay.getSumTemp() + tempT);
                            // 层最高最低
                            if (tempT > lay.getTempMax()) {
                                lay.setTempMax(tempT);
                            }
                            if (tempT < lay.getTempMin()) {
                                lay.setTempMin(tempT);
                            }

                        } else {
                            lay.setSumTemp(lay.getSumTemp() + tempT);
                            // 层最高最低
                            if (tempT > lay.getTempMax()) {
                                lay.setTempMax(tempT);
                            }
                            if (tempT < lay.getTempMin()) {
                                lay.setTempMin(tempT);
                            }
                        }
                    }
                    if (tempT == Constant.ERROR_TEMP || tempT == Constant.FAULT_TEMP) {
                        listErrorTag.add(listPoints.size() - 1);
                    }
                }

                startRow++;
            }

        }

        Double maxTemp = -50.0; //比较最高温
        // 调整层信息
        for (GrainLay detail : listLays) {
            if (0 != detail.getSumNum()) {
                detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
                detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
                        1));
            }

            if (0 != detail.getSumInNum()) {
                detail.setTempAveIn(detail.getSumInTemp()
                        / detail.getSumInNum());
                detail.setTempAveIn(NumberUtil.keepPrecision(
                        detail.getTempAveIn(), 1));
            }

            if (0 != detail.getSumOutNum()) {
                detail.setTempAveOut(detail.getSumOutTemp()
                        / detail.getSumOutNum());
                detail.setTempAveOut(NumberUtil.keepPrecision(
                        detail.getTempAveOut(), 1));
            }
            //过滤掉比较的最大最小的值50和-50
            if (detail.getTempMax() == -50) {
                detail.setTempMax(0.0);
            }
            if (detail.getTempMin() == 50) {
                detail.setTempMin(0.0);
            }
            if (listHighTag.size() > 0) {
                if (detail.getTempMax() > maxTemp) {
                    maxTemp = detail.getTempMax();
                }
            }
            // 将层数据转换为行数据
            updateReportLayInfo(result, detail);
        }
    }

    private static void buildLays(GrainDataReport report) {
        String points = report.getPoints();
        String cable = report.getCable();
        // 获取布线规则
        if (StringUtils.isEmpty(cable)) {
            return;
        }
        if (StringUtils.isEmpty(points)) {
            return;
        }

        String[] attr = cable.split("-");
        int cableZ = Integer.valueOf(attr[0]);
        int cableY = Integer.valueOf(attr[1]);
        int cableX = Integer.valueOf(attr[2]);
        report.setMaxZ(cableZ);
        List<GrainPoint> listPoints = new ArrayList<GrainPoint>();
        List<GrainLay> listLays = initDetail(cableX, cableY, cableZ);

        attr = points.split(",");

        GrainPoint point;
        Double tempT;
        GrainLay lay;
        List<Integer> listErrorTag = new ArrayList<>();// 故障或者错误的点
        Double sumAll = 0.0;

        Double sumAllTemp = 0.0;

        int sumAllNum = 0;
        int x = 0, y = 0, z = 0, fz = 0;
        for (int i = 0; i < attr.length; i++) {
            z = i % cableZ;
            fz = z + 1;
            x = i / (cableZ * cableY);
            y = x * (cableZ * cableY);
            y = (i - y) / cableZ;

            // 倒转X轴
            x = cableX - 1 - x;

            tempT = Double.valueOf(attr[i]);
            point = new GrainPoint(tempT, x, y, z, fz);

            // 统计每层数据 --初始化数据
            lay = listLays.get(z);

            if (tempT <= Constant.ERROR_TEMP) {
                listErrorTag.add(i);

                lay.setSumNum(lay.getSumNum() - 1);

                if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
                    lay.setSumOutNum(lay.getSumOutNum() - 1);
                } else {
                    lay.setSumInNum(lay.getSumInNum() - 1);
                }
            } else {
                sumAllTemp += tempT;

                if (tempT > report.getTempMax()) {
                    report.setTempMax(tempT);
                }

                // 层行列补充
                lay.setSumTemp(lay.getSumTemp() + tempT);

                if (x == (cableX - 1) || y == (cableY - 1) || x == 0 || y == 0) {
                    lay.setSumOutTemp(lay.getSumOutTemp() + tempT);
                } else {
                    lay.setSumInTemp(lay.getSumInTemp() + tempT);
                }

                // 层最高最低
                if (tempT > lay.getTempMax()) {
                    lay.setTempMax(tempT);
                }
                if (tempT < lay.getTempMin()) {
                    lay.setTempMin(tempT);
                }

                // log.info("----温度点={}",tempT);
                sumAll += tempT;
                sumAllNum = sumAllNum + 1;
                point.setTemp(tempT);
            }

            listPoints.add(point);
        }

        // 调整层信息
        for (GrainLay detail : listLays) {
            if (0 != detail.getSumNum()) {
                detail.setTempAve(detail.getSumTemp() / detail.getSumNum());
                detail.setTempAve(NumberUtil.keepPrecision(detail.getTempAve(),
                        1));
            }

            if (0 != detail.getSumInNum()) {
                detail.setTempAveIn(detail.getSumInTemp()
                        / detail.getSumInNum());
                detail.setTempAveIn(NumberUtil.keepPrecision(
                        detail.getTempAveIn(), 1));
            }

            if (0 != detail.getSumOutNum()) {
                detail.setTempAveOut(detail.getSumOutTemp()
                        / detail.getSumOutNum());
                detail.setTempAveOut(NumberUtil.keepPrecision(
                        detail.getTempAveOut(), 1));
            }

            // 将层数据转换为行数据
            updateReportLayInfo(report, detail);
        }
    }

    private static void updateReportLayInfo(GrainDataReport report, GrainLay lay) {

        if (1 == lay.getFz()) {// 第1层
            report.setZ1(lay.getFz());
            report.setTempAve1(lay.getTempAve() + "");
            report.setTempMax1(lay.getTempMax() + "");
            report.setTempMin1(lay.getTempMin() + "");
        }
        if (2 == lay.getFz()) {// 第2层
            report.setZ2(lay.getFz());
            report.setTempAve2(lay.getTempAve() + "");
            report.setTempMax2(lay.getTempMax() + "");
            report.setTempMin2(lay.getTempMin() + "");
        }

        if (3 == lay.getFz()) {// 第3层
            report.setZ3(lay.getFz());
            report.setTempAve3(lay.getTempAve() + "");
            report.setTempMax3(lay.getTempMax() + "");
            report.setTempMin3(lay.getTempMin() + "");
        }

        if (4 == lay.getFz()) {// 第4层
            report.setZ4(lay.getFz());
            report.setTempAve4(lay.getTempAve() + "");
            report.setTempMax4(lay.getTempMax() + "");
            report.setTempMin4(lay.getTempMin() + "");
        }

        if (5 == lay.getFz()) {// 第5层
            report.setZ5(lay.getFz());
            report.setTempAve5(lay.getTempAve() + "");
            report.setTempMax5(lay.getTempMax() + "");
            report.setTempMin5(lay.getTempMin() + "");
        }
        if (6 == lay.getFz()) {// 第6层
            report.setZ6(lay.getFz());
            report.setTempAve6(lay.getTempAve() + "");
            report.setTempMax6(lay.getTempMax() + "");
            report.setTempMin6(lay.getTempMin() + "");
        }
        if (7 == lay.getFz()) {// 第7层
            report.setZ7(lay.getFz());
            report.setTempAve7(lay.getTempAve() + "");
            report.setTempMax7(lay.getTempMax() + "");
            report.setTempMin7(lay.getTempMin() + "");
        }
        if (8 == lay.getFz()) {// 第8层
            report.setZ8(lay.getFz());
            report.setTempAve8(lay.getTempAve() + "");
            report.setTempMax8(lay.getTempMax() + "");
            report.setTempMin8(lay.getTempMin() + "");
        }
        if (9 == lay.getFz()) {// 第9层
            report.setZ9(lay.getFz());
            report.setTempAve9(lay.getTempAve() + "");
            report.setTempMax9(lay.getTempMax() + "");
            report.setTempMin9(lay.getTempMin() + "");
        }
        if (10 == lay.getFz()) {// 第10层
            report.setZ10(lay.getFz());
            report.setTempAve10(lay.getTempAve() + "");
            report.setTempMax10(lay.getTempMax() + "");
            report.setTempMin10(lay.getTempMin() + "");
        }
        if (11 == lay.getFz()) {// 第11层
            report.setZ11(lay.getFz());
            report.setTempAve11(lay.getTempAve() + "");
            report.setTempMax11(lay.getTempMax() + "");
            report.setTempMin11(lay.getTempMin() + "");
        }
        if (12 == lay.getFz()) {// 第12层
            report.setZ12(lay.getFz());
            report.setTempAve12(lay.getTempAve() + "");
            report.setTempMax12(lay.getTempMax() + "");
            report.setTempMin12(lay.getTempMin() + "");
        }
        if (13 == lay.getFz()) {// 第13层
            report.setZ13(lay.getFz());
            report.setTempAve13(lay.getTempAve() + "");
            report.setTempMax13(lay.getTempMax() + "");
            report.setTempMin13(lay.getTempMin() + "");
        }
        if (14 == lay.getFz()) {// 第14层
            report.setZ14(lay.getFz());
            report.setTempAve14(lay.getTempAve() + "");
            report.setTempMax14(lay.getTempMax() + "");
            report.setTempMin14(lay.getTempMin() + "");
        }
        if (15 == lay.getFz()) {// 第15层
            report.setZ15(lay.getFz());
            report.setTempAve15(lay.getTempAve() + "");
            report.setTempMax15(lay.getTempMax() + "");
            report.setTempMin15(lay.getTempMin() + "");
        }
        if (16 == lay.getFz()) {// 第16层
            report.setZ16(lay.getFz());
            report.setTempAve16(lay.getTempAve() + "");
            report.setTempMax16(lay.getTempMax() + "");
            report.setTempMin16(lay.getTempMin() + "");
        }
        if (17 == lay.getFz()) {// 第17层
            report.setZ17(lay.getFz());
            report.setTempAve17(lay.getTempAve() + "");
            report.setTempMax17(lay.getTempMax() + "");
            report.setTempMin17(lay.getTempMin() + "");
        }
        if (18 == lay.getFz()) {// 第18层
            report.setZ18(lay.getFz());
            report.setTempAve18(lay.getTempAve() + "");
            report.setTempMax18(lay.getTempMax() + "");
            report.setTempMin18(lay.getTempMin() + "");
        }
        if (19 == lay.getFz()) {// 第19层
            report.setZ19(lay.getFz());
            report.setTempAve19(lay.getTempAve() + "");
            report.setTempMax19(lay.getTempMax() + "");
            report.setTempMin19(lay.getTempMin() + "");
        }
        if (20 == lay.getFz()) {// 第20层
            report.setZ20(lay.getFz());
            report.setTempAve20(lay.getTempAve() + "");
            report.setTempMax20(lay.getTempMax() + "");
            report.setTempMin20(lay.getTempMin() + "");
        }
        if (21 == lay.getFz()) {// 第21层
            report.setZ21(lay.getFz());
            report.setTempAve21(lay.getTempAve() + "");
            report.setTempMax21(lay.getTempMax() + "");
            report.setTempMin21(lay.getTempMin() + "");
        }
        if (22 == lay.getFz()) {// 第22层
            report.setZ22(lay.getFz());
            report.setTempAve22(lay.getTempAve() + "");
            report.setTempMax22(lay.getTempMax() + "");
            report.setTempMin22(lay.getTempMin() + "");
        }
        if (23 == lay.getFz()) {// 第23层
            report.setZ23(lay.getFz());
            report.setTempAve23(lay.getTempAve() + "");
            report.setTempMax23(lay.getTempMax() + "");
            report.setTempMin23(lay.getTempMin() + "");
        }
        if (24 == lay.getFz()) {// 第24层
            report.setZ24(lay.getFz());
            report.setTempAve24(lay.getTempAve() + "");
            report.setTempMax24(lay.getTempMax() + "");
            report.setTempMin24(lay.getTempMin() + "");
        }
        if (25 == lay.getFz()) {// 第25层
            report.setZ25(lay.getFz());
            report.setTempAve25(lay.getTempAve() + "");
            report.setTempMax25(lay.getTempMax() + "");
            report.setTempMin25(lay.getTempMin() + "");
        }
    }

    private static List<GrainLay> initDetail(int cableX, int cableY, int cableZ) {
        List<GrainLay> result = new ArrayList<>();
        GrainLay lay;
        for (int i = 1; i <= cableZ; i++) {
            lay = new GrainLay(i, i - 1);
            lay.setSumNum(cableY * cableX);
            lay.setSumInNum((cableY - 2) * (cableX - 2));
            lay.setSumOutNum(2 * cableY + 2 * cableX - 4);
            lay.setTempMin(50.0);
            lay.setTempMax(-50.0);
            result.add(lay);
        }
        return result;
    }
}