keevo-components 1.5.191 → 1.5.192

package/esm2020/keevo-components.mjs

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

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

@@ -0,0 +1,36 @@
+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.color = 'bg-blue-100';
+        this.onClick = new EventEmitter();
+    }
+    click(event) {
+        this.onClick.emit();
+    }
+}
+BaseComponentButton.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentButton, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseComponentButton.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: BaseComponentButton, selector: "ng-component", inputs: { icon: "icon", label: "label", loading: "loading", disabled: "disabled", color: "color" }, outputs: { onClick: "onClick" }, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentButton, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { icon: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], onClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb21wb25lbnQtYnV0dG9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2FwaS9iYXNlLWNvbXBvbmVudHMvYmFzZS1jb21wb25lbnQtYnV0dG9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLEVBQ1QsWUFBWSxFQUNaLEtBQUssRUFDTCxNQUFNLEVBQ1AsTUFBTSxlQUFlLENBQUM7O0FBS3ZCLE1BQU0sT0FBTyxtQkFBbUI7SUFXOUI7UUFUUyxTQUFJLEdBQVcsRUFBRSxDQUFDO1FBQ2xCLFVBQUssR0FBVyxFQUFFLENBQUM7UUFDbkIsWUFBTyxHQUFZLEtBQUssQ0FBQztRQUN6QixhQUFRLEdBQVksS0FBSyxDQUFDO1FBQzFCLFVBQUssR0FBVyxhQUFhLENBQUM7UUFHN0IsWUFBTyxHQUFzQixJQUFJLFlBQVksRUFBRSxDQUFDO0lBRTFDLENBQUM7SUFFakIsS0FBSyxDQUFDLEtBQVU7UUFDZCxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxDQUFDO0lBQ3RCLENBQUM7O2dIQWZVLG1CQUFtQjtvR0FBbkIsbUJBQW1CLHlMQUZwQixFQUFFOzJGQUVELG1CQUFtQjtrQkFIL0IsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsRUFBRTtpQkFDYjswRUFHVSxJQUFJO3NCQUFaLEtBQUs7Z0JBQ0csS0FBSztzQkFBYixLQUFLO2dCQUNHLE9BQU87c0JBQWYsS0FBSztnQkFDRyxRQUFRO3NCQUFoQixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSztnQkFHSSxPQUFPO3NCQUFoQixNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ29tcG9uZW50LFxuICBFdmVudEVtaXR0ZXIsXG4gIElucHV0LFxuICBPdXRwdXRcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogJycsXG59KVxuZXhwb3J0IGNsYXNzIEJhc2VDb21wb25lbnRCdXR0b24ge1xuXG4gIEBJbnB1dCgpIGljb246IHN0cmluZyA9ICcnO1xuICBASW5wdXQoKSBsYWJlbDogc3RyaW5nID0gJyc7XG4gIEBJbnB1dCgpIGxvYWRpbmc6IGJvb2xlYW4gPSBmYWxzZTtcbiAgQElucHV0KCkgZGlzYWJsZWQ6IGJvb2xlYW4gPSBmYWxzZTtcbiAgQElucHV0KCkgY29sb3I6IHN0cmluZyA9ICdiZy1ibHVlLTEwMCc7XG5cblxuICBAT3V0cHV0KCkgb25DbGljazogRXZlbnRFbWl0dGVyPGFueT4gPSBuZXcgRXZlbnRFbWl0dGVyKCk7XG5cbiAgY29uc3RydWN0b3IoKSB7IH1cblxuICBjbGljayhldmVudDogYW55KTogdm9pZCB7XG4gICAgdGhpcy5vbkNsaWNrLmVtaXQoKTtcbiAgfVxufVxuIl19

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

