keevo-components 1.8.127 → 1.8.130

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,92 @@
+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 = '';
+            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;
+                values.push(obj.datasets);
+            });
+            datasets.push({
+                label: labelDataset,
+                backgroundColor: backgroundColor,
+                hoverBackgroundColor: hoverBackgroundColor,
+                borderColor: borderColor?.length === 0 ? undefined : borderColor,
+                data: values
+            });
+        }
+        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\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        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        }\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,298 @@
+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) {
+        obs
+            .pipe(loading())
+            .subscribe((data) => {
+            this.isNewRegistry = false;
+            this.registry = data;
+            this.setFormValues(this.registry);
+            this.loadGrids();
+            this.setTitlePopup();
+        });
+    }
+    async loadDataAsync(obs) {
+        await obs.pipe(loading()).toPromise();
+        const data = await obs.toPromise();
+        this.isNewRegistry = false;
+        this.registry = data;
+        this.setFormValues(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;
+    }
+    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, OnDestroy, OnInit } from \"@angular/core\";\r\nimport { DialogService, DynamicDialogConfig, DynamicDialogRef } 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 extends BaseComponentCrud 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    super\r\n      (\r\n        dialogService,\r\n        notificationService\r\n      );\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      }\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\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        }\r\n        else if (Array.isArray(err.error.item2)) {\r\n          if (err.error.item2?.length) {\r\n\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        }\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      }\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 => controlList.push(this.formGroup.controls[controlName].valueChanges));\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>) {\r\n    obs\r\n      .pipe(loading())\r\n      .subscribe((data: any) => {\r\n        this.isNewRegistry = false;\r\n        this.registry = data as T;\r\n        this.setFormValues(this.registry);\r\n        this.loadGrids();\r\n        this.setTitlePopup();\r\n      });\r\n  }\r\n\r\n  async loadDataAsync<T>(obs: Observable<any>) {\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    this.setFormValues(this.registry);\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    }\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      }\r\n      else if (this.dynamicDialogConfig?.data?.id) {\r\n        this.loadForm(this.dynamicDialogConfig.data.id);\r\n      }\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(finalize(() => {\r\n          this.isSaveLoading = false;\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(controName: string, validators: ValidatorFn | ValidatorFn[] | null) {\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"]}

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

@@ -0,0 +1,79 @@
+import { Component } 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 * 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());
+    }
+    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", 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 }] });
+//# sourceMappingURL=data:application/json;base64,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