@eqproject/eqp-dynamic-module 0.0.7 → 0.0.8

package/esm5/lib/components/exported/eqp-dynamic-module/eqp-dynamic-module.component.js

@@ -0,0 +1,269 @@
+import { __decorate } from "tslib";
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { Context } from '../../../models/context.model';
+import { ParamTypeEnum } from '../../../models/endPointConfiguration.model';
+import { Form, FormTypeEnum } from '../../../models/form.model';
+import { DynRecord, Record } from '../../../models/record.model';
+import { EqpDynamicModuleDialogService } from '../../../services/eqp-dynamic-module-dialog.service';
+import { UtilityHelperService } from '../../../services/utilityHelper.services';
+var EqpDynamicModuleComponent = /** @class */ (function () {
+    function EqpDynamicModuleComponent(utilityHelperService) {
+        this.utilityHelperService = utilityHelperService;
+        this.context = new Context();
+        this.showButtons = true;
+        this.showTitle = true;
+        /**
+         * Url del server da chiamare per recuperare, salvare o eliminare i record.
+         * Usato per creare la configurazione di default degli endpoint da chiamare.
+         */
+        this.baseServerUrl = null;
+        /**
+         * Token da usare negli endpoint da chiamare per recuperare o salvare i record.
+         * Usato solo se viene popolata la proprietà "baseServerUrl".
+         */
+        this.userToken = null;
+        /**
+         * Configurazione degli endpoint da chiamare per recuperare o salvare i dati.
+         * Può essere definita dall'utente oppure lasciata null, viene popolata con dei
+         * valori di default se viene valorizzata la proprietà "baseServerUrl" altrimenti
+         * viene lasciata null e non viene eseguita nessuna chiamata al server.
+         */
+        this.endPointConfiguration = null;
+        /**
+         * Eventi emessi quando si salva, elimina o duplica un record
+         * se non è stato specificato un endpoint da chiamare.
+         */
+        this.saveRecord = new EventEmitter();
+        this.deleteRecord = new EventEmitter();
+        this.duplicateRecord = new EventEmitter();
+        /**
+         * Eventi emessi DOPO aver eseguito una chiamata al server per il salvataggio,
+         * l'eliminazione o la duplicazione di un record all'endpoint specificato.
+         */
+        this.afterSaveRecord = new EventEmitter();
+        this.afterDeleteRecord = new EventEmitter();
+        this.afterDuplicateRecord = new EventEmitter();
+        this.form = new Form();
+        this.viewMode = FormTypeEnum.LIST;
+        this.FormTypeEnum = FormTypeEnum;
+    }
+    EqpDynamicModuleComponent.prototype.ngOnInit = function () {
+        UtilityHelperService.SetContext(this.context);
+        this.configureDefaultEndPoints();
+        this.getFormByID();
+    };
+    EqpDynamicModuleComponent.prototype.getFormByID = function () {
+        var _this = this;
+        var dynamicModuleParams = new Array();
+        dynamicModuleParams.push({
+            ParamName: "id",
+            ParamValue: this.formID,
+            ParamType: ParamTypeEnum['Query param']
+        });
+        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Forms.GetByIDEndPoint, dynamicModuleParams, function (res) {
+            _this.form = res;
+            _this.getRecordsByFormID();
+        }, function (err) {
+            console.log(err);
+        });
+    };
+    /**
+     * Metodo per configurare gli endpoint da usare di default a partire dall'url base del server
+     * a cui si deve connettere e al token da passare per autenticarsi.
+     * Se la proprietà "baseServerUrl" è null e non sono stati configurati i vari endpoint allora
+     * non viene eseguita nessuna chiamata http per recuperare/salvare i dati.
+     */
+    EqpDynamicModuleComponent.prototype.configureDefaultEndPoints = function () {
+        if (!this.endPointConfiguration && this.baseServerUrl) {
+            this.endPointConfiguration = this.utilityHelperService.ConfigureDefaultEndPoints(this.baseServerUrl, this.userToken);
+        }
+    };
+    /**
+     * Metodo per recuperare tutti i record salvati per una particolare Form.
+     * La chiamata viene effettuata solo se è stato configurato l'endPoint da usare.
+     * La risposta della chiamata deve essere un array di oggetti di tipo "DynRecord"
+     * a partire dai quali vengono ricreati i Record usati nel client.
+     */
+    EqpDynamicModuleComponent.prototype.getRecordsByFormID = function () {
+        var _this = this;
+        if (this.endPointConfiguration && this.endPointConfiguration.Records && this.endPointConfiguration.Records.GetByFormIDEndPoint) {
+            var dynamicModuleParams = [
+                { ParamName: 'EntID', ParamValue: this.form.ID, ParamType: ParamTypeEnum['Query param'] }
+            ];
+            this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetByFormIDEndPoint, dynamicModuleParams, function (res) {
+                _this.values = new Array();
+                res.forEach(function (r) {
+                    var tmpRec = new Record();
+                    tmpRec = JSON.parse(r.SerializedValues);
+                    tmpRec.ID = r.ID;
+                    tmpRec.EntID = r.EntID;
+                    _this.values.push(tmpRec);
+                });
+            });
+        }
+    };
+    /**
+     * Metodo invocato quando si vuole aggiungere, visualizzare o modificare un record.
+     * Se l'evento è null vuol dire che stiamo aggiungendo un nuovo record altrimenti siamo in modifica
+     * o visualizzazione. In questi ultimi due casi, se è stato configurato un endpoint per il recupero
+     * del record completo allora viene effettuata una chiamata al server, altrimenti viene usato l'oggetto selezionato.
+     * @param event Oggetto con due proprietà:
+     * "record" = oggetto da modificare/visualizzare,
+     * "onlyView" = booleano (se TRUE siamo in visualizzazione altrimenti in modifica)
+     */
+    EqpDynamicModuleComponent.prototype.onAddViewEditRecord = function (event) {
+        var _this = this;
+        if (event != null) {
+            this.onlyView = event.onlyView;
+            if (this.endPointConfiguration && this.endPointConfiguration.Records && this.endPointConfiguration.Records.GetByIDEndPoint) {
+                var dynamicModuleParams = [
+                    { ParamName: "id", ParamValue: event.record.ID, ParamType: ParamTypeEnum['Query param'] }
+                ];
+                this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetByIDEndPoint, dynamicModuleParams, function (res) {
+                    _this.selectedRecord = JSON.parse(res.SerializedValues);
+                    _this.selectedRecord.ID = res.ID;
+                    _this.selectedRecord.EntID = res.EntID;
+                    _this.viewMode = FormTypeEnum.SCALAR;
+                });
+            }
+            else {
+                this.selectedRecord = JSON.parse(JSON.stringify(event.record));
+                this.viewMode = FormTypeEnum.SCALAR;
+            }
+        }
+        else {
+            this.selectedRecord = null;
+            this.onlyView = false;
+            this.viewMode = FormTypeEnum.SCALAR;
+        }
+    };
+    /**
+     * Metodo per salvare il record aggiunto o modificato.
+     * Se è stato configurato un endPoint per il salvataggio viene effettuata una chiamata al server passando l'oggeto da salvare
+     * nel body della chiamata, altrimenti scatena l'evento "saveRecord".
+     * @param event Oggetto di tipo Record da salvare.
+     */
+    EqpDynamicModuleComponent.prototype.onSaveRecord = function (event) {
+        var _this = this;
+        var _a;
+        if (event != null && this.endPointConfiguration != null && this.endPointConfiguration.Records.SaveEndPoint) {
+            var dynRec = new DynRecord();
+            dynRec.ID = (_a = event.ID, (_a !== null && _a !== void 0 ? _a : null));
+            dynRec.EntID = this.form.ID;
+            dynRec.Values = (event !== null && event !== void 0 ? event : null);
+            var dynamicModuleParams = [
+                { ParamName: "Record", ParamValue: dynRec, ParamType: ParamTypeEnum['In Body'] }
+            ];
+            this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.SaveEndPoint, dynamicModuleParams, function (res) {
+                _this.getRecordsByFormID();
+                _this.afterSaveRecord.emit(event);
+                _this.viewMode = FormTypeEnum.LIST;
+            });
+        }
+        else {
+            this.saveRecord.emit(event);
+            this.viewMode = FormTypeEnum.LIST;
+        }
+    };
+    /**
+     * Metodo per duplicare un record precedentemente salvato.
+     * Se è stato configurato un endPoint per la duplicazione lato server allora effettua una chiamata passando nel body
+     * un oggetto contenente il record da duplicare, altrimenti scatena l'evento di output "duplicateRecord".
+     * @param record Oggetto di tipo Record da duplicare.
+     */
+    EqpDynamicModuleComponent.prototype.onDuplicateRecord = function (record) {
+        var _this = this;
+        if (this.endPointConfiguration && this.endPointConfiguration.Records.DuplicateEndPoint) {
+            EqpDynamicModuleDialogService.Confirm('Duplicare il record selezionato?', function () {
+                var dynamicModuleParams = [
+                    { ParamName: "id", ParamValue: record.ID, ParamType: ParamTypeEnum['Query param'] }
+                ];
+                _this.utilityHelperService.RunEndPointCall(_this.endPointConfiguration.Records.DuplicateEndPoint, dynamicModuleParams, function (res) {
+                    _this.getRecordsByFormID();
+                    _this.afterDuplicateRecord.emit(record);
+                });
+            }, false, 'Richiesta conferma');
+        }
+        else {
+            this.duplicateRecord.emit(record);
+        }
+    };
+    /**
+     * Metodo per eliminare un record.
+     * Se è stato configurato un endPoint per l'eliminazione allora effettua una chiamata passando l'ID del record da eliminare
+     * come query param all'interno della rotta, altrimenti scatena l'evento di output "deleteRecord".
+     * @param record Oggetto di tipo Record da duplicare.
+     */
+    EqpDynamicModuleComponent.prototype.onDeleteRecord = function (record) {
+        var _this = this;
+        if (this.endPointConfiguration && this.endPointConfiguration.Records.DeleteEndPoint) {
+            EqpDynamicModuleDialogService.Confirm('Eliminare il record selezionato?', function () {
+                var dynamicModuleParams = [
+                    { ParamName: "id", ParamValue: record.ID, ParamType: ParamTypeEnum['Query param'] }
+                ];
+                _this.utilityHelperService.RunEndPointCall(_this.endPointConfiguration.Records.DeleteEndPoint, dynamicModuleParams, function (res) {
+                    _this.getRecordsByFormID();
+                    _this.afterDeleteRecord.emit(record);
+                });
+            }, false, 'Richiesta conferma');
+        }
+        else {
+            this.deleteRecord.emit(record);
+        }
+    };
+    EqpDynamicModuleComponent.ctorParameters = function () { return [
+        { type: UtilityHelperService }
+    ]; };
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "context", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "formID", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "values", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "showButtons", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "showTitle", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "baseServerUrl", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "userToken", void 0);
+    __decorate([
+        Input()
+    ], EqpDynamicModuleComponent.prototype, "endPointConfiguration", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "saveRecord", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "deleteRecord", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "duplicateRecord", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "afterSaveRecord", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "afterDeleteRecord", void 0);
+    __decorate([
+        Output()
+    ], EqpDynamicModuleComponent.prototype, "afterDuplicateRecord", void 0);
+    EqpDynamicModuleComponent = __decorate([
+        Component({
+            selector: 'eqp-dynamic-module',
+            template: "<eqp-dynamic-module-spinner></eqp-dynamic-module-spinner>\r\n\r\n<add-form-record *ngIf=\"viewMode == FormTypeEnum.SCALAR\" [form]=\"form\" [record]=\"selectedRecord\"\r\n    [showButtons]=\"showButtons\" [onlyView]=\"onlyView\" (saveRecordEvent)=\"onSaveRecord($event)\" [showTitle]=\"showTitle\">\r\n</add-form-record>\r\n\r\n<list-form-record *ngIf=\"viewMode == FormTypeEnum.LIST && values\" [form]=\"form\" [values]=\"values\"\r\n    (onAddViewEditRecord)=\"onAddViewEditRecord($event)\" [showTitle]=\"showTitle\"\r\n    (onDeleteRecord)=\"onDeleteRecord($event)\" (onDuplicateRecord)=\"onDuplicateRecord($event)\">\r\n</list-form-record>",
+            styles: ["::ng-deep mat-form-field{width:100%}"]
+        })
+    ], EqpDynamicModuleComponent);
+    return EqpDynamicModuleComponent;
+}());
+export { EqpDynamicModuleComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"eqp-dynamic-module.component.js","sourceRoot":"ng://@eqproject/eqp-dynamic-module/","sources":["lib/components/exported/eqp-dynamic-module/eqp-dynamic-module.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, Input, OnInit, Output } from '@angular/core';\r\nimport { Context } from '../../../models/context.model';\r\nimport { EndPointConfiguration, EndPointData, EndPointDataParams, ParamTypeEnum, RequestMethodEnum } from '../../../models/endPointConfiguration.model';\r\nimport { Form, FormTypeEnum } from '../../../models/form.model';\r\nimport { DynRecord, Record } from '../../../models/record.model';\r\nimport { EqpDynamicModuleDialogService } from '../../../services/eqp-dynamic-module-dialog.service';\r\nimport { UtilityHelperService } from '../../../services/utilityHelper.services';\r\n\r\n@Component({\r\n  selector: 'eqp-dynamic-module',\r\n  templateUrl: './eqp-dynamic-module.component.html',\r\n  styleUrls: ['./eqp-dynamic-module.component.scss']\r\n})\r\nexport class EqpDynamicModuleComponent implements OnInit {\r\n\r\n  @Input() context: Context = new Context();\r\n  //@Input() form: Form = new Form();\r\n  @Input() formID: string;\r\n  @Input() values: Array<Record>;\r\n  @Input() showButtons = true;\r\n  @Input() showTitle = true;\r\n\r\n  /**\r\n   * Url del server da chiamare per recuperare, salvare o eliminare i record.\r\n   * Usato per creare la configurazione di default degli endpoint da chiamare.\r\n   */\r\n  @Input() baseServerUrl: string = null;\r\n\r\n  /**\r\n   * Token da usare negli endpoint da chiamare per recuperare o salvare i record.\r\n   * Usato solo se viene popolata la proprietà \"baseServerUrl\".\r\n   */\r\n  @Input() userToken: string = null;\r\n\r\n  /**\r\n   * Configurazione degli endpoint da chiamare per recuperare o salvare i dati.\r\n   * Può essere definita dall'utente oppure lasciata null, viene popolata con dei\r\n   * valori di default se viene valorizzata la proprietà \"baseServerUrl\" altrimenti\r\n   * viene lasciata null e non viene eseguita nessuna chiamata al server.\r\n   */\r\n  @Input() endPointConfiguration: EndPointConfiguration = null;\r\n\r\n  /**\r\n   * Eventi emessi quando si salva, elimina o duplica un record\r\n   * se non è stato specificato un endpoint da chiamare.\r\n   */\r\n  @Output() saveRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() deleteRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() duplicateRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n\r\n  /**\r\n   * Eventi emessi DOPO aver eseguito una chiamata al server per il salvataggio,\r\n   * l'eliminazione o la duplicazione di un record all'endpoint specificato.\r\n   */\r\n  @Output() afterSaveRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() afterDeleteRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n  @Output() afterDuplicateRecord: EventEmitter<Record> = new EventEmitter<Record>();\r\n\r\n  form: Form = new Form();\r\n  viewMode: FormTypeEnum = FormTypeEnum.LIST;\r\n  FormTypeEnum = FormTypeEnum;\r\n  selectedRecord: Record;\r\n  onlyView: boolean;\r\n\r\n  constructor(\r\n    private utilityHelperService: UtilityHelperService\r\n  ) { }\r\n\r\n  ngOnInit(): void {\r\n    UtilityHelperService.SetContext(this.context);\r\n    this.configureDefaultEndPoints();\r\n    this.getFormByID();\r\n  }\r\n\r\n  getFormByID(){\r\n    const dynamicModuleParams: Array<EndPointDataParams> = 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(this.endPointConfiguration.Forms.GetByIDEndPoint, dynamicModuleParams, (res: Form) => {\r\n      this.form = res;\r\n      this.getRecordsByFormID();\r\n    }, (err) => {\r\n      console.log(err);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Metodo per configurare gli endpoint da usare di default a partire dall'url base del server\r\n   * a cui si deve connettere e al token da passare per autenticarsi.\r\n   * Se la proprietà \"baseServerUrl\" è null e non sono stati configurati i vari endpoint allora\r\n   * non viene eseguita nessuna chiamata http per recuperare/salvare i dati.\r\n   */\r\n  configureDefaultEndPoints() {\r\n    if (!this.endPointConfiguration && this.baseServerUrl) {\r\n      this.endPointConfiguration = this.utilityHelperService.ConfigureDefaultEndPoints(this.baseServerUrl, this.userToken);\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   * La risposta della chiamata deve essere un array di oggetti di tipo \"DynRecord\"\r\n   * a partire dai quali vengono ricreati i Record usati nel client.\r\n   */\r\n  getRecordsByFormID() {\r\n    if (this.endPointConfiguration && this.endPointConfiguration.Records && this.endPointConfiguration.Records.GetByFormIDEndPoint) {\r\n      var dynamicModuleParams = [\r\n        { ParamName: 'EntID', ParamValue: this.form.ID, ParamType: ParamTypeEnum['Query param'] }\r\n      ];\r\n      this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetByFormIDEndPoint, dynamicModuleParams, (res: Array<DynRecord>) => {\r\n        this.values = new Array<Record>();\r\n        res.forEach(r => {\r\n          var tmpRec: Record = new Record();\r\n          tmpRec = JSON.parse(r.SerializedValues);\r\n          tmpRec.ID = r.ID;\r\n          tmpRec.EntID = r.EntID;\r\n          this.values.push(tmpRec);\r\n        });\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo invocato quando si vuole aggiungere, visualizzare o modificare un record.\r\n   * Se l'evento è null vuol dire che stiamo aggiungendo un nuovo record altrimenti siamo in modifica\r\n   * o visualizzazione. In questi ultimi due casi, se è stato configurato un endpoint per il recupero\r\n   * del record completo allora viene effettuata una chiamata al server, altrimenti viene usato l'oggetto selezionato.\r\n   * @param event Oggetto con due proprietà:\r\n   * \"record\" = oggetto da modificare/visualizzare,\r\n   * \"onlyView\" = booleano (se TRUE siamo in visualizzazione altrimenti in modifica)\r\n   */\r\n  onAddViewEditRecord(event: { record: Record, onlyView: boolean }) {\r\n    if (event != null) {\r\n      this.onlyView = event.onlyView;\r\n      if (this.endPointConfiguration && this.endPointConfiguration.Records && this.endPointConfiguration.Records.GetByIDEndPoint) {\r\n        var dynamicModuleParams = [\r\n          { ParamName: \"id\", ParamValue: event.record.ID, ParamType: ParamTypeEnum['Query param'] }\r\n        ];\r\n        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.GetByIDEndPoint, dynamicModuleParams, (res: DynRecord) => {\r\n          this.selectedRecord = JSON.parse(res.SerializedValues);\r\n          this.selectedRecord.ID = res.ID;\r\n          this.selectedRecord.EntID = res.EntID;\r\n          this.viewMode = FormTypeEnum.SCALAR;\r\n        });\r\n      } else {\r\n        this.selectedRecord = JSON.parse(JSON.stringify(event.record));\r\n        this.viewMode = FormTypeEnum.SCALAR;\r\n      }\r\n    } else {\r\n      this.selectedRecord = null;\r\n      this.onlyView = false;\r\n      this.viewMode = FormTypeEnum.SCALAR;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per salvare il record aggiunto o modificato.\r\n   * Se è stato configurato un endPoint per il salvataggio viene effettuata una chiamata al server passando l'oggeto da salvare\r\n   * nel body della chiamata, altrimenti scatena l'evento \"saveRecord\".\r\n   * @param event Oggetto di tipo Record da salvare.\r\n   */\r\n  onSaveRecord(event: Record) {\r\n    if (event != null && this.endPointConfiguration != null && this.endPointConfiguration.Records.SaveEndPoint) {\r\n      var dynRec: DynRecord = new DynRecord();\r\n      dynRec.ID = event.ID ?? null;\r\n      dynRec.EntID = this.form.ID;\r\n      dynRec.Values = event ?? null;\r\n      var dynamicModuleParams = [\r\n        { ParamName: \"Record\", ParamValue: dynRec, ParamType: ParamTypeEnum['In Body'] }\r\n      ];\r\n      this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.SaveEndPoint, dynamicModuleParams, (res) => {\r\n        this.getRecordsByFormID();\r\n        this.afterSaveRecord.emit(event);\r\n        this.viewMode = FormTypeEnum.LIST;\r\n      });\r\n    } else {\r\n      this.saveRecord.emit(event);\r\n      this.viewMode = FormTypeEnum.LIST;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per duplicare un record precedentemente salvato.\r\n   * Se è stato configurato un endPoint per la duplicazione lato server allora effettua una chiamata passando nel body\r\n   * un oggetto contenente il record da duplicare, altrimenti scatena l'evento di output \"duplicateRecord\".\r\n   * @param record Oggetto di tipo Record da duplicare.\r\n   */\r\n  onDuplicateRecord(record: Record) {\r\n    if (this.endPointConfiguration && this.endPointConfiguration.Records.DuplicateEndPoint) {\r\n      EqpDynamicModuleDialogService.Confirm('Duplicare il record selezionato?', () => {\r\n        var dynamicModuleParams = [\r\n          { ParamName: \"id\", ParamValue: record.ID, ParamType: ParamTypeEnum['Query param'] }\r\n        ];\r\n        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.DuplicateEndPoint, dynamicModuleParams, (res) => {\r\n          this.getRecordsByFormID();\r\n          this.afterDuplicateRecord.emit(record);\r\n        });\r\n      }, false, 'Richiesta conferma');\r\n    } else {\r\n      this.duplicateRecord.emit(record);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Metodo per eliminare un record.\r\n   * Se è stato configurato un endPoint per l'eliminazione allora effettua una chiamata passando l'ID del record da eliminare\r\n   * come query param all'interno della rotta, altrimenti scatena l'evento di output \"deleteRecord\".\r\n   * @param record Oggetto di tipo Record da duplicare.\r\n   */\r\n  onDeleteRecord(record: Record) {\r\n    if (this.endPointConfiguration && this.endPointConfiguration.Records.DeleteEndPoint) {\r\n      EqpDynamicModuleDialogService.Confirm('Eliminare il record selezionato?', () => {\r\n        var dynamicModuleParams = [\r\n          { ParamName: \"id\", ParamValue: record.ID, ParamType: ParamTypeEnum['Query param'] }\r\n        ];\r\n        this.utilityHelperService.RunEndPointCall(this.endPointConfiguration.Records.DeleteEndPoint, dynamicModuleParams, (res) => {\r\n          this.getRecordsByFormID();\r\n          this.afterDeleteRecord.emit(record);\r\n        });\r\n      }, false, 'Richiesta conferma');\r\n    } else {\r\n      this.deleteRecord.emit(record);\r\n    }\r\n  }\r\n}\r\n"]}