@@ -0,0 +1,92 @@
+import { Component, EventEmitter, Output, ViewChild } from "@angular/core";
+import { ChartComponent, PeriodosChart } from "../../chart/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;
+    }
+}
+BaseChartComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseChartComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+BaseChartComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: BaseChartComponent, selector: "ng-component", outputs: { onPrintReport: "onPrintReport" }, viewQueries: [{ propertyName: "chartComponent", first: true, predicate: ChartComponent, descendants: true }], ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseChartComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { chartComponent: [{
+                type: ViewChild,
+                args: [ChartComponent]
+            }], onPrintReport: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,68 @@
+import { Component } from "@angular/core";
+import { BaseComponentCrud } from "./base-component-crud";
+import { TablePaginate } from "../components/table/table.paginate";
+import { loading } from "../../loader/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.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) => {
+                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());
+    }
+}
+BaseComponentCrudList.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentCrudList, deps: [{ token: i1.DialogService }, { token: i2.NotificationService }, { token: i3.Router }], target: i0.ɵɵFactoryTarget.Component });
+BaseComponentCrudList.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: BaseComponentCrudList, selector: "ng-component", usesInheritance: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentCrudList, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DialogService }, { type: i2.NotificationService }, { type: i3.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS1jb21wb25lbnQtY3J1ZC1saXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2FwaS9iYXNlLWNvbXBvbmVudHMvYmFzZS1jb21wb25lbnQtY3J1ZC1saXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFJbEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDMUQsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBS25FLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQzs7Ozs7QUFLdEQsTUFBTSxPQUFnQixxQkFBc0IsU0FBUSxpQkFBaUI7SUFRbkUsWUFDRSxhQUE0QixFQUM1QixtQkFBd0MsRUFDakMsTUFBYztRQUNyQixLQUFLLENBRUQsYUFBYSxFQUNiLG1CQUFtQixDQUNwQixDQUFDO1FBTEcsV0FBTSxHQUFOLE1BQU0sQ0FBUTtRQU52QixpQkFBWSxHQUFXLENBQUMsQ0FBQztRQUN6QixvQkFBZSxHQUFpQixFQUFFLENBQUM7SUFXbkMsQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLENBQUMsV0FBVyxFQUFFLENBQUM7UUFDbkIsSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO1FBRXRCLHdDQUF3QztRQUN4QyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJO1lBQ3hCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxhQUFhLEVBQUUsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUE4QkQ7OztPQUdHO0lBQ08sVUFBVSxDQUFDLEtBQVU7UUFDN0IsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUM7SUFDNUIsQ0FBQztJQUVEOzs7T0FHRztJQUNPLFFBQVEsQ0FBQyxHQUFvQjtRQUNyQyxHQUFHO2FBQ0EsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO2FBQ2YsU0FBUyxDQUFDO1lBQ1QsSUFBSSxFQUFFLENBQUMsR0FBUSxFQUFFLEVBQUU7Z0JBQ2pCLElBQUksQ0FBQyxZQUFZLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQztnQkFDOUIsSUFBSSxDQUFDLFVBQVUsR0FBRyxHQUFHLENBQUMsS0FBSyxDQUFBO1lBQzdCLENBQUM7WUFDRCxLQUFLLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRTtnQkFDWCxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3JCLENBQUM7U0FDRixDQUFDLENBQUM7SUFDUCxDQUFDO0lBRUQ7O09BRUc7SUFDTyxRQUFRLENBQUMsS0FBVTtRQUMzQixJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3hCLENBQUM7SUFFRDs7T0FFRztJQUNPLE9BQU87UUFDZixJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksYUFBYSxFQUFFLENBQUMsQ0FBQztJQUN0QyxDQUFDOztrSEE5Rm1CLHFCQUFxQjtzR0FBckIscUJBQXFCLDJFQUYvQixFQUFFOzJGQUVRLHFCQUFxQjtrQkFIMUMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsRUFBRTtpQkFDYiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgT25Jbml0IH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IERpYWxvZ1NlcnZpY2UgfSBmcm9tIFwicHJpbWVuZy9keW5hbWljZGlhbG9nXCI7XG5pbXBvcnQgeyBSb3V0ZXIgfSBmcm9tIFwiQGFuZ3VsYXIvcm91dGVyXCI7XG5cbmltcG9ydCB7IEJhc2VDb21wb25lbnRDcnVkIH0gZnJvbSBcIi4vYmFzZS1jb21wb25lbnQtY3J1ZFwiO1xuaW1wb3J0IHsgVGFibGVQYWdpbmF0ZSB9IGZyb20gXCIuLi9jb21wb25lbnRzL3RhYmxlL3RhYmxlLnBhZ2luYXRlXCI7XG5pbXBvcnQgeyBUYWJsZUNvbmZpZyB9IGZyb20gXCIuLi9jb21wb25lbnRzL3RhYmxlL3RhYmxlLmNvbmZpZ1wiO1xuaW1wb3J0IHsgQWN0aW9uSXRlbSB9IGZyb20gXCIuLi9jb21wb25lbnRzL3RhYmxlL2FjdGlvbi1pdGVtXCI7XG5pbXBvcnQgeyBOb3RpZmljYXRpb25TZXJ2aWNlIH0gZnJvbSBcIi4uL3NlcnZpY2VzL25vdGlmaWNhdGlvbi5zZXJ2aWNlXCI7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSBcInJ4anNcIjtcbmltcG9ydCB7IGxvYWRpbmcgfSBmcm9tIFwiLi4vLi4vbG9hZGVyL2xvYWRlci5zZXJ2aWNlXCI7XG5cbkBDb21wb25lbnQoe1xuICB0ZW1wbGF0ZTogJydcbn0pXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgQmFzZUNvbXBvbmVudENydWRMaXN0IGV4dGVuZHMgQmFzZUNvbXBvbmVudENydWQgaW1wbGVtZW50cyBPbkluaXQge1xuXG4gIGRhdGFTb3VyY2U6IGFueTtcbiAgc2VsZWN0ZWRJdGVtOiBhbnk7XG4gIHRhYmxlQ29uZmlnITogVGFibGVDb25maWc7XG4gIHRvdGFsUmVjb3JkczogbnVtYmVyID0gMDtcbiAgYWN0aW9uc1BhZ2VMaXN0OiBBY3Rpb25JdGVtW10gPSBbXTtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBkaWFsb2dTZXJ2aWNlOiBEaWFsb2dTZXJ2aWNlLFxuICAgIG5vdGlmaWNhdGlvblNlcnZpY2U6IE5vdGlmaWNhdGlvblNlcnZpY2UsXG4gICAgcHVibGljIHJvdXRlcjogUm91dGVyKSB7XG4gICAgc3VwZXJcbiAgICAgIChcbiAgICAgICAgZGlhbG9nU2VydmljZSxcbiAgICAgICAgbm90aWZpY2F0aW9uU2VydmljZVxuICAgICAgKTtcbiAgfVxuXG4gIG5nT25Jbml0KCkge1xuICAgIHRoaXMubG9hZEZpbHRlcnMoKTtcbiAgICB0aGlzLmNvbmZpZ3VyZVRhYmxlKCk7XG5cbiAgICAvLyBUYWJlbGEgbsOjbyBjb25maWd1cmFkYSBwYXJhIHBhZ2luYcOnw6NvXG4gICAgaWYgKCF0aGlzLnRhYmxlQ29uZmlnLmxhenkpXG4gICAgICB0aGlzLmxvYWRUYWJsZShuZXcgVGFibGVQYWdpbmF0ZSgpKTtcbiAgfVxuXG4gIC8qKlxuICAgKiBNw6l0b2RvIGRpc3BhcmFkbyBwYXJhIGNvbmZpZ3VyYcOnw6NvIGRhcyB0YWJlbGFzIGRvIGNvbXBvbmVudGUgZGUgbGlzdGFcbiAgICovXG4gIGFic3RyYWN0IGNvbmZpZ3VyZVRhYmxlKCk6IHZvaWQ7XG5cbiAgLyoqXG4gICAqIE3DqXRvZG8gZGlzcGFyYWRvIHBhcmEgZWRpw6fDo28gZGUgcmVnaXN0cm9zXG4gICAqIEBwYXJhbSByZWdpc3RyeSAtIFJlZ2lzdHJvIHF1ZSBlc3TDoSBzZW5kbyBlZGl0YWRvXG4gICAqXG4gICAqL1xuICBhYnN0cmFjdCBlZGl0KHJlZ2lzdHJ5OiBhbnkpOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBNw6l0b2RvIGRpc3BhcmFkbyBwYXJhIGNhcnJlZ2FtZW50byBkb3MgZmlsdHJvcyBkYSB0ZWxhXG4gICAqL1xuICBhYnN0cmFjdCBsb2FkRmlsdGVycygpOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBNw6l0b2RvIGRpc3BhcmFkbyBwYXJhIGNhcnJlZ2FyIGEgdGFiZWxhIGRvIGNvbXBvbmVudGUgZGUgbGlzdGFcbiAgICogQHBhcmFtIHRhYmxlUGFnaW5hdGUgLSBDbGFzc2UgZG9zIGRhZG9zIGRhIHBhZ2luYcOnw6NvIGRhIHRhYmVsYVxuICAgKi9cbiAgYWJzdHJhY3QgbG9hZFRhYmxlKHRhYmxlUGFnaW5hdGU6IFRhYmxlUGFnaW5hdGUpOiB2b2lkO1xuXG4gIC8qKlxuICAgKiBNw6l0b2RvIGRpc3BhcmFkbyBhbyBjbGljYXIgbm8gYm90w6NvIGRlIG5vdm8gcmVnaXN0cm9cbiAgICovXG4gIGFic3RyYWN0IG5ld1JlZ2lzdHJ5KCk6IHZvaWQ7XG5cbiAgLyoqXG4gICAqIE3DqXRvZG8gcXVlIHNldGEgbyByZWdpc3RybyBzZWxlY2lvbmFkbyBuYSB0YWJlbGFcbiAgICogQHBhcmFtIGV2ZW50IC0gUmVnaXN0cm9cbiAgICovXG4gIHByb3RlY3RlZCBhY3RpdmVJdGVtKGV2ZW50OiBhbnkpIHtcbiAgICB0aGlzLnNlbGVjdGVkSXRlbSA9IGV2ZW50O1xuICB9XG5cbiAgLyoqXG4gICAqIE3DqXRvZG8gcXVlIGRpc3BhcmEgbyBjYXJyZWdhbWVudG8gZGEgdGFiZWxhXG4gICAqIEBwYXJhbSBvYnMgLSBPYnNlcnZhYmxlIGRlIGNhcnJlZ2FtZW50byBkb3MgZGFkb3NcbiAgICovXG4gIHByb3RlY3RlZCBsb2FkRGF0YShvYnM6IE9ic2VydmFibGU8YW55Pikge1xuICAgIG9ic1xuICAgICAgLnBpcGUobG9hZGluZygpKVxuICAgICAgLnN1YnNjcmliZSh7XG4gICAgICAgIG5leHQ6IChyZXM6IGFueSkgPT4ge1xuICAgICAgICAgIHRoaXMudG90YWxSZWNvcmRzID0gcmVzLml0ZW0xO1xuICAgICAgICAgIHRoaXMuZGF0YVNvdXJjZSA9IHJlcy5pdGVtMlxuICAgICAgICB9LFxuICAgICAgICBlcnJvcjogKGUpID0+IHtcbiAgICAgICAgICB0aGlzLnRvYXN0RXJyb3IoZSk7XG4gICAgICAgIH0sXG4gICAgICB9KTtcbiAgfVxuXG4gIC8qKlxuICAgKiBNw6l0b2RvIHF1ZSBkaXNwYXJhIGEgcGFnaW5hw6fDo29cbiAgICovXG4gIHByb3RlY3RlZCBwYWdpbmF0ZShldmVudDogYW55KSB7XG4gICAgdGhpcy5sb2FkVGFibGUoZXZlbnQpO1xuICB9XG5cbiAgLyoqXG4gICAqIE3DqXRvZG8gcXVlIGRpc3BhcmEgYSBhdHVhbGl6YcOnw6NvIGRhIHDDoWdpbmEgaW50ZWlyYVxuICAgKi9cbiAgcHJvdGVjdGVkIHJlZnJlc2goKSB7XG4gICAgdGhpcy5sb2FkVGFibGUobmV3IFRhYmxlUGFnaW5hdGUoKSk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/api/base-components/base-component-crud.mjs

@@ -0,0 +1,65 @@
+import { Component } from "@angular/core";
+import { FormService } from "../services/form.service";
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dynamicdialog";
+import * as i2 from "../services/notification.service";
+export class BaseComponentCrud {
+    constructor(dialogService, notificationService) {
+        this.dialogService = dialogService;
+        this.notificationService = notificationService;
+        this.isReport = false;
+        this.itemsReport = [];
+    }
+    /**
+     * Fecha um relatório
+     */
+    closeReport() {
+        this.isReport = false;
+    }
+    /**
+     * Abre um form dialog
+     * @param componentType - Componente que será renderizado
+     * @param callBackFunction - Função de callback que deverá ser chamada após o fechamento do dialog
+     * @param paramsDialog - Parâmetros do dialog
+     */
+    openDialog(componentType, callBackFunction, paramsDialog) {
+        FormService.openDialog(this.dialogService, componentType, callBackFunction, paramsDialog);
+    }
+    /**
+     * Imprime um relatório na tela
+     * @param obs - Observable com o carregamento do relatório
+     */
+    printReportFilter(obs) {
+        obs
+            //.pipe(loading())
+            .subscribe({
+            next: (res) => {
+                this.itemsReport = res;
+                this.isReport = true;
+            },
+            error: (e) => {
+                this.toastError(e);
+            },
+        });
+    }
+    /**
+     * Exibe um toast com um erro
+     * @param err - Erro
+     */
+    toastError(err) {
+        if (err) {
+            if (err.message) {
+                this.notificationService.toastError(err.message);
+            }
+        }
+    }
+}
+BaseComponentCrud.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentCrud, deps: [{ token: i1.DialogService }, { token: i2.NotificationService }], target: i0.ɵɵFactoryTarget.Component });
+BaseComponentCrud.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: BaseComponentCrud, selector: "ng-component", ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: BaseComponentCrud, decorators: [{
+            type: Component,
+            args: [{
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DialogService }, { type: i2.NotificationService }]; } });
+//# sourceMappingURL=data:application/json;base64,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