macrorugo-compound-results-table.component.ts

import { Component, ViewChild, ElementRef } from "@angular/core";

import { MacroRugo } from "jalhyd";

import * as XLSX from "xlsx";

import { ApplicationSetupService } from "../../services/app-setup/app-setup.service";
import { I18nService } from "../../services/internationalisation/internationalisation.service";
import { ResultsComponent } from "../fixedvar-results/results.component";
import { MacrorugoCompoundResults } from "../../results/macrorugo-compound-results";

@Component({
    selector: "macrorugo-compound-results-table",
    templateUrl: "./macrorugo-compound-results-table.component.html",
    styleUrls: [
        "./macrorugo-compound-results-table.component.scss"
    ]
})
export class MacrorugoCompoundResultsTableComponent extends ResultsComponent {

    /** résultats non mis en forme */
    private _mrcResults: MacrorugoCompoundResults;

    /** entêtes des colonnes */
    private _headers: string[];

    /** résultats mis en forme */
    private _dataSet: any[];

    @ViewChild("tableContainer", { static: false })
    table: ElementRef;

    constructor(
        protected appSetupService: ApplicationSetupService,
        protected intlService: I18nService
    ) {
        super();
    }

    public set results(r: MacrorugoCompoundResults) {
        this._mrcResults = r;

        this._dataSet = [];
        if (
            this._mrcResults
            && this._mrcResults.childrenResults
            && this._mrcResults.childrenResults.length > 0
            && ! this._mrcResults.hasOnlyErrors()
        ) {
            const pr = this._mrcResults;
            const nDigits = this.appSetupService.displayDigits;
            // when a parameter is variating, index of the variating parameter
            // values to build the data from
            const vi = pr.variableIndex;

            // refresh headers here if language changed
            this._headers = pr.headers;

            // lines 1 - n-1 (aprons)
            for (let i = 0; i < pr.childrenResults.length; i++) {
                // @TODO protect loop contents with if(vCalc) ? Will hide erroneous apron results..
                const res = pr.childrenResults[i].resultElements[vi].values;
                const nub = (pr.childrenResults[i].sourceNub as MacroRugo);
                // does ZF1 or B vary ?
                let zf1: number;
                try {
                    if (nub.prms.ZF1.hasMultipleValues) {
                        zf1 = nub.prms.ZF1.getInferredValuesList()[vi];
                    } else {
                        zf1 = nub.prms.ZF1.singleValue;
                    }
                } catch (e) {
                    // silent fail
                }
                let b: number;
                try {
                    if (nub.prms.B.hasMultipleValues) {
                        b = nub.prms.B.getInferredValuesList()[vi];
                    } else {
                        b = nub.prms.B.singleValue;
                    }
                } catch (e) {
                    // silent fail
                }

                this._dataSet.push([
                    i + 1, // n° radier
                    (zf1 !== undefined ? zf1.toFixed(nDigits) : "-"),
                    (b !== undefined ? b.toFixed(nDigits) : "-"),
                    res.Q.toFixed(nDigits),
                    res.ZF2.toFixed(nDigits),
                    res.Vdeb.toFixed(nDigits),
                    res.Fr.toFixed(nDigits),
                    res.Vmax.toFixed(nDigits),
                    res.PV.toFixed(nDigits),
                    this.intlService.localizeText("INFO_ENUM_MACRORUGOFLOWTYPE_" + res.ENUM_MacroRugoFlowType),
                    res.Q_GuideTech.toFixed(nDigits),
                    (res.V_GuideTech !== undefined ? res.V_GuideTech.toFixed(nDigits) : "-"),
                    res.xCenter.toFixed(nDigits)
                ]);
            }

            // line n (total flow)
            this._dataSet.push([
                this.intlService.localizeText("INFO_LIB_TOTAL"),
                "", "",
                pr.result.resultElements[vi].vCalc.toFixed(nDigits),
                "", "", "", "", "", "", "", "", ""
            ]);
        }
    }

    public get headers() {
        return this._headers;
    }

    /**
     * Returns a combination of parameters and results for mat-table
     */
    public get dataSet() {
        return this._dataSet;
    }

    public exportAsSpreadsheet() {
        // automagic <table> extraction
        const ws: XLSX.WorkSheet = XLSX.utils.table_to_sheet(this.table.nativeElement);
        const wb: XLSX.WorkBook = XLSX.utils.book_new();
        XLSX.utils.book_append_sheet(wb, ws, "default");
        // save and download
        XLSX.writeFile(wb, "MacrorugoCompoundResults.xlsx");
    }

    public get uitextExportAsSpreadsheet() {
        return this.intlService.localizeText("INFO_RESULTS_EXPORT_AS_SPREADSHEET");
    }

    public get uitextEnterFSTitle() {
        return this.intlService.localizeText("INFO_GRAPH_BUTTON_TITLE_ENTER_FS");
    }

    public get uitextExitFSTitle() {
        return this.intlService.localizeText("INFO_GRAPH_BUTTON_TITLE_EXIT_FS");
    }
}