fixedvar-results.component.ts

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

import { LogComponent } from "../../components/log/log.component";
import { FixedResults } from "../../results/fixed-results";
import { VarResults } from "../../results/var-results";
import { ResultsGraphComponent } from "../results-graph/results-graph.component";
import { CalculatorResults } from "../../results/calculator-results";
import { Result, cLog } from "jalhyd";
import { NgParameter } from "../../formulaire/ngparam";
import { FixedResultsComponent } from "./fixed-results.component";
import { VarResultsComponent } from "./var-results.component";
import { ResultsComponent } from "./results.component";

@Component({
    selector: "fixedvar-results",
    templateUrl: "./fixedvar-results.component.html",
    styleUrls: [
        "./fixedvar-results.component.scss"
    ]
})
export class FixedVarResultsComponent extends ResultsComponent implements DoCheck {
    /**
     * résultats non mis en forme
     */
    protected _fixedResults: FixedResults;
    protected _varResults: VarResults;

    /**
     * true si les résultats doiventt être remis à jour
     */
    protected _doUpdate = false;

    @ViewChild(FixedResultsComponent, { static: false })
    private fixedResultsComponent: FixedResultsComponent;

    @ViewChild(VarResultsComponent, { static: false })
    private varResultsComponent: VarResultsComponent;

    /**
     * composant journal
     */
    @ViewChild(LogComponent, { static: false })
    private logComponent: LogComponent;

    /**
     * graphique dans le cas d'un paramètre à varier
     */
    @ViewChild(ResultsGraphComponent, { static: false })
    private resultsGraphComponent: ResultsGraphComponent;

    public set results(rs: CalculatorResults[]) {
        this._fixedResults = undefined;
        this._varResults = undefined;
        if (rs !== undefined) {
            for (const r of rs) {
                if (r instanceof FixedResults) {
                    this._fixedResults = r;
                } else
                    if (r instanceof VarResults) {
                        this._varResults = r;
                    }
            }
        }
        this.updateView();
    }

    public updateView() {
        if (this.logComponent) {
            this.logComponent.log = undefined;
        }
        if (this.fixedResultsComponent) {
            this.fixedResultsComponent.results = undefined;
        }
        if (this.varResultsComponent) {
            this.varResultsComponent.results = undefined;
        }
        if (this.resultsGraphComponent) {
            this.resultsGraphComponent.results = undefined;
        }

        // set _doUpdate flag so that results are rebuilt on the next Angular display cycle
        this._doUpdate = false;
        if (this._fixedResults !== undefined) {
            this._doUpdate = this._fixedResults.hasResults || this._fixedResults.hasLog;
        }
        if (this._varResults !== undefined) {
            this._doUpdate = this._doUpdate || this._varResults.hasResults || this._varResults.hasLog;
        }
    }

    public ngDoCheck() {
        if (this._doUpdate) {
            this._doUpdate = !this.updateResults();
        }
    }

    private mergeLog(result: Result, log: cLog) {
        if (result && result.hasLog()) {
            if (result.hasGlobalLog()) {
                log.addLog(result.globalLog);
            } else {
                log.addLog(result.log);
            }
        }
    }

    private get mergedGlobalLogs(): cLog {
        const res = new cLog();
        if (this._fixedResults) {
            this.mergeLog(this._fixedResults.result, res);
        }
        return res;
    }

    /**
     * met à jour l'affichage des résultats
     * @returns true si les résultats ont pu être mis à jour
     */
    protected updateResults() {
        const fixedUpdated = this._fixedResults !== undefined && this.fixedResultsComponent !== undefined;
        if (fixedUpdated) {
            this.fixedResultsComponent.results = this._fixedResults;
        }

        let graphUpdated: boolean;
        let varUpdated: boolean;
        if (this._varResults && this._varResults.hasResults) {
            varUpdated = this.varResultsComponent !== undefined;
            if (varUpdated) {
                this.varResultsComponent.results = this._varResults;
            }

            graphUpdated = this.resultsGraphComponent !== undefined;
            if (graphUpdated) {
                this.resultsGraphComponent.results = this._varResults;
                this.resultsGraphComponent.updateView();
            }
        } else {
            varUpdated = true;
            graphUpdated = true;
        }

        const logUpdated = this.logComponent !== undefined;
        if (logUpdated) {
            this.logComponent.log = this.mergedGlobalLogs;
        }

        return fixedUpdated && varUpdated && logUpdated && graphUpdated;
    }

    /**
     * affichage de la table des résultats fixés
     */
    public get showFixedResults(): boolean {
        return this._fixedResults && this._fixedResults.hasResults;
    }

    /**
     * affichage de la table des résultats variés
     */
    public get showVarResults(): boolean {
        return this._varResults && this._varResults.hasResults;
    }

    public getFixedResultClass(i: number) {
        // tslint:disable-next-line:no-bitwise
        return "result_id_" + String(i & 1);
    }

    public get fixedParams() {
        return this._fixedResults.fixedParameters;
    }

    public get fixedResults() {
        return this._fixedResults;
    }

    public formattedLabel(p: NgParameter): string {
        return CalculatorResults.paramLabel(p, false);
    }

    public get varResults() {
        return this._varResults;
    }

    public get hasResults(): boolean {
        return this._fixedResults !== undefined && this._fixedResults.hasResults;
    }
}