@eqproject/eqp-dynamic-module 2.8.7 → 3.0.0

package/esm2022/lib/components/private/form-statistics/filter-templates/textarea-filter-template/textarea-filter-template.component.mjs

@@ -0,0 +1,111 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { TextMaskEnum } from '../../../../../models/fields/textField.model';
+import { UtilityHelperService } from '../../../../../services/utilityHelper.services';
+import { interval } from 'rxjs';
+import { LogicOperatorText } from '../../../../../models/logicOperator.model';
+import { Statistic } from '../../../../../models/statistic.model';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/input";
+import * as i2 from "@angular/material/form-field";
+import * as i3 from "@angular/material/icon";
+import * as i4 from "@angular/forms";
+import * as i5 from "@angular/common";
+import * as i6 from "@eqproject/eqp-select";
+import * as i7 from "../../../../../directives/speech-to-text/speech-to-text.directive";
+export class TextareaFilterTemplateComponent {
+    //Variabili per l'input vocale
+    isStillRecoginze = false;
+    source = interval(200);
+    newtext;
+    subscription;
+    //variabili esterne per l'input dei campi
+    field;
+    record;
+    STT = true;
+    //variabili per gestire il css della label e del field
+    FieldstyleObj;
+    LabelstyleObj;
+    recordChange = new EventEmitter();
+    InputMaskEnum = TextMaskEnum;
+    filterChange = new EventEmitter();
+    logicOperatorText = LogicOperatorText;
+    selectedLogicOperator;
+    activeCondition = false;
+    constructor() {
+    }
+    ngOnInit() {
+        this.initStyles();
+    }
+    initStyles() {
+        //Funzione per parsare il campo stylecss dell'oggetto field ed applicarlo all'html
+        if (this.field.FieldstyleCSS != null || this.field.FieldstyleCSS != undefined)
+            this.FieldstyleObj = UtilityHelperService.initStyles(this.field.FieldstyleCSS);
+        if (this.field.LabelstyleCSS != null || this.field.LabelstyleCSS != undefined)
+            this.LabelstyleObj = UtilityHelperService.initStyles(this.field.LabelstyleCSS);
+    }
+    getInputType() {
+        switch (this.field.TextMask) {
+            case TextMaskEnum.Email:
+                return 'email';
+            case TextMaskEnum.Password:
+                return 'password';
+            case TextMaskEnum.Telefono:
+                return 'tel';
+            case TextMaskEnum.Url:
+                return 'url';
+            default:
+                return 'text';
+        }
+    }
+    /**
+    * Metodo per emettere l'evento che il valore del record è cambiato.
+    */
+    onFilterChange() {
+        if (this.record[this.field.Name] != null && this.record[this.field.Name] != "" && this.selectedLogicOperator != null) {
+            this.activeCondition = true;
+            this.filterChange.emit(this.generateCondition("active"));
+        }
+        if (this.activeCondition && (this.record[this.field.Name] == null || this.record[this.field.Name] == "" || this.selectedLogicOperator == null)) {
+            this.activeCondition = false;
+            this.filterChange.emit(this.generateCondition("deactivated"));
+        }
+    }
+    /**
+     * Metodo che genera l'oggetto da inviare all'esterno
+     */
+    generateCondition(mode) {
+        let output = new Statistic();
+        if (mode == "active") {
+            output = {
+                key: this.field.Name,
+                value: this.record[this.field.Name],
+                logicoperator: this.selectedLogicOperator,
+                fieldtype: this.field.FieldType
+            };
+        }
+        else {
+            output = {
+                key: this.field.Name,
+                value: null,
+                logicoperator: null,
+                fieldtype: null
+            };
+        }
+        return output;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextareaFilterTemplateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: TextareaFilterTemplateComponent, selector: "textarea-filter-template", inputs: { field: "field", record: "record" }, outputs: { recordChange: "recordChange", filterChange: "filterChange" }, ngImport: i0, template: "<div class=\"row textareaFilterTemplate\">\r\n  <div class=\"col-md-9 valueCol\">\r\n    <mat-form-field [formGroup]=\"field.FormFormGroup\">\r\n      <mat-label class=\"pt-1\" [ngStyle]=\"LabelstyleObj\">\r\n        {{ field.Description }}\r\n      </mat-label>\r\n      <textarea\r\n        [ngStyle]=\"FieldstyleObj\"\r\n        matInput\r\n        [type]=\"getInputType()\"\r\n        [formControlName]=\"field.Name\"\r\n        [readonly]=\"false\"\r\n        [required]=\"false\"\r\n        [(ngModel)]=\"record[field.Name]\"\r\n        (ngModelChange)=\"onFilterChange()\"\r\n      ></textarea>\r\n      <mat-error\r\n        *ngIf=\"\r\n          !field.FormFormGroup.valid &&\r\n          field.FormFormGroup.controls[field.Name].touched\r\n        \"\r\n      >\r\n        Min. Caratteri: {{ field.MinLenght }} - Max. Caratteri:\r\n        {{ field.MaxLenght }}\r\n      </mat-error>\r\n      <mat-icon\r\n        [hidden]=\"!field.Microphone\"\r\n        matSuffix\r\n        SpeechToText\r\n        [(bindedText)]=\"record[field.Name]\"\r\n        style=\"cursor: pointer\"\r\n        >keyboard_voice</mat-icon\r\n      >\r\n    </mat-form-field>\r\n  </div>\r\n  <div class=\"col-md-3 operatorCol\">\r\n    <eqp-select\r\n      [enumData]=\"logicOperatorText\"\r\n      [(ngModel)]=\"selectedLogicOperator\"\r\n      (ngModelChange)=\"onFilterChange()\"\r\n    ></eqp-select>\r\n  </div>\r\n</div>\r\n", styles: [".valueCol{padding-right:0}.operatorCol{padding-left:0}.keyboard_speaking{color:red}::ng-deep .textareaFilterTemplate .operatorCol .mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:#a5afc0!important;min-height:80px!important}::ng-deep .textareaFilterTemplate .operatorCol .mat-mdc-select-value{color:#081c45;font-size:16px;font-weight:700;position:relative;top:-6px}\n"], dependencies: [{ kind: "directive", type: i1.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly"], exportAs: ["matInput"] }, { kind: "component", type: i2.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i2.MatLabel, selector: "mat-label" }, { kind: "directive", type: i2.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i2.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "component", type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: i4.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i4.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i4.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i4.RequiredValidator, selector: ":not([type=checkbox])[required][formControlName],:not([type=checkbox])[required][formControl],:not([type=checkbox])[required][ngModel]", inputs: ["required"] }, { kind: "directive", type: i4.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "directive", type: i4.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i4.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "component", type: i6.EqpSelectComponent, selector: "eqp-select", inputs: ["placeholder", "enumData", "enumDataToExclude", "arrayData", "arrayKeyProperty", "arrayValueProperty", "ngModelOptions", "ngModelInput", "formGroupInput", "formControlNameInput", "isRequired", "isDisabled", "isMultiLanguage", "multilanguagePrefixKey", "isAlphabeticalOrderable", "suffixIcon", "prefixIcon", "isMultiSelect", "showCancelButton", "isSearchable", "noResultSearchText", "isReadonly", "isSearchWhileComposing", "appendToInput", "dropdownPosition", "selectOnTab", "selectAll", "selectAllText", "selectableGroupAsModel", "clearAllText", "customOption", "customLabel", "class", "data"], outputs: ["ngModelInputChange", "formControlChange"] }, { kind: "directive", type: i7.SpeechToTextDirective, selector: "[SpeechToText]", inputs: ["bindedText"], outputs: ["bindedTextChange"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TextareaFilterTemplateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'textarea-filter-template', template: "<div class=\"row textareaFilterTemplate\">\r\n  <div class=\"col-md-9 valueCol\">\r\n    <mat-form-field [formGroup]=\"field.FormFormGroup\">\r\n      <mat-label class=\"pt-1\" [ngStyle]=\"LabelstyleObj\">\r\n        {{ field.Description }}\r\n      </mat-label>\r\n      <textarea\r\n        [ngStyle]=\"FieldstyleObj\"\r\n        matInput\r\n        [type]=\"getInputType()\"\r\n        [formControlName]=\"field.Name\"\r\n        [readonly]=\"false\"\r\n        [required]=\"false\"\r\n        [(ngModel)]=\"record[field.Name]\"\r\n        (ngModelChange)=\"onFilterChange()\"\r\n      ></textarea>\r\n      <mat-error\r\n        *ngIf=\"\r\n          !field.FormFormGroup.valid &&\r\n          field.FormFormGroup.controls[field.Name].touched\r\n        \"\r\n      >\r\n        Min. Caratteri: {{ field.MinLenght }} - Max. Caratteri:\r\n        {{ field.MaxLenght }}\r\n      </mat-error>\r\n      <mat-icon\r\n        [hidden]=\"!field.Microphone\"\r\n        matSuffix\r\n        SpeechToText\r\n        [(bindedText)]=\"record[field.Name]\"\r\n        style=\"cursor: pointer\"\r\n        >keyboard_voice</mat-icon\r\n      >\r\n    </mat-form-field>\r\n  </div>\r\n  <div class=\"col-md-3 operatorCol\">\r\n    <eqp-select\r\n      [enumData]=\"logicOperatorText\"\r\n      [(ngModel)]=\"selectedLogicOperator\"\r\n      (ngModelChange)=\"onFilterChange()\"\r\n    ></eqp-select>\r\n  </div>\r\n</div>\r\n", styles: [".valueCol{padding-right:0}.operatorCol{padding-left:0}.keyboard_speaking{color:red}::ng-deep .textareaFilterTemplate .operatorCol .mdc-text-field--filled:not(.mdc-text-field--disabled){background-color:#a5afc0!important;min-height:80px!important}::ng-deep .textareaFilterTemplate .operatorCol .mat-mdc-select-value{color:#081c45;font-size:16px;font-weight:700;position:relative;top:-6px}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { field: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], recordChange: [{
+                type: Output
+            }], filterChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"textarea-filter-template.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/form-statistics/filter-templates/textarea-filter-template/textarea-filter-template.component.ts","../../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/form-statistics/filter-templates/textarea-filter-template/textarea-filter-template.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, Output } from '@angular/core';\r\nimport { Record } from '../../../../../models/record.model';\r\nimport { TextMaskEnum, TextField } from '../../../../../models/fields/textField.model';\r\nimport { UtilityHelperService } from '../../../../../services/utilityHelper.services';\r\nimport { interval, Subscription } from 'rxjs';\r\nimport { LogicOperatorText } from '../../../../../models/logicOperator.model';\r\nimport { Statistic } from '../../../../../models/statistic.model';\r\n\r\n@Component({\r\n  selector: 'textarea-filter-template',\r\n  templateUrl: './textarea-filter-template.component.html',\r\n  styleUrls: ['./textarea-filter-template.component.scss']\r\n})\r\nexport class TextareaFilterTemplateComponent {\r\n\r\n  //Variabili per l'input vocale\r\n  isStillRecoginze = false;\r\n  source = interval(200);\r\n  newtext: string;\r\n  subscription: Subscription;\r\n  //variabili esterne per l'input dei campi\r\n  @Input() field: TextField;\r\n  @Input() record: Record;\r\n  STT:boolean =true;\r\n  //variabili per gestire il css della label e del field\r\n  FieldstyleObj: any;\r\n  LabelstyleObj: any;\r\n\r\n  @Output() recordChange: EventEmitter<Record> = new EventEmitter<Record>();\r\n  InputMaskEnum = TextMaskEnum;\r\n\r\n  @Output() filterChange: EventEmitter<any> = new EventEmitter<any>();\r\n  logicOperatorText = LogicOperatorText;\r\n  selectedLogicOperator: LogicOperatorText;\r\n  activeCondition: boolean = false;\r\n\r\n  constructor() {\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.initStyles();\r\n  }\r\n  initStyles() {\r\n      //Funzione per parsare il campo stylecss dell'oggetto field ed applicarlo all'html\r\n    if(this.field.FieldstyleCSS != null || this.field.FieldstyleCSS != undefined)   \r\n      this.FieldstyleObj= UtilityHelperService.initStyles(this.field.FieldstyleCSS);\r\n    if(this.field.LabelstyleCSS != null || this.field.LabelstyleCSS != undefined)   \r\n      this.LabelstyleObj = UtilityHelperService.initStyles(this.field.LabelstyleCSS);\r\n }\r\n\r\n  getInputType() {\r\n    switch (this.field.TextMask) {\r\n      case TextMaskEnum.Email:\r\n        return 'email';\r\n      case TextMaskEnum.Password:\r\n        return 'password';\r\n      case TextMaskEnum.Telefono:\r\n        return 'tel';\r\n      case TextMaskEnum.Url:\r\n        return 'url'\r\n      default:\r\n        return 'text';\r\n    }\r\n  }\r\n\r\n/**\r\n* Metodo per emettere l'evento che il valore del record è cambiato.\r\n*/\r\nonFilterChange() {\r\n  if (this.record[this.field.Name] != null && this.record[this.field.Name] != \"\" && this.selectedLogicOperator != null){\r\n    this.activeCondition = true;\r\n    this.filterChange.emit(this.generateCondition(\"active\"));\r\n  }\r\n  if (this.activeCondition && (this.record[this.field.Name] == null || this.record[this.field.Name] == \"\" || this.selectedLogicOperator == null)){\r\n    this.activeCondition = false;\r\n    this.filterChange.emit(this.generateCondition(\"deactivated\"));\r\n  }\r\n}\r\n\r\n/**\r\n * Metodo che genera l'oggetto da inviare all'esterno\r\n */\r\n\r\ngenerateCondition(mode){\r\n  let output:Statistic = new Statistic();\r\n  if (mode == \"active\"){\r\n    output = {\r\n      key: this.field.Name,\r\n      value: this.record[this.field.Name],\r\n      logicoperator: this.selectedLogicOperator,\r\n      fieldtype: this.field.FieldType\r\n    };\r\n  } else {\r\n    output = {\r\n      key: this.field.Name,\r\n      value: null,\r\n      logicoperator: null,\r\n      fieldtype: null\r\n    };\r\n  }\r\n\r\n  return output;\r\n}\r\n\r\n}\r\n","<div class=\"row textareaFilterTemplate\">\r\n  <div class=\"col-md-9 valueCol\">\r\n    <mat-form-field [formGroup]=\"field.FormFormGroup\">\r\n      <mat-label class=\"pt-1\" [ngStyle]=\"LabelstyleObj\">\r\n        {{ field.Description }}\r\n      </mat-label>\r\n      <textarea\r\n        [ngStyle]=\"FieldstyleObj\"\r\n        matInput\r\n        [type]=\"getInputType()\"\r\n        [formControlName]=\"field.Name\"\r\n        [readonly]=\"false\"\r\n        [required]=\"false\"\r\n        [(ngModel)]=\"record[field.Name]\"\r\n        (ngModelChange)=\"onFilterChange()\"\r\n      ></textarea>\r\n      <mat-error\r\n        *ngIf=\"\r\n          !field.FormFormGroup.valid &&\r\n          field.FormFormGroup.controls[field.Name].touched\r\n        \"\r\n      >\r\n        Min. Caratteri: {{ field.MinLenght }} - Max. Caratteri:\r\n        {{ field.MaxLenght }}\r\n      </mat-error>\r\n      <mat-icon\r\n        [hidden]=\"!field.Microphone\"\r\n        matSuffix\r\n        SpeechToText\r\n        [(bindedText)]=\"record[field.Name]\"\r\n        style=\"cursor: pointer\"\r\n        >keyboard_voice</mat-icon\r\n      >\r\n    </mat-form-field>\r\n  </div>\r\n  <div class=\"col-md-3 operatorCol\">\r\n    <eqp-select\r\n      [enumData]=\"logicOperatorText\"\r\n      [(ngModel)]=\"selectedLogicOperator\"\r\n      (ngModelChange)=\"onFilterChange()\"\r\n    ></eqp-select>\r\n  </div>\r\n</div>\r\n"]}

package/esm2022/lib/components/private/graphs/graph/graph.component.mjs

@@ -0,0 +1,186 @@
+import { Component, HostListener, Input } from '@angular/core';
+import * as ss from 'simple-statistics';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@canvasjs/angular-stockcharts";
+export class GraphComponent {
+    datePipe;
+    onResize() {
+        this.loaded = false;
+        this.loadGraph(Math.floor(window.innerWidth / 2));
+    }
+    data = new Array();
+    title = "";
+    trendColor = '#EB0102';
+    mainColor = '#006cad';
+    m; // m of the linear regression
+    q; // q of the linear regression
+    trend; // trend string
+    linearRegression; // variable used to store the linear regression points to plot
+    stockChartOptions;
+    loaded = false;
+    counter = 0;
+    constructor(datePipe) {
+        this.datePipe = datePipe;
+    }
+    ngOnInit() {
+        var self = this;
+        // Aggiustamento e scrittura dati
+        if (this.data.length > 0) {
+            this.loadGraph(Math.floor(window.innerWidth / 2));
+        }
+    }
+    loadGraph(width) {
+        var lastvalue = this.data[0];
+        var firstvalue = this.data[this.data.length - 1];
+        var stockChartMinimum = new Date(firstvalue.x);
+        var stockChartMaximum = new Date(lastvalue.x);
+        var stockChartTitleText = this.title;
+        var stockChartdataPoints = this.data;
+        this.linearRegression = new Array();
+        this.trend = "";
+        stockChartdataPoints.reverse();
+        if (stockChartdataPoints.length > 2) {
+            let x = [];
+            for (let i = 0; i < stockChartdataPoints.length; i++) {
+                x.push([i, stockChartdataPoints[i].y]);
+            }
+            let parameters = ss.linearRegression(x);
+            this.m = parameters.m;
+            this.q = parameters.b;
+            if (this.m > 0) {
+                this.trend += " ↗";
+            }
+            else if (this.m < 0) {
+                this.trend += " ↘";
+            }
+            // console.log(x);
+            // console.log(stockChartdataPoints);
+            for (let i = 0; i < stockChartdataPoints.length; i++) {
+                if (i == 0 || i == stockChartdataPoints.length - 1) {
+                    this.linearRegression.push({ x: stockChartdataPoints[i].x,
+                        y: this.m * i + this.q,
+                        label: stockChartdataPoints[i].label,
+                        name: stockChartdataPoints[i].name
+                    });
+                }
+            }
+            //this.linearRegression.reverse();
+            // console.log(this.linearRegression);
+            // console.log(this.m);
+            // console.log(this.q);
+        }
+        this.stockChartOptions = {
+            theme: 'light2',
+            animationEnabled: true,
+            width: width,
+            height: 500,
+            creditText: "",
+            creditHref: "",
+            title: {
+                text: stockChartTitleText
+            },
+            charts: [{
+                    axisX: {
+                        labelFormatter: this.labelFormatterFunction,
+                    },
+                    data: [
+                        {
+                            toolTipContent: null,
+                            type: 'line',
+                            color: this.trendColor,
+                            showInLegend: true,
+                            legendMarkerType: "none",
+                            markerType: "none",
+                            legendText: "Trend" + this.trend,
+                            dataPoints: this.linearRegression
+                        },
+                        {
+                            type: "spline",
+                            dataPoints: stockChartdataPoints,
+                            color: this.mainColor,
+                        }
+                    ],
+                    culture: "it"
+                }],
+            rangeSelector: {
+                enabled: false
+            },
+            navigator: {
+                slider: {
+                    minimum: stockChartMinimum,
+                    maximum: stockChartMaximum
+                }
+            },
+            options: {
+                responsive: true,
+                maintainAspectRatio: false
+            }
+        };
+        this.loaded = true;
+    }
+    labelFormatterFunction(e) {
+        let label = "";
+        let dirtyLabel;
+        let date = e.value;
+        let newYear = date.getFullYear();
+        let newMonth = date.getMonth() + 1;
+        let newMonthString;
+        if (newMonth < 10) {
+            newMonthString = "0" + newMonth.toString();
+        }
+        else {
+            newMonthString = newMonth.toString();
+        }
+        let newDay = date.getDate();
+        let newDayString;
+        if (newDay < 10) {
+            newDayString = "0" + newDay.toString();
+        }
+        else {
+            newDayString = newDay.toString();
+        }
+        let newHour = date.getHours();
+        let newHourString;
+        if (newHour < 10) {
+            newHourString = "0" + newHour.toString();
+        }
+        else {
+            newHourString = newHour.toString();
+        }
+        let newMinute = date.getMinutes();
+        let newMinuteString;
+        if (newMinute < 10) {
+            newMinuteString = "0" + newMinute.toString();
+        }
+        else {
+            newMinuteString = newMinute.toString();
+        }
+        dirtyLabel = newDayString + "/" + newMonthString + "/" + newYear.toString() + " " + newHourString + ":" + newMinuteString;
+        for (let i = 0; i < 5; i++) {
+            label += dirtyLabel[i];
+        }
+        label += " ";
+        for (let i = 11; i < 16; i++) {
+            label += dirtyLabel[i];
+        }
+        //label = label.replace("00:00","");
+        return label;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GraphComponent, deps: [{ token: i1.DatePipe }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: GraphComponent, selector: "graph", inputs: { data: "data", title: "title" }, host: { listeners: { "window:resize": "onResize($event)" } }, ngImport: i0, template: "<canvasjs-stockchart *ngIf=\"loaded\" [options]=\"stockChartOptions\"></canvasjs-stockchart>\r\n<div class=\"error\" *ngIf=\"!loaded\"><b>{{title}}:</b> Nessun dato trovato nell'intervallo specificato!</div>", styles: [""], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.CanvasJSStockChart, selector: "canvasjs-stockchart", inputs: ["options", "styles"], outputs: ["stockChartInstance"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GraphComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'graph', template: "<canvasjs-stockchart *ngIf=\"loaded\" [options]=\"stockChartOptions\"></canvasjs-stockchart>\r\n<div class=\"error\" *ngIf=\"!loaded\"><b>{{title}}:</b> Nessun dato trovato nell'intervallo specificato!</div>" }]
+        }], ctorParameters: () => [{ type: i1.DatePipe }], propDecorators: { onResize: [{
+                type: HostListener,
+                args: ['window:resize', ['$event']]
+            }], data: [{
+                type: Input,
+                args: ["data"]
+            }], title: [{
+                type: Input,
+                args: ["title"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graph.component.js","sourceRoot":"","sources":["../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/graphs/graph/graph.component.ts","../../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/graphs/graph/graph.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, HostListener, Input, OnInit } from '@angular/core';\r\nimport { Coords } from '../../../../models/graph.model';\r\nimport { DatePipe } from '@angular/common';\r\nimport * as ss from 'simple-statistics';\r\n\r\n\r\n@Component({\r\n  selector: 'graph',\r\n  templateUrl: './graph.component.html',\r\n  styleUrls: ['./graph.component.scss']\r\n})\r\n\r\nexport class GraphComponent implements OnInit {\r\n\r\n  @HostListener('window:resize', ['$event'])\r\n  onResize() {\r\n    this.loaded = false;\r\n    this.loadGraph(Math.floor(window.innerWidth/2));\r\n  }\r\n\r\n  @Input(\"data\") data: Array<Coords> = new Array<Coords>();\r\n  @Input(\"title\") title: string = \"\";\r\n\r\n  trendColor: string = '#EB0102';\r\n  mainColor: string = '#006cad';\r\n\r\n  m: number; // m of the linear regression\r\n  q: number; // q of the linear regression\r\n  trend: string; // trend string\r\n  linearRegression: Array<Coords>; // variable used to store the linear regression points to plot\r\n\r\n\r\n\r\n  stockChartOptions: any;\r\n\r\n  loaded: boolean = false;\r\n  counter: number = 0;\r\n\r\n  constructor(\r\n    private datePipe: DatePipe\r\n    ) {}  \r\n\r\n  ngOnInit() {\r\n\r\n    var self = this;\r\n\r\n    // Aggiustamento e scrittura dati\r\n    if (this.data.length > 0){\r\n      this.loadGraph(Math.floor(window.innerWidth/2));\r\n    }\r\n  }\r\n\r\n  loadGraph(width: number){\r\n\r\n    var lastvalue = this.data[0];\r\n    var firstvalue = this.data[this.data.length-1];\r\n\r\n    var stockChartMinimum = new Date(firstvalue.x);\r\n    var stockChartMaximum = new Date(lastvalue.x);\r\n    var stockChartTitleText = this.title;\r\n    var stockChartdataPoints = this.data;\r\n\r\n    this.linearRegression = new Array<Coords>();\r\n    this.trend = \"\";\r\n\r\n    stockChartdataPoints.reverse();\r\n    if (stockChartdataPoints.length > 2) {\r\n      let x = [];\r\n      for (let i = 0; i<stockChartdataPoints.length; i ++) {\r\n        x.push([i, stockChartdataPoints[i].y]);\r\n      }\r\n      let parameters = ss.linearRegression(x);\r\n      this.m = parameters.m;\r\n      this.q = parameters.b;\r\n      if (this.m > 0) {\r\n          this.trend += \" ↗\";\r\n        } else if (this.m < 0) {\r\n          this.trend += \" ↘\";\r\n      }\r\n      // console.log(x);\r\n      // console.log(stockChartdataPoints);\r\n      \r\n      for (let i = 0; i<stockChartdataPoints.length; i ++) {\r\n        if (i == 0 || i == stockChartdataPoints.length - 1) {\r\n          this.linearRegression.push({x: stockChartdataPoints[i].x,\r\n            y: this.m*i + this.q,\r\n            label: stockChartdataPoints[i].label,\r\n            name: stockChartdataPoints[i].name\r\n          })\r\n        }\r\n      }\r\n      //this.linearRegression.reverse();\r\n      // console.log(this.linearRegression);\r\n      // console.log(this.m);\r\n      // console.log(this.q);\r\n    }\r\n\r\n    this.stockChartOptions = {\r\n      theme: 'light2',\r\n      animationEnabled: true,\r\n      width: width,\r\n      height: 500,\r\n      creditText: \"\",\r\n      creditHref: \"\",\r\n      title: {\r\n        text: stockChartTitleText\r\n      },\r\n      charts: [{\r\n        axisX: {\r\n          labelFormatter: this.labelFormatterFunction,\r\n        },\r\n        data: [\r\n          {\r\n            toolTipContent: null,\r\n            type: 'line',\r\n            color: this.trendColor,\r\n            showInLegend: true,\r\n            legendMarkerType: \"none\",\r\n            markerType: \"none\",\r\n            legendText: \"Trend\" + this.trend,\r\n            dataPoints: this.linearRegression\r\n          },\r\n          {\r\n            type: \"spline\",\r\n            dataPoints: stockChartdataPoints,\r\n            color: this.mainColor,\r\n          }\r\n        ],\r\n        culture: \"it\"\r\n      }],\r\n      rangeSelector: {\r\n        enabled: false\r\n      },\r\n      navigator: {\r\n        slider: {\r\n          minimum: stockChartMinimum,\r\n          maximum: stockChartMaximum\r\n        }\r\n      },\r\n      options: {\r\n        responsive: true,\r\n        maintainAspectRatio: false\r\n      }\r\n    };\r\n\r\n    this.loaded = true;\r\n  }\r\n\r\n  labelFormatterFunction(e) {\r\n    let label = \"\";\r\n    let dirtyLabel;\r\n    let date = e.value;\r\n\r\n      let newYear: number = date.getFullYear();\r\n      let newMonth: number = date.getMonth() + 1;\r\n      let newMonthString: string;\r\n      if (newMonth < 10) {\r\n      newMonthString = \"0\" + newMonth.toString();\r\n      } else {\r\n      newMonthString = newMonth.toString();\r\n      }\r\n      let newDay: number = date.getDate();\r\n      let newDayString: string;\r\n      if (newDay < 10) {\r\n      newDayString = \"0\" + newDay.toString();\r\n      } else {\r\n      newDayString = newDay.toString();\r\n      }\r\n      let newHour: number = date.getHours();\r\n      let newHourString: string;\r\n      if (newHour < 10) {\r\n      newHourString = \"0\" + newHour.toString();\r\n      } else {\r\n      newHourString = newHour.toString();\r\n      }\r\n      let newMinute: number = date.getMinutes();\r\n      let newMinuteString: string;\r\n      if (newMinute < 10) {\r\n      newMinuteString = \"0\" + newMinute.toString();\r\n      } else {\r\n      newMinuteString = newMinute.toString();\r\n      }\r\n\r\n      dirtyLabel = newDayString + \"/\" + newMonthString + \"/\" + newYear.toString() + \" \" + newHourString  + \":\" + newMinuteString;\r\n\r\n      for (let i = 0; i < 5; i++) {\r\n        label += dirtyLabel[i];\r\n      }\r\n      label += \" \";\r\n      for (let i = 11; i < 16; i++) {\r\n        label += dirtyLabel[i];\r\n      }\r\n\r\n      //label = label.replace(\"00:00\",\"\");\r\n    \r\n    return label;\r\n  }  \r\n  \r\n\r\n}\r\n","<canvasjs-stockchart *ngIf=\"loaded\" [options]=\"stockChartOptions\"></canvasjs-stockchart>\r\n<div class=\"error\" *ngIf=\"!loaded\"><b>{{title}}:</b> Nessun dato trovato nell'intervallo specificato!</div>"]}

package/esm2022/lib/components/private/graphs/graphs.component.mjs

@@ -0,0 +1,175 @@
+import { Component, Input } from '@angular/core';
+import { ParamTypeEnum } from '../../../models/endPointConfiguration.model';
+import { Coords, GraphField } from '../../../models/graph.model';
+import { FieldTypeEnum } from '../../../models/baseField.model';
+import { ModeEnum, TimeTypeEnum } from 'tmw-picker';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/utilityHelper.services";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/checkbox";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/card";
+import * as i6 from "@angular/forms";
+import * as i7 from "@eqproject/eqp-select";
+import * as i8 from "tmw-picker";
+import * as i9 from "./graph/graph.component";
+export class GraphsComponent {
+    utilityHelperService;
+    datePipe;
+    configurations;
+    endPointConfiguration;
+    userID;
+    formID = null; // preview
+    form = null; // preview config
+    fieldFormGroup;
+    loaded = false;
+    generated = false;
+    minperiod = new Date();
+    maxperiod = new Date();
+    minperiodS;
+    maxperiodS;
+    fields = new Array();
+    selectedFields;
+    selectedGeneratedFields;
+    answers = null;
+    eligibleAnswers = null;
+    // TMW-PICKER
+    modes = ModeEnum;
+    timeType = TimeTypeEnum;
+    mode;
+    constructor(utilityHelperService, datePipe) {
+        this.utilityHelperService = utilityHelperService;
+        this.datePipe = datePipe;
+    }
+    ngOnInit() {
+        if (this.formID != null) {
+            this.getFormByID();
+        }
+        else {
+            this.loaded = true;
+        }
+    }
+    /**
+     * Metodo per recuperare tutti i record salvati per una particolare Form.
+     * La chiamata viene effettuata solo se è stato configurato l'endPoint da usare.
+     */
+    getFormByID() {
+        if (this.formID &&
+            this.endPointConfiguration &&
+            this.endPointConfiguration.Forms &&
+            this.endPointConfiguration.Forms.GetByIDEndPoint) {
+            const dynamicModuleParams = new Array();
+            dynamicModuleParams.push({
+                ParamName: "id",
+                ParamValue: this.formID,
+                ParamType: ParamTypeEnum["Query param"],
+            });
+            this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Forms.GetByIDEndPoint, dynamicModuleParams, (res) => {
+                this.form = res;
+                this.form.Fields.filter(x => x.FieldType == FieldTypeEnum['Campo numerico']).forEach((field) => {
+                    var graphField = new GraphField();
+                    graphField.Name = field.Label;
+                    graphField.Description = field.Description;
+                    this.fields.push(graphField);
+                });
+                this.getRecordsByFormID();
+            }, (err) => {
+            });
+        }
+    }
+    async getRecordsByFormID() {
+        var dynamicModuleParams = [
+            {
+                ParamName: "EntID",
+                ParamValue: this.form.ID,
+                ParamType: ParamTypeEnum["Query param"],
+            },
+        ];
+        if (this.configurations.userID == null &&
+            this.endPointConfiguration &&
+            this.endPointConfiguration.Records &&
+            this.endPointConfiguration.Records.GetByFormIDEndPoint) {
+            // se non conosco l'utente
+            this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetByFormIDEndPoint, dynamicModuleParams, (res) => {
+                this.answers = res;
+            });
+        }
+        else if (this.configurations.userID != null &&
+            this.endPointConfiguration &&
+            this.endPointConfiguration.Records &&
+            this.endPointConfiguration.Records.GetAllByEntAndUserIDEndPoint) {
+            // se conosco l'utente
+            let dynamicModuleParams = [
+                {
+                    ParamName: "EntID",
+                    ParamValue: this.form.ID,
+                    ParamType: ParamTypeEnum["Query param"],
+                },
+                {
+                    ParamName: "UserID",
+                    ParamValue: this.configurations.userID,
+                    ParamType: ParamTypeEnum["Query param"],
+                },
+            ];
+            await this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetAllByEntAndUserIDEndPoint, dynamicModuleParams, (res) => {
+                this.answers = res;
+                this.loaded = true;
+            });
+        }
+        else {
+            console.error("controllare le configurazioni dell'endpoint");
+        }
+    }
+    generateGraph() {
+        this.generated = false;
+        this.selectedGeneratedFields = JSON.parse(JSON.stringify(this.selectedFields));
+        this.getEligibleAnswers();
+    }
+    getEligibleAnswers() {
+        // Azzero le coordinate
+        this.selectedGeneratedFields.forEach((field) => { field.Coords = new Array(); });
+        this.eligibleAnswers = JSON.parse(JSON.stringify(this.answers));
+        this.minperiodS = this.datePipe.transform(this.minperiod, "yyyy-MM-dd");
+        this.maxperiodS = this.datePipe.transform(this.maxperiod, "yyyy-MM-dd");
+        // Filtro minimo periodo
+        if (this.minperiod != null) {
+            this.eligibleAnswers = this.eligibleAnswers.filter(x => x.AnswerDate.split("T")[0] >= this.minperiodS);
+        }
+        // Filtro massimo periodo
+        if (this.maxperiod != null) {
+            this.eligibleAnswers = this.eligibleAnswers.filter(x => x.AnswerDate.split("T")[0] <= this.maxperiodS);
+        }
+        // Inserisco i dati trovati
+        this.eligibleAnswers.forEach((answer) => {
+            var answervalues = JSON.parse(answer.SerializedValues);
+            this.selectedGeneratedFields.forEach((field) => {
+                if (answervalues[field.Name] != null) {
+                    var coords = new Coords();
+                    coords.x = new Date(answer.AnswerDate);
+                    coords.y = parseFloat(answervalues[field.Name]);
+                    coords.label = this.datePipe.transform(coords.x, "dd/MM HH:mm");
+                    coords.name = coords.label;
+                    field.Coords.push(coords);
+                }
+            });
+        });
+        setTimeout(() => { this.generated = true; }, 1000);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GraphsComponent, deps: [{ token: i1.UtilityHelperService }, { token: i2.DatePipe }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: GraphsComponent, selector: "graphs", inputs: { configurations: "configurations", endPointConfiguration: "endPointConfiguration", userID: "userID", formID: "formID", form: "form" }, ngImport: i0, template: "<mat-card class=\"list-view-form-record\" *ngIf=\"loaded\">\r\n    <mat-card-content>\r\n      \r\n\r\n        <div class=\"row\">\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo inizio'\" [label]=\"'Periodo inizio'\"\r\n                    [(ngModelInput)]=\"minperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo fine'\" [label]=\"'Periodo fine'\"\r\n                    [(ngModelInput)]=\"maxperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <eqp-select [arrayData]=\"fields\" [(ngModelInput)]=\"selectedFields\" [placeholder]=\"'Selezione dei campi'\"\r\n                [arrayKeyProperty]=\"'Description'\" [arrayValueProperty]=\"'Description'\" [isMultiSelect]=\"true\" class=\"eqp-form-field\">\r\n                </eqp-select>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <button\r\n                [disabled]=\"selectedFields == null || selectedFields.length == 0\"\r\n                class=\"btn btn-graph-generate button-next me-2\"\r\n                mat-raised-button\r\n                color=\"primary\"\r\n                (click)=\"generateGraph()\"\r\n                >\r\n                Genera\r\n              </button>\r\n            </div>                   \r\n        </div>\r\n        <div class=\"generation_box\" *ngIf=\"generated\">\r\n            <div class=\"row\">\r\n                <div class=\"col-3\">\r\n                    <div class=\"generation_options\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                        <mat-checkbox class=\"mr-2\" [(ngModel)]=\"selectedField.Visible\">\r\n                        {{selectedField.Description}}\r\n                        </mat-checkbox>\r\n                    </div>\r\n                </div>\r\n                <div class=\"col-9\">\r\n                        <div class=\"generation_graph\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                            <div class=\"generation_divider\" [hidden]=\"!selectedField.Visible\">\r\n                                <graph [data]=\"selectedField.Coords\" [title]=\"selectedField.Description\"></graph>\r\n                            </div>\r\n                        </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n  \r\n  \r\n    </mat-card-content>\r\n    <mat-card-footer>\r\n    </mat-card-footer>\r\n  </mat-card>", styles: [".btn-graph-generate{height:56px;width:100%}.generation_box .generation_divider{margin-bottom:10px;padding-bottom:10px;border-bottom:2px solid black;width:100%;height:600px}.generation_box .generation_divider>*{width:100%;height:400px}\n"], dependencies: [{ kind: "component", type: i3.MatCheckbox, selector: "mat-checkbox", inputs: ["aria-label", "aria-labelledby", "aria-describedby", "id", "required", "labelPosition", "name", "value", "disableRipple", "tabIndex", "color", "checked", "disabled", "indeterminate"], outputs: ["change", "indeterminateChange"], exportAs: ["matCheckbox"] }, { kind: "component", type: i4.MatButton, selector: "    button[mat-button], button[mat-raised-button], button[mat-flat-button],    button[mat-stroked-button]  ", exportAs: ["matButton"] }, { kind: "component", type: i5.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i5.MatCardContent, selector: "mat-card-content" }, { kind: "directive", type: i5.MatCardFooter, selector: "mat-card-footer" }, { kind: "directive", type: i6.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i6.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i7.EqpSelectComponent, selector: "eqp-select", inputs: ["placeholder", "enumData", "enumDataToExclude", "arrayData", "arrayKeyProperty", "arrayValueProperty", "ngModelOptions", "ngModelInput", "formGroupInput", "formControlNameInput", "isRequired", "isDisabled", "isMultiLanguage", "multilanguagePrefixKey", "isAlphabeticalOrderable", "suffixIcon", "prefixIcon", "isMultiSelect", "showCancelButton", "isSearchable", "noResultSearchText", "isReadonly", "isSearchWhileComposing", "appendToInput", "dropdownPosition", "selectOnTab", "selectAll", "selectAllText", "selectableGroupAsModel", "clearAllText", "customOption", "customLabel", "class", "data"], outputs: ["ngModelInputChange", "formControlChange"] }, { kind: "component", type: i8.TmwDateTimePickerComponent, selector: "tmw-datetimepicker", inputs: ["debugMode", "ngModelInput", "formGroupInput", "formControlNameInput", "pickerMode", "timeType", "label", "placeholder", "hint", "minDate", "maxDate", "locale", "inputFormat", "outputFormat", "forSaveLocalOnDB", "disabled", "readonly", "currentDateAsDefault", "showSpinners", "touchUi", "enableMeridian", "hideTime", "stepHour", "showHours", "hourLabel", "stepMinute", "showMinutes", "minuteLabel", "stepSecond", "showSeconds", "secondLabel", "disableMinute", "dayLabel", "monthLabel", "yearLabel", "highLightedDates", "highLightedAriaFormat"], outputs: ["ngModelInputChange"] }, { kind: "component", type: i9.GraphComponent, selector: "graph", inputs: ["data", "title"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: GraphsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'graphs', template: "<mat-card class=\"list-view-form-record\" *ngIf=\"loaded\">\r\n    <mat-card-content>\r\n      \r\n\r\n        <div class=\"row\">\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo inizio'\" [label]=\"'Periodo inizio'\"\r\n                    [(ngModelInput)]=\"minperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo fine'\" [label]=\"'Periodo fine'\"\r\n                    [(ngModelInput)]=\"maxperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <eqp-select [arrayData]=\"fields\" [(ngModelInput)]=\"selectedFields\" [placeholder]=\"'Selezione dei campi'\"\r\n                [arrayKeyProperty]=\"'Description'\" [arrayValueProperty]=\"'Description'\" [isMultiSelect]=\"true\" class=\"eqp-form-field\">\r\n                </eqp-select>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <button\r\n                [disabled]=\"selectedFields == null || selectedFields.length == 0\"\r\n                class=\"btn btn-graph-generate button-next me-2\"\r\n                mat-raised-button\r\n                color=\"primary\"\r\n                (click)=\"generateGraph()\"\r\n                >\r\n                Genera\r\n              </button>\r\n            </div>                   \r\n        </div>\r\n        <div class=\"generation_box\" *ngIf=\"generated\">\r\n            <div class=\"row\">\r\n                <div class=\"col-3\">\r\n                    <div class=\"generation_options\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                        <mat-checkbox class=\"mr-2\" [(ngModel)]=\"selectedField.Visible\">\r\n                        {{selectedField.Description}}\r\n                        </mat-checkbox>\r\n                    </div>\r\n                </div>\r\n                <div class=\"col-9\">\r\n                        <div class=\"generation_graph\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                            <div class=\"generation_divider\" [hidden]=\"!selectedField.Visible\">\r\n                                <graph [data]=\"selectedField.Coords\" [title]=\"selectedField.Description\"></graph>\r\n                            </div>\r\n                        </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n  \r\n  \r\n    </mat-card-content>\r\n    <mat-card-footer>\r\n    </mat-card-footer>\r\n  </mat-card>", styles: [".btn-graph-generate{height:56px;width:100%}.generation_box .generation_divider{margin-bottom:10px;padding-bottom:10px;border-bottom:2px solid black;width:100%;height:600px}.generation_box .generation_divider>*{width:100%;height:400px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UtilityHelperService }, { type: i2.DatePipe }], propDecorators: { configurations: [{
+                type: Input
+            }], endPointConfiguration: [{
+                type: Input
+            }], userID: [{
+                type: Input
+            }], formID: [{
+                type: Input
+            }], form: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"graphs.component.js","sourceRoot":"","sources":["../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/graphs/graphs.component.ts","../../../../../../../projects/eqp-dynamic-module/src/lib/components/private/graphs/graphs.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAU,MAAM,eAAe,CAAC;AAGzD,OAAO,EAA6C,aAAa,EAAE,MAAM,6CAA6C,CAAC;AAEvH,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAGjE,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAEhE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;;;;;;;;;;;AAOpD,MAAM,OAAO,eAAe;IA+BhB;IACA;IA9BD,cAAc,CAA6B;IAC3C,qBAAqB,CAAwB;IAC7C,MAAM,CAAS;IACf,MAAM,GAAW,IAAI,CAAC,CAAC,UAAU;IACjC,IAAI,GAAS,IAAI,CAAC,CAAC,iBAAiB;IAE7C,cAAc,CAAmB;IAEjC,MAAM,GAAY,KAAK,CAAC;IACxB,SAAS,GAAY,KAAK,CAAC;IAE3B,SAAS,GAAS,IAAI,IAAI,EAAE,CAAC;IAC7B,SAAS,GAAS,IAAI,IAAI,EAAE,CAAC;IAC7B,UAAU,CAAS;IACnB,UAAU,CAAS;IAEnB,MAAM,GAAsB,IAAI,KAAK,EAAc,CAAC;IACpD,cAAc,CAAoB;IAClC,uBAAuB,CAAoB;IAE3C,OAAO,GAAqB,IAAI,CAAC;IACjC,eAAe,GAAqB,IAAI,CAAC;IAEzC,aAAa;IACb,KAAK,GAAG,QAAQ,CAAA;IAChB,QAAQ,GAAG,YAAY,CAAA;IACvB,IAAI,CAAW;IAEf,YACU,oBAA0C,EAC1C,QAAkB;QADlB,yBAAoB,GAApB,oBAAoB,CAAsB;QAC1C,aAAQ,GAAR,QAAQ,CAAU;IACvB,CAAC;IAEN,QAAQ;QACN,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,EAAC,CAAC;YACvB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,WAAW;QACT,IACE,IAAI,CAAC,MAAM;YACX,IAAI,CAAC,qBAAqB;YAC1B,IAAI,CAAC,qBAAqB,CAAC,KAAK;YAChC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,eAAe,EAChD,CAAC;YACD,MAAM,mBAAmB,GACvB,IAAI,KAAK,EAAsB,CAAC;YAClC,mBAAmB,CAAC,IAAI,CAAC;gBACvB,SAAS,EAAE,IAAI;gBACf,UAAU,EAAE,IAAI,CAAC,MAAM;gBACvB,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC;aACxC,CAAC,CAAC;YACH,IAAI,CAAC,oBAAoB,CAAC,eAAe,CACvC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,eAAe,EAChD,mBAAmB,EACnB,CAAC,GAAS,EAAE,EAAE;gBAEZ,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;gBAEhB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,IAAI,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oBAC7F,IAAI,UAAU,GAAe,IAAI,UAAU,EAAE,CAAC;oBAC9C,UAAU,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;oBAC9B,UAAU,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;oBAC3C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAC/B,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAE5B,CAAC,EACD,CAAC,GAAG,EAAE,EAAE;YACR,CAAC,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,kBAAkB;QACtB,IAAI,mBAAmB,GAAG;YACxB;gBACE,SAAS,EAAE,OAAO;gBAClB,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;gBACxB,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC;aACxC;SACF,CAAC;QAEF,IACE,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,IAAI;YAClC,IAAI,CAAC,qBAAqB;YAC1B,IAAI,CAAC,qBAAqB,CAAC,OAAO;YAClC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,mBAAmB,EACtD,CAAC;YACD,0BAA0B;YAC1B,IAAI,CAAC,oBAAoB,CAAC,eAAe,CACvC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,mBAAmB,EACtD,mBAAmB,EACnB,CAAC,GAAqB,EAAE,EAAE;gBACxB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;YACrB,CAAC,CACF,CAAC;QACJ,CAAC;aAAM,IACL,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,IAAI;YAClC,IAAI,CAAC,qBAAqB;YAC1B,IAAI,CAAC,qBAAqB,CAAC,OAAO;YAClC,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,4BAA4B,EAC/D,CAAC;YACH,sBAAsB;YACpB,IAAI,mBAAmB,GAAG;gBACxB;oBACE,SAAS,EAAE,OAAO;oBAClB,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE;oBACxB,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC;iBACxC;gBACD;oBACE,SAAS,EAAE,QAAQ;oBACnB,UAAU,EAAE,IAAI,CAAC,cAAc,CAAC,MAAM;oBACtC,SAAS,EAAE,aAAa,CAAC,aAAa,CAAC;iBACxC;aACF,CAAC;YAEF,MAAM,IAAI,CAAC,oBAAoB,CAAC,eAAe,CAC7C,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,4BAA4B,EAC/D,mBAAmB,EACnB,CAAC,GAAqB,EAAE,EAAE;gBACxB,IAAI,CAAC,OAAO,GAAG,GAAG,CAAC;gBACnB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACrB,CAAC,CACF,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,KAAK,CAAC,6CAA6C,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED,aAAa;QACX,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,uBAAuB,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC;QAC/E,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED,kBAAkB;QAChB,uBAAuB;QACvB,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,GAAG,KAAK,CAAC,MAAM,GAAG,IAAI,KAAK,EAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QACzF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QAEhE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAC,YAAY,CAAC,CAAC;QACvE,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,EAAC,YAAY,CAAC,CAAC;QAEvE,wBAAwB;QACxB,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,EAAC,CAAC;YAC1B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;QACzG,CAAC;QAED,yBAAyB;QACzB,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,EAAC,CAAC;YAC1B,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,CAAC;QACzG,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;YACtC,IAAI,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;YACvD,IAAI,CAAC,uBAAuB,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;gBAC7C,IAAI,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,EAAC,CAAC;oBACpC,IAAI,MAAM,GAAW,IAAI,MAAM,EAAE,CAAC;oBAClC,MAAM,CAAC,CAAC,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;oBACvC,MAAM,CAAC,CAAC,GAAG,UAAU,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;oBAChD,MAAM,CAAC,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAC,aAAa,CAAC,CAAC;oBAC/D,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;oBAC3B,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;gBAC5B,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QAEH,UAAU,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;IAErD,CAAC;wGArLU,eAAe;4FAAf,eAAe,8LCjB5B,k4FAyDa;;4FDxCA,eAAe;kBAL3B,SAAS;+BACE,QAAQ;gHAMT,cAAc;sBAAtB,KAAK;gBACG,qBAAqB;sBAA7B,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,IAAI;sBAAZ,KAAK","sourcesContent":["import { Component, Input, OnInit } from '@angular/core';\r\nimport { Form } from \"../../../models/form.model\";\r\nimport { DynamicModuleCompileConfig } from '../../../models/dynamicModuleCompileConfig.model';\r\nimport { EndPointConfiguration, EndPointDataParams, ParamTypeEnum } from '../../../models/endPointConfiguration.model';\r\nimport { UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';\r\nimport { Coords, GraphField } from '../../../models/graph.model';\r\nimport { UtilityHelperService } from '../../../services/utilityHelper.services';\r\nimport { DynRecord } from '../../../models/record.model';\r\nimport { FieldTypeEnum } from '../../../models/baseField.model';\r\nimport { DatePipe } from '@angular/common';\r\nimport { ModeEnum, TimeTypeEnum } from 'tmw-picker';\r\n\r\n@Component({\r\n  selector: 'graphs',\r\n  templateUrl: './graphs.component.html',\r\n  styleUrls: ['./graphs.component.scss']\r\n})\r\nexport class GraphsComponent implements OnInit {\r\n\r\n  @Input() configurations: DynamicModuleCompileConfig;\r\n  @Input() endPointConfiguration: EndPointConfiguration;\r\n  @Input() userID: string;\r\n  @Input() formID: string = null; // preview\r\n  @Input() form: Form = null; // preview config\r\n\r\n  fieldFormGroup: UntypedFormGroup;\r\n\r\n  loaded: boolean = false;\r\n  generated: boolean = false;\r\n\r\n  minperiod: Date = new Date();\r\n  maxperiod: Date = new Date();\r\n  minperiodS: string;\r\n  maxperiodS: string;\r\n\r\n  fields: Array<GraphField> = new Array<GraphField>();\r\n  selectedFields: Array<GraphField>;\r\n  selectedGeneratedFields: Array<GraphField>;\r\n\r\n  answers: Array<DynRecord> = null;\r\n  eligibleAnswers: Array<DynRecord> = null;\r\n\r\n  // TMW-PICKER\r\n  modes = ModeEnum\r\n  timeType = TimeTypeEnum\r\n  mode: ModeEnum;\r\n\r\n  constructor(\r\n    private utilityHelperService: UtilityHelperService,\r\n    private datePipe: DatePipe\r\n    ) {}\r\n\r\n  ngOnInit() {\r\n    if (this.formID != null){\r\n      this.getFormByID();\r\n    } else {\r\n      this.loaded = true;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per recuperare tutti i record salvati per una particolare Form.\r\n   * La chiamata viene effettuata solo se è stato configurato l'endPoint da usare.\r\n   */\r\n  getFormByID() {\r\n    if (\r\n      this.formID &&\r\n      this.endPointConfiguration &&\r\n      this.endPointConfiguration.Forms &&\r\n      this.endPointConfiguration.Forms.GetByIDEndPoint\r\n    ) {\r\n      const dynamicModuleParams: Array<EndPointDataParams> =\r\n        new Array<EndPointDataParams>();\r\n      dynamicModuleParams.push({\r\n        ParamName: \"id\",\r\n        ParamValue: this.formID,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      });\r\n      this.utilityHelperService.RunEndPointCall(\r\n        this.endPointConfiguration.Forms.GetByIDEndPoint,\r\n        dynamicModuleParams,\r\n        (res: Form) => {\r\n\r\n          this.form = res;\r\n\r\n          this.form.Fields.filter(x => x.FieldType == FieldTypeEnum['Campo numerico']).forEach((field) => {\r\n            var graphField: GraphField = new GraphField();\r\n            graphField.Name = field.Label;\r\n            graphField.Description = field.Description;\r\n            this.fields.push(graphField);\r\n          });\r\n\r\n          this.getRecordsByFormID();\r\n\r\n        },\r\n        (err) => {\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  async getRecordsByFormID() {\r\n    var dynamicModuleParams = [\r\n      {\r\n        ParamName: \"EntID\",\r\n        ParamValue: this.form.ID,\r\n        ParamType: ParamTypeEnum[\"Query param\"],\r\n      },\r\n    ];\r\n\r\n    if (\r\n      this.configurations.userID == null &&\r\n      this.endPointConfiguration &&\r\n      this.endPointConfiguration.Records &&\r\n      this.endPointConfiguration.Records.GetByFormIDEndPoint\r\n    ) {\r\n      // se non conosco l'utente\r\n      this.utilityHelperService.RunEndPointCall(\r\n        this.endPointConfiguration.Records.GetByFormIDEndPoint,\r\n        dynamicModuleParams,\r\n        (res: Array<DynRecord>) => {\r\n          this.answers = res;\r\n        }\r\n      );\r\n    } else if (\r\n      this.configurations.userID != null &&\r\n      this.endPointConfiguration &&\r\n      this.endPointConfiguration.Records &&\r\n      this.endPointConfiguration.Records.GetAllByEntAndUserIDEndPoint\r\n    ) {\r\n    // se conosco l'utente\r\n      let dynamicModuleParams = [\r\n        {\r\n          ParamName: \"EntID\",\r\n          ParamValue: this.form.ID,\r\n          ParamType: ParamTypeEnum[\"Query param\"],\r\n        },\r\n        {\r\n          ParamName: \"UserID\",\r\n          ParamValue: this.configurations.userID,\r\n          ParamType: ParamTypeEnum[\"Query param\"],\r\n        },\r\n      ];\r\n\r\n      await this.utilityHelperService.RunEndPointCall(\r\n        this.endPointConfiguration.Records.GetAllByEntAndUserIDEndPoint,\r\n        dynamicModuleParams,\r\n        (res: Array<DynRecord>) => {\r\n          this.answers = res;\r\n          this.loaded = true;\r\n        }\r\n      );\r\n    } else {\r\n      console.error(\"controllare le configurazioni dell'endpoint\");\r\n    }\r\n  }  \r\n\r\n  generateGraph(){\r\n    this.generated = false;\r\n    this.selectedGeneratedFields = JSON.parse(JSON.stringify(this.selectedFields));\r\n    this.getEligibleAnswers();\r\n  }\r\n\r\n  getEligibleAnswers(){\r\n    // Azzero le coordinate\r\n    this.selectedGeneratedFields.forEach((field) => { field.Coords = new Array<Coords>(); });\r\n    this.eligibleAnswers = JSON.parse(JSON.stringify(this.answers));\r\n\r\n    this.minperiodS = this.datePipe.transform(this.minperiod,\"yyyy-MM-dd\");\r\n    this.maxperiodS = this.datePipe.transform(this.maxperiod,\"yyyy-MM-dd\");\r\n\r\n    // Filtro minimo periodo\r\n    if (this.minperiod != null){\r\n      this.eligibleAnswers = this.eligibleAnswers.filter(x => x.AnswerDate.split(\"T\")[0] >= this.minperiodS);\r\n    }\r\n\r\n    // Filtro massimo periodo\r\n    if (this.maxperiod != null){\r\n      this.eligibleAnswers = this.eligibleAnswers.filter(x => x.AnswerDate.split(\"T\")[0] <= this.maxperiodS);\r\n    }\r\n\r\n    // Inserisco i dati trovati\r\n    this.eligibleAnswers.forEach((answer) => {\r\n      var answervalues = JSON.parse(answer.SerializedValues);\r\n      this.selectedGeneratedFields.forEach((field) => {\r\n        if (answervalues[field.Name] != null){\r\n          var coords: Coords = new Coords();\r\n          coords.x = new Date(answer.AnswerDate);\r\n          coords.y = parseFloat(answervalues[field.Name]);\r\n          coords.label = this.datePipe.transform(coords.x,\"dd/MM HH:mm\");\r\n          coords.name = coords.label;\r\n          field.Coords.push(coords);\r\n        }\r\n      });\r\n    });\r\n\r\n    setTimeout(() => { this.generated = true; }, 1000);\r\n\r\n  }\r\n\r\n}\r\n","<mat-card class=\"list-view-form-record\" *ngIf=\"loaded\">\r\n    <mat-card-content>\r\n      \r\n\r\n        <div class=\"row\">\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo inizio'\" [label]=\"'Periodo inizio'\"\r\n                    [(ngModelInput)]=\"minperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>\r\n            <div class=\"col-sm-12 col-md-3\">\r\n                <tmw-datetimepicker class=\"date\" [placeholder]=\"'Periodo fine'\" [label]=\"'Periodo fine'\"\r\n                    [(ngModelInput)]=\"maxperiod\"\r\n                    [pickerMode]=\"modes.DATEPICKER\" [outputFormat]=\"'DD/MM/YYYY'\" [showSeconds]=\"false\">\r\n                </tmw-datetimepicker>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <eqp-select [arrayData]=\"fields\" [(ngModelInput)]=\"selectedFields\" [placeholder]=\"'Selezione dei campi'\"\r\n                [arrayKeyProperty]=\"'Description'\" [arrayValueProperty]=\"'Description'\" [isMultiSelect]=\"true\" class=\"eqp-form-field\">\r\n                </eqp-select>\r\n            </div>       \r\n            <div class=\"col-sm-12 col-md-3 mt-2\">\r\n                <button\r\n                [disabled]=\"selectedFields == null || selectedFields.length == 0\"\r\n                class=\"btn btn-graph-generate button-next me-2\"\r\n                mat-raised-button\r\n                color=\"primary\"\r\n                (click)=\"generateGraph()\"\r\n                >\r\n                Genera\r\n              </button>\r\n            </div>                   \r\n        </div>\r\n        <div class=\"generation_box\" *ngIf=\"generated\">\r\n            <div class=\"row\">\r\n                <div class=\"col-3\">\r\n                    <div class=\"generation_options\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                        <mat-checkbox class=\"mr-2\" [(ngModel)]=\"selectedField.Visible\">\r\n                        {{selectedField.Description}}\r\n                        </mat-checkbox>\r\n                    </div>\r\n                </div>\r\n                <div class=\"col-9\">\r\n                        <div class=\"generation_graph\" *ngFor=\"let selectedField of selectedGeneratedFields\">\r\n                            <div class=\"generation_divider\" [hidden]=\"!selectedField.Visible\">\r\n                                <graph [data]=\"selectedField.Coords\" [title]=\"selectedField.Description\"></graph>\r\n                            </div>\r\n                        </div>\r\n                </div>\r\n            </div>\r\n        </div>\r\n  \r\n  \r\n    </mat-card-content>\r\n    <mat-card-footer>\r\n    </mat-card-footer>\r\n  </mat-card>"]}