keevo-components 2.0.107 → 2.0.108

package/esm2022/keevo-components.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2Vldm8tY29tcG9uZW50cy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2tlZXZvLWNvbXBvbmVudHMvc3JjL2tlZXZvLWNvbXBvbmVudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/api/base-components/base-component-button.mjs

@@ -0,0 +1,39 @@
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class BaseComponentButton {
+    constructor() {
+        this.icon = '';
+        this.label = '';
+        this.loading = false;
+        this.disabled = false;
+        this.text = false;
+        this.color = 'bg-blue-100';
+        this.onClick = new EventEmitter();
+    }
+    click(event) {
+        this.onClick.emit();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentButton, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentButton, selector: "ng-component", inputs: { icon: "icon", label: "label", loading: "loading", disabled: "disabled", text: "text", color: "color" }, outputs: { onClick: "onClick" }, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentButton, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [], propDecorators: { icon: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], text: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb21wb25lbnQtYnV0dG9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2FwaS9iYXNlLWNvbXBvbmVudHMvYmFzZS1jb21wb25lbnQtYnV0dG9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLEVBQ1QsWUFBWSxFQUNaLEtBQUssRUFDTCxNQUFNLEVBQ1AsTUFBTSxlQUFlLENBQUM7O0FBS3ZCLE1BQU0sT0FBTyxtQkFBbUI7SUFhOUI7UUFYUyxTQUFJLEdBQVcsRUFBRSxDQUFDO1FBQ2xCLFVBQUssR0FBVyxFQUFFLENBQUM7UUFDbkIsWUFBTyxHQUFZLEtBQUssQ0FBQztRQUN6QixhQUFRLEdBQVksS0FBSyxDQUFDO1FBQzFCLFNBQUksR0FBWSxLQUFLLENBQUM7UUFDdEIsVUFBSyxHQUFXLGFBQWEsQ0FBQztRQUk3QixZQUFPLEdBQXNCLElBQUksWUFBWSxFQUFFLENBQUM7SUFFMUMsQ0FBQztJQUVqQixLQUFLLENBQUMsS0FBVTtRQUNkLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDdEIsQ0FBQzs4R0FqQlUsbUJBQW1CO2tHQUFuQixtQkFBbUIsdU1BRnBCLEVBQUU7OzJGQUVELG1CQUFtQjtrQkFIL0IsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsRUFBRTtpQkFDYjt3REFHVSxJQUFJO3NCQUFaLEtBQUs7Z0JBQ0csS0FBSztzQkFBYixLQUFLO2dCQUNHLE9BQU87c0JBQWYsS0FBSztnQkFDRyxRQUFRO3NCQUFoQixLQUFLO2dCQUNHLElBQUk7c0JBQVosS0FBSztnQkFDRyxLQUFLO3NCQUFiLEtBQUs7Z0JBSUksT0FBTztzQkFBaEIsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XHJcbiAgQ29tcG9uZW50LFxyXG4gIEV2ZW50RW1pdHRlcixcclxuICBJbnB1dCxcclxuICBPdXRwdXRcclxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHRlbXBsYXRlOiAnJyxcclxufSlcclxuZXhwb3J0IGNsYXNzIEJhc2VDb21wb25lbnRCdXR0b24ge1xyXG5cclxuICBASW5wdXQoKSBpY29uOiBzdHJpbmcgPSAnJztcclxuICBASW5wdXQoKSBsYWJlbDogc3RyaW5nID0gJyc7XHJcbiAgQElucHV0KCkgbG9hZGluZzogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIEBJbnB1dCgpIGRpc2FibGVkOiBib29sZWFuID0gZmFsc2U7XHJcbiAgQElucHV0KCkgdGV4dDogYm9vbGVhbiA9IGZhbHNlO1xyXG4gIEBJbnB1dCgpIGNvbG9yOiBzdHJpbmcgPSAnYmctYmx1ZS0xMDAnO1xyXG5cclxuXHJcblxyXG4gIEBPdXRwdXQoKSBvbkNsaWNrOiBFdmVudEVtaXR0ZXI8YW55PiA9IG5ldyBFdmVudEVtaXR0ZXIoKTtcclxuXHJcbiAgY29uc3RydWN0b3IoKSB7IH1cclxuXHJcbiAgY2xpY2soZXZlbnQ6IGFueSk6IHZvaWQge1xyXG4gICAgdGhpcy5vbkNsaWNrLmVtaXQoKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2022/lib/api/base-components/base-component-chart.mjs

@@ -0,0 +1,104 @@
+import { Component, EventEmitter, Output, ViewChild } from "@angular/core";
+import { KvChartComponent, PeriodosChart } from "../../components/kv-chart/kv-chart.component";
+import * as i0 from "@angular/core";
+export class BaseChartComponent {
+    constructor() {
+        this.selectedData = 0;
+        this.enablePeriodos = [];
+        this.periodos = PeriodosChart;
+        this.onPrintReport = new EventEmitter();
+    }
+    changeData(event) {
+        if (event) {
+            this.selectedData = event?.value;
+            this.loadData();
+        }
+    }
+    ngOnInit() {
+        this.loadData();
+    }
+    loadGraphic(obs) {
+        obs
+            .subscribe({
+            next: (data) => {
+                this.chartConfig = this.assembleGraphic(data);
+                this.chartComponent?.reInit(this.chartConfig);
+            },
+            error: (error) => { },
+        });
+    }
+    assembleGraphic(data) {
+        let labels = [];
+        let datasets = [];
+        // Tratando legendas
+        data.map((element) => {
+            if (element.labels && !labels.includes(element.labels)) {
+                labels.push(element.labels);
+            }
+        });
+        //Descobrindo quantas dimensões tem o gráfico
+        let numDatasets = Math.max(...data.map(o => o.numDatasets));
+        //Populando datasets
+        for (let i = 0; i <= numDatasets; i++) {
+            let backgroundColor = [];
+            let hoverBackgroundColor = [];
+            let borderColor = [];
+            let values = [];
+            let labelDataset = '';
+            let borderRadius = 10;
+            let hoverOffset = 0;
+            let borderWidth = 0;
+            data.filter((obj) => {
+                return obj.numDatasets === i;
+            }).map((obj) => {
+                if (obj.backgroundColor && !backgroundColor.includes(obj.backgroundColor)) {
+                    backgroundColor.push(obj.backgroundColor);
+                }
+                if (obj.borderColor && !borderColor.includes(obj.borderColor)) {
+                    borderColor.push(obj.borderColor);
+                }
+                if (obj.hoverBackgroundColor && !hoverBackgroundColor.includes(obj.hoverBackgroundColor)) {
+                    hoverBackgroundColor.push(obj.hoverBackgroundColor);
+                }
+                if (obj.labelDataset)
+                    labelDataset = obj.labelDataset;
+                if (obj.borderRadius)
+                    borderRadius = obj.borderRadius;
+                if (obj.hoverOffset)
+                    hoverOffset = obj.hoverOffset;
+                if (obj.borderWidth)
+                    borderWidth = obj.borderWidth;
+                values.push(obj.datasets);
+            });
+            datasets.push({
+                label: labelDataset,
+                backgroundColor: backgroundColor,
+                hoverBackgroundColor: hoverBackgroundColor,
+                borderColor: borderColor?.length === 0 ? undefined : borderColor,
+                data: values,
+                borderRadius: borderRadius,
+                hoverOffset: hoverOffset,
+                borderWidth: borderWidth
+            });
+        }
+        let dados = {
+            labels: labels,
+            datasets: datasets
+        };
+        return dados;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseChartComponent, selector: "ng-component", outputs: { onPrintReport: "onPrintReport" }, viewQueries: [{ propertyName: "chartComponent", first: true, predicate: KvChartComponent, descendants: true }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: () => [], propDecorators: { chartComponent: [{
+                type: ViewChild,
+                args: [KvChartComponent]
+            }], onPrintReport: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component-chart.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/base-components/base-component-chart.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, EventEmitter, OnInit, Output, ViewChild } from \"@angular/core\";\r\nimport { Observable } from \"rxjs\";\r\n\r\nimport { chartModel } from \"../components/chart/chart.model\";\r\nimport { ChartConfig, ChartDatasetConfig } from \"../components/chart/chart.config\";\r\nimport { KvChartComponent, PeriodosChart } from \"../../components/kv-chart/kv-chart.component\";\r\n\r\n@Component({\r\n  template: ''\r\n})\r\nexport abstract class BaseChartComponent implements OnInit {\r\n\r\n  chartConfig!: ChartConfig;\r\n  selectedData: number = 0;\r\n  enablePeriodos: number[] = [];\r\n  periodos = PeriodosChart;\r\n\r\n  @ViewChild(KvChartComponent) chartComponent?: KvChartComponent;\r\n\r\n  @Output() onPrintReport: EventEmitter<any> = new EventEmitter();\r\n\r\n  constructor() { }\r\n\r\n  protected changeData(event: any) {\r\n    if (event) {\r\n      this.selectedData = event?.value;\r\n      this.loadData();\r\n    }\r\n  }\r\n\r\n  ngOnInit(): void {\r\n    this.loadData()\r\n  }\r\n\r\n  abstract loadData(): void;\r\n\r\n  protected loadGraphic(obs: Observable<any>) {\r\n    obs\r\n      .subscribe({\r\n        next: (data: any) => {\r\n          this.chartConfig = this.assembleGraphic(data as chartModel[]);\r\n          this.chartComponent?.reInit(this.chartConfig);\r\n        },\r\n        error: (error: any) => { },\r\n      });\r\n  }\r\n\r\n  protected assembleGraphic(data: chartModel[]) {\r\n    let labels: string[] = [];\r\n    let datasets: ChartDatasetConfig[] = [];\r\n\r\n    // Tratando legendas\r\n    data.map((element: any) => {\r\n      if (element.labels && !labels.includes(element.labels)) {\r\n        labels.push(element.labels);\r\n      }\r\n    });\r\n\r\n    //Descobrindo quantas dimensões tem o gráfico\r\n    let numDatasets = Math.max(...data.map(o => o.numDatasets));\r\n\r\n    //Populando datasets\r\n    for (let i = 0; i <= numDatasets; i++) {\r\n      let backgroundColor: string[] = [];\r\n      let hoverBackgroundColor: string[] = [];\r\n      let borderColor: string[] = [];\r\n      let values: number[] = [];\r\n      let labelDataset: string = '';\r\n      let borderRadius: number = 10;\r\n      let hoverOffset: number = 0;\r\n      let borderWidth: number = 0;\r\n      \r\n\r\n      data.filter((obj) => {\r\n        return obj.numDatasets === i;\r\n      }).map((obj) => {\r\n        if (obj.backgroundColor && !backgroundColor.includes(obj.backgroundColor)) {\r\n          backgroundColor.push(obj.backgroundColor);\r\n        }\r\n        if (obj.borderColor && !borderColor.includes(obj.borderColor)) {\r\n          borderColor.push(obj.borderColor);\r\n        }\r\n        if (obj.hoverBackgroundColor && !hoverBackgroundColor.includes(obj.hoverBackgroundColor)) {\r\n          hoverBackgroundColor.push(obj.hoverBackgroundColor);\r\n        }\r\n        if (obj.labelDataset) labelDataset = obj.labelDataset;\r\n\r\n        if(obj.borderRadius) borderRadius = obj.borderRadius;\r\n\r\n        if(obj.hoverOffset) hoverOffset = obj.hoverOffset;\r\n\r\n        if(obj.borderWidth) borderWidth = obj.borderWidth;\r\n\r\n        values.push(obj.datasets);\r\n      });\r\n\r\n      datasets.push(\r\n        {\r\n          label: labelDataset,\r\n          backgroundColor: backgroundColor,\r\n          hoverBackgroundColor: hoverBackgroundColor,\r\n          borderColor: borderColor?.length === 0 ? undefined : borderColor,\r\n          data: values,\r\n          borderRadius: borderRadius,\r\n          hoverOffset: hoverOffset,\r\n          borderWidth: borderWidth\r\n        }\r\n      );\r\n    }\r\n\r\n    let dados: ChartConfig = {\r\n      labels: labels,\r\n      datasets: datasets\r\n    };\r\n\r\n    return dados;\r\n  }\r\n}\r\n"]}

package/esm2022/lib/api/base-components/base-component-crud-form.mjs

@@ -0,0 +1,308 @@
+import { Component } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { combineLatest, filter, finalize } from 'rxjs';
+import { BaseComponentCrud } from './base-component-crud';
+import { FormService } from '../services/form.service';
+import { loading } from '../../components/kv-loader/kv-loader.service';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dynamicdialog";
+import * as i2 from "../services/notification.service";
+import * as i3 from "@angular/router";
+export class BaseComponentCrudForm extends BaseComponentCrud {
+    constructor(dialogService, notificationService, activatedRoute, dynamicDialogRef, dynamicDialogConfig, router) {
+        super(dialogService, notificationService);
+        this.activatedRoute = activatedRoute;
+        this.dynamicDialogRef = dynamicDialogRef;
+        this.dynamicDialogConfig = dynamicDialogConfig;
+        this.router = router;
+        this.isAccordionExpanded = false;
+        this.isNewRegistry = false;
+        this.isSaveLoading = false;
+        this.isView = false;
+        this.formGroup = new FormGroup({});
+        this.actions = [];
+        this.popup = false;
+        this.registry = null;
+        this.onSetFormValues = false;
+    }
+    /**
+     * Método disparado para tratamento das notificações do backend
+     * @param err - Notificação
+     */
+    backendError(err) {
+        if (err) {
+            if (err.status == 404) {
+                this.notificationService.toastError(err.error.item2[0].message);
+                return;
+            }
+            else if (err.status == 400) {
+                // Erros de validação de domínio do backend
+                if (Array.isArray(err.error)) {
+                    if (err.error?.length) {
+                        if (err.error.length == 1 && err.error[0].key == '') {
+                            this.notificationService.toastError(err.error[0].message);
+                            return;
+                        }
+                        this.invalidForm(err.error);
+                        return;
+                    }
+                }
+                else if (Array.isArray(err.error.item2)) {
+                    if (err.error.item2?.length) {
+                        if (err.error.item2.length == 1) {
+                            this.notificationService.toastError(err.error.item2[0].message);
+                            return;
+                        }
+                        this.invalidForm(err.error.item2);
+                        return;
+                    }
+                }
+                else if (err.error?.title) {
+                    // Erro de json no backend
+                    this.notificationService.toastError(err.error.title);
+                    return;
+                }
+            }
+            else if (err.status == 415) {
+                if (err.error?.title) {
+                    // Erro de json no backend
+                    this.notificationService.toastError(err.error.title);
+                    return;
+                }
+            }
+            // Qualquer outro tipo de erro que tenha mensagem
+            if (err.message) {
+                this.notificationService.toastError(err.message);
+            }
+        }
+    }
+    /**
+     * Método disparado ao clicar no botão de cancelamento
+     */
+    cancel() {
+        this.notificationService.question({
+            type: 'question',
+            message: 'Deseja cancelar a operação?',
+            accept: () => {
+                this.navigateList();
+            },
+        });
+    }
+    /**
+     * Verifica se houveram alterações nos componentes do formControl
+     * @param controls - Nomes do controles no formGroup
+     * @returns Observable
+     */
+    detectFormControlChanges(controls) {
+        const controlList = [];
+        controls.forEach((controlName) => controlList.push(this.formGroup.controls[controlName].valueChanges));
+        return combineLatest(controlList).pipe(filter(() => !this.onSetFormValues));
+    }
+    /**
+     * Método responsável por desabilitar um componente
+     * @param controlName - Nome do controle no formGroup
+     */
+    disableComponent(controlName) {
+        FormService.disableControl(this.formGroup, controlName);
+    }
+    /**
+     * Método responsável por limpar e desabilitar um componente
+     * @param controlName - Nome do controle no formGroup
+     * @param value - Valor default
+     */
+    disableAndClearComponent(controlName, value) {
+        FormService.disableAndClearControl(this.formGroup, controlName, value);
+    }
+    /**
+     * Método responsável por habilitar um componente
+     * @param controlName - Nome do controle no formGroup
+     */
+    enableComponent(controName) {
+        FormService.enableControl(this.formGroup, controName);
+    }
+    /**
+     * Método que retorna o valor de um componente
+     * @param controlName - Nome do controle no formGroup
+     * @returns - Valor
+     */
+    getFormValue(controlName) {
+        return FormService.getFormValue(this.formGroup, controlName);
+    }
+    /**
+     * Verifica se o componente possui erro
+     * @param controlName - Nome do controle no formGroup
+     */
+    hasControlError(controlName, errorCode) {
+        return FormService.hasControlError(this.formGroup, controlName, errorCode);
+    }
+    /**
+     * Seta inconsistências para o fomulário
+     * @param notification - Lista de notificações
+     */
+    invalidForm(notification) {
+        FormService.invalidForm(this.formGroup, notification);
+    }
+    /**
+     * Tratamento de inconsistências do formulário
+     */
+    invalidateForm() {
+        this.isAccordionExpanded = true;
+        this.invalidForm();
+        if (this.dadosTela?.mensagemValidacao) {
+            this.notificationService.dialog({
+                type: 'alert',
+                message: 'Verifique os campos obrigatórios.',
+            });
+        }
+    }
+    /**
+     * Método responsável pelo carregamento da tela
+     * @param obs - Observable responsável pelo salvamento dos dados
+     */
+    loadData(obs, setFormValuesCallback) {
+        obs.pipe(loading()).subscribe((data) => {
+            this.isNewRegistry = false;
+            this.registry = data;
+            if (!setFormValuesCallback)
+                this.setFormValues(this.registry);
+            else
+                setFormValuesCallback(this.registry);
+            this.loadGrids();
+            this.setTitlePopup();
+        });
+    }
+    async loadDataAsync(obs, setFormValuesCallback) {
+        await obs.pipe(loading()).toPromise();
+        const data = await obs.toPromise();
+        this.isNewRegistry = false;
+        this.registry = data;
+        if (!setFormValuesCallback)
+            this.setFormValues(this.registry);
+        else
+            setFormValuesCallback(this.registry);
+        this.loadGrids();
+        this.setTitlePopup();
+    }
+    /**
+     * Método disparado para carregamento de grids (Disparado após o loadData)
+     */
+    loadGrids() { }
+    /**
+     * Método disparado para retornar a lista
+     */
+    navigateList(id = null) {
+        if (this.popup) {
+            this.dynamicDialogRef.close(id);
+        }
+        else if (this.dadosTela?.rotaListar) {
+            this.router.navigate([this.dadosTela.rotaListar]);
+        }
+    }
+    ngOnDestroy() {
+        if (this.dynamicDialogRef) {
+            this.dynamicDialogRef.close();
+        }
+    }
+    ngOnInit() {
+        this.configureForm();
+        this.popup = this.dynamicDialogConfig?.data?.popup || false;
+        this.activatedRoute.params.subscribe((params) => {
+            if (params['id']) {
+                this.loadForm(params['id']);
+            }
+            else if (this.dynamicDialogConfig?.data?.id) {
+                this.loadForm(this.dynamicDialogConfig.data.id);
+            }
+            else {
+                this.isNewRegistry = true;
+                this.loadGrids();
+                this.setTitlePopup();
+            }
+        });
+    }
+    /**
+     * Método disparado para salvar dados
+     * @param obs - Observable responsável pelo salvamento dos dados
+     */
+    saveData(obs) {
+        obs
+            .pipe((src) => {
+            this.isSaveLoading = true;
+            return src.pipe(finalize(() => {
+                this.isSaveLoading = false;
+            }));
+        })
+            .subscribe({
+            next: (res) => {
+                this.notificationService.toastSuccess(res.item2[0].message);
+                this.navigateList(res.item1);
+            },
+            error: (e) => {
+                this.backendError(e);
+            },
+        });
+    }
+    /**
+     * Método se atualiza o valor de um componente do formGroup
+     * @param controName - Nome do controle
+     * @param value - Valor para atualização
+     */
+    setControlValue(controName, value) {
+        FormService.setControlValue(this.formGroup, controName, value);
+    }
+    /**
+     * Atualiza valores dos componentes do formGroup
+     * @param values - Valores para atualização
+     */
+    setFormValues(values) {
+        this.onSetFormValues = true;
+        this.formGroup.patchValue(values, { emitEvent: false });
+        this.onSetFormValues = false;
+    }
+    /**
+     * Seta o título do popup
+     */
+    setTitlePopup() {
+        if (this.popup) {
+            if (this.dynamicDialogConfig)
+                this.dynamicDialogConfig.header = this.dadosTela?.tituloForm;
+        }
+    }
+    /**
+     * Atualiza o validador de um componente do formGroup
+     * @param controName - Nome do controle
+     * @param validators - Regra de validação
+     */
+    setValidators(controName, validators) {
+        FormService.setValidators(this.formGroup, controName, validators);
+    }
+    /**
+     * Dispara os métodos de validações do formulário
+     * @returns - True/False
+     */
+    validateForm() {
+        let valid = false;
+        if (this.formGroup && this.formGroup.valid) {
+            valid = true;
+        }
+        else {
+            this.invalidateForm();
+        }
+        return valid;
+    }
+    /**
+     * Método que dispara a atualização da página inteira
+     */
+    refresh() {
+        window.location.reload();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrudForm, deps: [{ token: i1.DialogService }, { token: i2.NotificationService }, { token: i3.ActivatedRoute }, { token: i1.DynamicDialogRef }, { token: i1.DynamicDialogConfig }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentCrudForm, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrudForm, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.DialogService }, { type: i2.NotificationService }, { type: i3.ActivatedRoute }, { type: i1.DynamicDialogRef }, { type: i1.DynamicDialogConfig }, { type: i3.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component-crud-form.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/base-components/base-component-crud-form.ts"],"names":[],"mappings":"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","sourcesContent":["import { ActivatedRoute, Router } from '@angular/router';\r\nimport { Component, inject, OnDestroy, OnInit } from '@angular/core';\r\nimport {\r\n  DialogService,\r\n  DynamicDialogConfig,\r\n  DynamicDialogRef,\r\n} from 'primeng/dynamicdialog';\r\nimport { FormGroup, ValidatorFn } from '@angular/forms';\r\nimport { Observable, combineLatest, filter, finalize } from 'rxjs';\r\n\r\nimport { ActionItem } from '../components/table/action-item';\r\nimport { BaseComponentCrud } from './base-component-crud';\r\nimport { FormService } from '../services/form.service';\r\nimport { NotificationService } from '../services/notification.service';\r\nimport { loading } from '../../components/kv-loader/kv-loader.service';\r\n\r\nexport interface DadosTela {\r\n  subTituloForm: string | undefined;\r\n  tituloForm: string | undefined;\r\n  rotaListar: string;\r\n  mensagemValidacao: boolean;\r\n}\r\n\r\n@Component({\r\n  template: '',\r\n})\r\nexport abstract class BaseComponentCrudForm\r\n  extends BaseComponentCrud\r\n  implements OnInit, OnDestroy\r\n{\r\n  protected isAccordionExpanded = false;\r\n  protected isNewRegistry = false;\r\n  protected isSaveLoading = false;\r\n  protected isView = false;\r\n\r\n  protected formGroup: FormGroup = new FormGroup({});\r\n  protected actions: ActionItem[] = [];\r\n\r\n  protected dadosTela: DadosTela | undefined;\r\n  protected popup: boolean = false;\r\n  protected registry: any = null;\r\n\r\n  private onSetFormValues: boolean = false;\r\n\r\n  constructor(\r\n    dialogService: DialogService,\r\n    notificationService: NotificationService,\r\n    protected activatedRoute: ActivatedRoute,\r\n    protected dynamicDialogRef: DynamicDialogRef,\r\n    protected dynamicDialogConfig: DynamicDialogConfig,\r\n    protected router: Router\r\n  ) {\r\n    super(dialogService, notificationService);\r\n  }\r\n\r\n  /**\r\n   * Método disparado para configuração do form\r\n   */\r\n  abstract configureForm(): void;\r\n\r\n  /**\r\n   * Método disparado para o carregamento do form\r\n   * @param id\r\n   */\r\n  abstract loadForm(id: any): void;\r\n\r\n  /**\r\n   * Método disparado para salvamento dos dados\r\n   */\r\n  abstract save(): void;\r\n\r\n  /**\r\n   * Método disparado para tratamento das notificações do backend\r\n   * @param err - Notificação\r\n   */\r\n  protected backendError(err: any): void {\r\n    if (err) {\r\n      if (err.status == 404) {\r\n        this.notificationService.toastError(err.error.item2[0].message);\r\n        return;\r\n      } else if (err.status == 400) {\r\n        // Erros de validação de domínio do backend\r\n        if (Array.isArray(err.error)) {\r\n          if (err.error?.length) {\r\n            if (err.error.length == 1 && err.error[0].key == '') {\r\n              this.notificationService.toastError(err.error[0].message);\r\n              return;\r\n            }\r\n\r\n            this.invalidForm(err.error);\r\n            return;\r\n          }\r\n        } else if (Array.isArray(err.error.item2)) {\r\n          if (err.error.item2?.length) {\r\n            if (err.error.item2.length == 1) {\r\n              this.notificationService.toastError(err.error.item2[0].message);\r\n              return;\r\n            }\r\n\r\n            this.invalidForm(err.error.item2);\r\n            return;\r\n          }\r\n        } else if (err.error?.title) {\r\n          // Erro de json no backend\r\n          this.notificationService.toastError(err.error.title);\r\n          return;\r\n        }\r\n      } else if (err.status == 415) {\r\n        if (err.error?.title) {\r\n          // Erro de json no backend\r\n          this.notificationService.toastError(err.error.title);\r\n          return;\r\n        }\r\n      }\r\n\r\n      // Qualquer outro tipo de erro que tenha mensagem\r\n      if (err.message) {\r\n        this.notificationService.toastError(err.message);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Método disparado ao clicar no botão de cancelamento\r\n   */\r\n  protected cancel() {\r\n    this.notificationService.question({\r\n      type: 'question',\r\n      message: 'Deseja cancelar a operação?',\r\n      accept: () => {\r\n        this.navigateList();\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Verifica se houveram alterações nos componentes do formControl\r\n   * @param controls - Nomes do controles no formGroup\r\n   * @returns Observable\r\n   */\r\n  protected detectFormControlChanges(controls: Array<string>): Observable<any> {\r\n    const controlList: Observable<any>[] = [];\r\n    controls.forEach((controlName) =>\r\n      controlList.push(this.formGroup.controls[controlName].valueChanges)\r\n    );\r\n    return combineLatest(controlList).pipe(filter(() => !this.onSetFormValues));\r\n  }\r\n\r\n  /**\r\n   * Método responsável por desabilitar um componente\r\n   * @param controlName - Nome do controle no formGroup\r\n   */\r\n  protected disableComponent(controlName: string) {\r\n    FormService.disableControl(this.formGroup, controlName);\r\n  }\r\n\r\n  /**\r\n   * Método responsável por limpar e desabilitar um componente\r\n   * @param controlName - Nome do controle no formGroup\r\n   * @param value - Valor default\r\n   */\r\n  protected disableAndClearComponent(controlName: string, value?: any) {\r\n    FormService.disableAndClearControl(this.formGroup, controlName, value);\r\n  }\r\n\r\n  /**\r\n   * Método responsável por habilitar um componente\r\n   * @param controlName - Nome do controle no formGroup\r\n   */\r\n  protected enableComponent(controName: string) {\r\n    FormService.enableControl(this.formGroup, controName);\r\n  }\r\n\r\n  /**\r\n   * Método que retorna o valor de um componente\r\n   * @param controlName - Nome do controle no formGroup\r\n   * @returns - Valor\r\n   */\r\n  protected getFormValue<T>(controlName: string): T {\r\n    return FormService.getFormValue<T>(this.formGroup, controlName);\r\n  }\r\n\r\n  /**\r\n   * Verifica se o componente possui erro\r\n   * @param controlName - Nome do controle no formGroup\r\n   */\r\n  protected hasControlError(controlName: string, errorCode?: string): boolean {\r\n    return FormService.hasControlError(this.formGroup, controlName, errorCode);\r\n  }\r\n\r\n  /**\r\n   * Seta inconsistências para o fomulário\r\n   * @param notification - Lista de notificações\r\n   */\r\n  protected invalidForm(notification?: any) {\r\n    FormService.invalidForm(this.formGroup, notification);\r\n  }\r\n\r\n  /**\r\n   * Tratamento de inconsistências do formulário\r\n   */\r\n  protected invalidateForm() {\r\n    this.isAccordionExpanded = true;\r\n    this.invalidForm();\r\n\r\n    if (this.dadosTela?.mensagemValidacao) {\r\n      this.notificationService.dialog({\r\n        type: 'alert',\r\n        message: 'Verifique os campos obrigatórios.',\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Método responsável pelo carregamento da tela\r\n   * @param obs - Observable responsável pelo salvamento dos dados\r\n   */\r\n  public loadData<T>(obs: Observable<any>, setFormValuesCallback?: (data: T) => void) {\r\n    obs.pipe(loading()).subscribe((data: any) => {\r\n      this.isNewRegistry = false;\r\n      this.registry = data as T;\r\n\r\n      if(!setFormValuesCallback)\r\n        this.setFormValues(this.registry);\r\n      else\r\n        setFormValuesCallback(this.registry);\r\n\r\n      this.loadGrids();\r\n      this.setTitlePopup();\r\n    });\r\n  }\r\n\r\n  async loadDataAsync<T>(obs: Observable<any>, setFormValuesCallback?: (data: T) => void) {\r\n    await obs.pipe(loading()).toPromise();\r\n    const data: any = await obs.toPromise();\r\n\r\n    this.isNewRegistry = false;\r\n    this.registry = data as T;\r\n\r\n    if(!setFormValuesCallback)\r\n      this.setFormValues(this.registry);\r\n    else\r\n      setFormValuesCallback(this.registry);\r\n\r\n    this.loadGrids();\r\n    this.setTitlePopup();\r\n  }\r\n\r\n  /**\r\n   * Método disparado para carregamento de grids (Disparado após o loadData)\r\n   */\r\n  public loadGrids() {}\r\n\r\n  /**\r\n   * Método disparado para retornar a lista\r\n   */\r\n  protected navigateList(id: any = null) {\r\n    if (this.popup) {\r\n      this.dynamicDialogRef.close(id);\r\n    } else if (this.dadosTela?.rotaListar) {\r\n      this.router.navigate([this.dadosTela.rotaListar]);\r\n    }\r\n  }\r\n\r\n  public ngOnDestroy() {\r\n    if (this.dynamicDialogRef) {\r\n      this.dynamicDialogRef.close();\r\n    }\r\n  }\r\n\r\n  public ngOnInit() {\r\n    this.configureForm();\r\n\r\n    this.popup = this.dynamicDialogConfig?.data?.popup || false;\r\n\r\n    this.activatedRoute.params.subscribe((params: any) => {\r\n      if (params['id']) {\r\n        this.loadForm(params['id']);\r\n      } else if (this.dynamicDialogConfig?.data?.id) {\r\n        this.loadForm(this.dynamicDialogConfig.data.id);\r\n      } else {\r\n        this.isNewRegistry = true;\r\n        this.loadGrids();\r\n        this.setTitlePopup();\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Método disparado para salvar dados\r\n   * @param obs - Observable responsável pelo salvamento dos dados\r\n   */\r\n  protected saveData(obs: Observable<any>) {\r\n    obs\r\n      .pipe((src: Observable<any>) => {\r\n        this.isSaveLoading = true;\r\n        return src.pipe(\r\n          finalize(() => {\r\n            this.isSaveLoading = false;\r\n          })\r\n        );\r\n      })\r\n      .subscribe({\r\n        next: (res: any) => {\r\n          this.notificationService.toastSuccess(res.item2[0].message);\r\n          this.navigateList(res.item1);\r\n        },\r\n        error: (e) => {\r\n          this.backendError(e);\r\n        },\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Método se atualiza o valor de um componente do formGroup\r\n   * @param controName - Nome do controle\r\n   * @param value - Valor para atualização\r\n   */\r\n  protected setControlValue(controName: string, value: any) {\r\n    FormService.setControlValue(this.formGroup, controName, value);\r\n  }\r\n\r\n  /**\r\n   * Atualiza valores dos componentes do formGroup\r\n   * @param values - Valores para atualização\r\n   */\r\n  protected setFormValues(values: any) {\r\n    this.onSetFormValues = true;\r\n    this.formGroup.patchValue(values, { emitEvent: false });\r\n    this.onSetFormValues = false;\r\n  }\r\n\r\n  /**\r\n   * Seta o título do popup\r\n   */\r\n  private setTitlePopup() {\r\n    if (this.popup) {\r\n      if (this.dynamicDialogConfig)\r\n        this.dynamicDialogConfig.header = this.dadosTela?.tituloForm;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Atualiza o validador de um componente do formGroup\r\n   * @param controName - Nome do controle\r\n   * @param validators - Regra de validação\r\n   */\r\n  protected setValidators(\r\n    controName: string,\r\n    validators: ValidatorFn | ValidatorFn[] | null\r\n  ) {\r\n    FormService.setValidators(this.formGroup, controName, validators);\r\n  }\r\n\r\n  /**\r\n   * Dispara os métodos de validações do formulário\r\n   * @returns - True/False\r\n   */\r\n  protected validateForm(): boolean {\r\n    let valid: boolean = false;\r\n\r\n    if (this.formGroup && this.formGroup.valid) {\r\n      valid = true;\r\n    } else {\r\n      this.invalidateForm();\r\n    }\r\n\r\n    return valid;\r\n  }\r\n\r\n  /**\r\n   * Método que dispara a atualização da página inteira\r\n   */\r\n  protected refresh() {\r\n    window.location.reload();\r\n  }\r\n}\r\n"]}

package/esm2022/lib/api/base-components/base-component-crud-list.mjs

@@ -0,0 +1,91 @@
+import { Component, ViewChild } from '@angular/core';
+import { BaseComponentCrud } from './base-component-crud';
+import { TablePaginate } from '../components/table/table.paginate';
+import { loading } from '../../components/kv-loader/kv-loader.service';
+import { KvTableComponent } from '../../components/kv-table/kv-table.component';
+import { KvTreetableComponent } from '../../components/kv-tree-table/kv-tree-table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dynamicdialog";
+import * as i2 from "../services/notification.service";
+import * as i3 from "@angular/router";
+export class BaseComponentCrudList extends BaseComponentCrud {
+    constructor(dialogService, notificationService, router) {
+        super(dialogService, notificationService);
+        this.router = router;
+        this.dataSource = [];
+        this.totalRecords = 0;
+        this.actionsPageList = [];
+    }
+    ngOnInit() {
+        this.loadFilters();
+        this.configureTable();
+        // Tabela não configurada para paginação
+        if (!this.tableConfig?.lazy)
+            this.loadTable(new TablePaginate());
+    }
+    /**
+     * Método que seta o registro selecionado na tabela
+     * @param event - Registro
+     */
+    activeItem(event) {
+        this.selectedItem = event;
+    }
+    /**
+     * Método que dispara o carregamento da tabela
+     * @param obs - Observable de carregamento dos dados
+     */
+    loadData(obs) {
+        obs.pipe(loading()).subscribe({
+            next: (res) => {
+                if (res) {
+                    if (Array.isArray(res)) {
+                        //Tratamento para retorno do tipo listar ([])
+                        this.totalRecords = res.length;
+                        this.dataSource = res;
+                    }
+                    else {
+                        //Tratamento para retorno do tipo listarPaginado (<int,[]>)
+                        this.totalRecords = res.item1;
+                        this.dataSource = res.item2;
+                    }
+                }
+            },
+            error: (e) => {
+                this.toastError(e);
+            },
+        });
+    }
+    /**
+     * Método que dispara a paginação
+     */
+    paginate(event) {
+        this.loadTable(event);
+    }
+    /**
+     * Método que dispara a atualização da página inteira
+     */
+    refresh() {
+        this.loadTable(new TablePaginate());
+    }
+    resetTable() {
+        this.table?.resetTable();
+    }
+    resetTreeTable() {
+        this.treetable?.resetTreeTable();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrudList, deps: [{ token: i1.DialogService }, { token: i2.NotificationService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.8", type: BaseComponentCrudList, selector: "ng-component", viewQueries: [{ propertyName: "table", first: true, predicate: KvTableComponent, descendants: true }, { propertyName: "treetable", first: true, predicate: KvTreetableComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.8", ngImport: i0, type: BaseComponentCrudList, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [{ type: i1.DialogService }, { type: i2.NotificationService }, { type: i3.Router }], propDecorators: { table: [{
+                type: ViewChild,
+                args: [KvTableComponent]
+            }], treetable: [{
+                type: ViewChild,
+                args: [KvTreetableComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-component-crud-list.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/base-components/base-component-crud-list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAkB,SAAS,EAAE,MAAM,eAAe,CAAC;AAIrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAKnE,OAAO,EAAE,OAAO,EAAE,MAAM,8CAA8C,CAAC;AAEvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAChF,OAAO,EAAE,oBAAoB,EAAE,MAAM,wDAAwD,CAAC;;;;;AAK9F,MAAM,OAAgB,qBACpB,SAAQ,iBAAiB;IAWzB,YACE,aAA4B,EAC5B,mBAAwC,EACjC,MAAc;QAErB,KAAK,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC;QAFnC,WAAM,GAAN,MAAM,CAAQ;QAZvB,eAAU,GAAQ,EAAE,CAAC;QAGrB,iBAAY,GAAW,CAAC,CAAC;QACzB,oBAAe,GAAiB,EAAE,CAAC;IAWnC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,cAAc,EAAE,CAAC;QAEtB,wCAAwC;QACxC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI;YAAE,IAAI,CAAC,SAAS,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC;IACnE,CAAC;IA8BD;;;OAGG;IACO,UAAU,CAAC,KAAU;QAC7B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACO,QAAQ,CAAC,GAAoB;QACrC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC;YAC5B,IAAI,EAAE,CAAC,GAAQ,EAAE,EAAE;gBACjB,IAAI,GAAG,EAAE,CAAC;oBACR,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;wBACvB,6CAA6C;wBAC7C,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,MAAM,CAAC;wBAC/B,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;oBACxB,CAAC;yBAAM,CAAC;wBACN,2DAA2D;wBAC3D,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,KAAK,CAAC;wBAC9B,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC;oBAC9B,CAAC;gBACH,CAAC;YACH,CAAC;YACD,KAAK,EAAE,CAAC,CAAC,EAAE,EAAE;gBACX,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YACrB,CAAC;SACF,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACO,QAAQ,CAAC,KAAU;QAC3B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED;;OAEG;IACO,OAAO;QACf,IAAI,CAAC,SAAS,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC;IACtC,CAAC;IAES,UAAU;QAClB,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,CAAC;IAC3B,CAAC;IAES,cAAc;QACtB,IAAI,CAAC,SAAS,EAAE,cAAc,EAAE,CAAC;IACnC,CAAC;8GA7GmB,qBAAqB;kGAArB,qBAAqB,2FAS9B,gBAAgB,4EAChB,oBAAoB,uEAZrB,EAAE;;2FAEQ,qBAAqB;kBAH1C,SAAS;mBAAC;oBACT,QAAQ,EAAE,EAAE;iBACb;yIAU8B,KAAK;sBAAjC,SAAS;uBAAC,gBAAgB;gBACM,SAAS;sBAAzC,SAAS;uBAAC,oBAAoB","sourcesContent":["import { Component, inject, OnInit, ViewChild } from '@angular/core';\r\nimport { DialogService } from 'primeng/dynamicdialog';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { BaseComponentCrud } from './base-component-crud';\r\nimport { TablePaginate } from '../components/table/table.paginate';\r\nimport { TableConfig } from '../components/table/table.config';\r\nimport { ActionItem } from '../components/table/action-item';\r\nimport { NotificationService } from '../services/notification.service';\r\nimport { Observable } from 'rxjs';\r\nimport { loading } from '../../components/kv-loader/kv-loader.service';\r\nimport { TreeTableConfig } from '../components/tree-table/tree-table.config';\r\nimport { KvTableComponent } from '../../components/kv-table/kv-table.component';\r\nimport { KvTreetableComponent } from '../../components/kv-tree-table/kv-tree-table.component';\r\n\r\n@Component({\r\n  template: '',\r\n})\r\nexport abstract class BaseComponentCrudList\r\n  extends BaseComponentCrud\r\n  implements OnInit {\r\n  dataSource: any = [];\r\n  selectedItem: any;\r\n  tableConfig!: TableConfig | TreeTableConfig;\r\n  totalRecords: number = 0;\r\n  actionsPageList: ActionItem[] = [];\r\n\r\n  @ViewChild(KvTableComponent) table!: KvTableComponent;\r\n  @ViewChild(KvTreetableComponent) treetable!: KvTreetableComponent;\r\n\r\n  constructor(\r\n    dialogService: DialogService,\r\n    notificationService: NotificationService,\r\n    public router: Router\r\n  ) {\r\n    super(dialogService, notificationService);\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.loadFilters();\r\n    this.configureTable();\r\n\r\n    // Tabela não configurada para paginação\r\n    if (!this.tableConfig?.lazy) this.loadTable(new TablePaginate());\r\n  }\r\n\r\n  /**\r\n   * Método disparado para configuração das tabelas do componente de lista\r\n   */\r\n  abstract configureTable(): void;\r\n\r\n  /**\r\n   * Método disparado para edição de registros\r\n   * @param registry - Registro que está sendo editado\r\n   *\r\n   */\r\n  abstract edit(registry: any): void;\r\n\r\n  /**\r\n   * Método disparado para carregamento dos filtros da tela\r\n   */\r\n  abstract loadFilters(): void;\r\n\r\n  /**\r\n   * Método disparado para carregar a tabela do componente de lista\r\n   * @param tablePaginate - Classe dos dados da paginação da tabela\r\n   */\r\n  abstract loadTable(tablePaginate: TablePaginate): void;\r\n\r\n  /**\r\n   * Método disparado ao clicar no botão de novo registro\r\n   */\r\n  abstract newRegistry(): void;\r\n\r\n  /**\r\n   * Método que seta o registro selecionado na tabela\r\n   * @param event - Registro\r\n   */\r\n  protected activeItem(event: any) {\r\n    this.selectedItem = event;\r\n  }\r\n\r\n  /**\r\n   * Método que dispara o carregamento da tabela\r\n   * @param obs - Observable de carregamento dos dados\r\n   */\r\n  protected loadData(obs: Observable<any>) {\r\n    obs.pipe(loading()).subscribe({\r\n      next: (res: any) => {\r\n        if (res) {\r\n          if (Array.isArray(res)) {\r\n            //Tratamento para retorno do tipo listar ([])\r\n            this.totalRecords = res.length;\r\n            this.dataSource = res;\r\n          } else {\r\n            //Tratamento para retorno do tipo listarPaginado (<int,[]>)\r\n            this.totalRecords = res.item1;\r\n            this.dataSource = res.item2;\r\n          }\r\n        }\r\n      },\r\n      error: (e) => {\r\n        this.toastError(e);\r\n      },\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Método que dispara a paginação\r\n   */\r\n  protected paginate(event: any) {\r\n    this.loadTable(event);\r\n  }\r\n\r\n  /**\r\n   * Método que dispara a atualização da página inteira\r\n   */\r\n  protected refresh() {\r\n    this.loadTable(new TablePaginate());\r\n  }\r\n\r\n  protected resetTable() {\r\n    this.table?.resetTable();\r\n  }\r\n\r\n  protected resetTreeTable() {\r\n    this.treetable?.resetTreeTable();\r\n  }\r\n}\r\n"]}