keevo-components 1.5.135 → 1.5.137

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

@@ -0,0 +1,278 @@
+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 * 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, propertyDescripton) {
+        obs
+            //.pipe(loading())
+            .subscribe((data) => {
+            this.isNewRegistry = false;
+            this.registry = data;
+            this.setFormValues(this.registry);
+            this.loadGrids();
+            //this.dadosTela.tituloForm = this.tituloForm<T>(false, propertyDescripton);
+            //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.dadosTela.tituloForm = this.tituloForm(true, '');
+                //this.setTitlePopup();
+                this.loadGrids();
+            }
+        });
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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);
+    }
+    // private setTitlePopup() {
+    //   if (this.popup) {
+    //     if (this.dynamicDialogConfig)
+    //       this.dynamicDialogConfig.header = this.dadosTela.tituloForm;
+    //   }
+    // }
+    // protected tituloForm<T>(isNew: boolean, propertyDescripton: string): string {
+    //   if (isNew) {
+    //     return `${this.dadosTela.masculino ? 'Novo' : 'Nova'} ${this.dadosTela.nomeCadastro}`;
+    //   }
+    //   else if (this.isView) {
+    //     return `Visualização ${this.dadosTela.masculino ? 'do' : 'da'} ${this.dadosTela.nomeCadastro}: ${ObjectService.getProperty<T>(this.registry, propertyDescripton)}`;
+    //   } else {
+    //     return `Edição ${this.dadosTela.masculino ? 'do' : 'da'} ${this.dadosTela.nomeCadastro}: ${ObjectService.getProperty<T>(this.registry, propertyDescripton)}`;
+    //   }
+    // }
+    /**
+     * 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\";\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\n\r\nexport interface DadosTela {\r\n  nomeCadastro: string;\r\n  tituloForm: string;\r\n  rotaListar: string;\r\n  masculino: boolean;\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 (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   * 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>, propertyDescripton: string) {\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.dadosTela.tituloForm = this.tituloForm<T>(false, propertyDescripton);\r\n        //this.setTitlePopup();\r\n      });\r\n  }\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.dadosTela.tituloForm = this.tituloForm(true, '');\r\n        //this.setTitlePopup();\r\n        this.loadGrids();\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   * 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  // 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  // protected tituloForm<T>(isNew: boolean, propertyDescripton: string): string {\r\n  //   if (isNew) {\r\n  //     return `${this.dadosTela.masculino ? 'Novo' : 'Nova'} ${this.dadosTela.nomeCadastro}`;\r\n  //   }\r\n  //   else if (this.isView) {\r\n  //     return `Visualização ${this.dadosTela.masculino ? 'do' : 'da'} ${this.dadosTela.nomeCadastro}: ${ObjectService.getProperty<T>(this.registry, propertyDescripton)}`;\r\n  //   } else {\r\n  //     return `Edição ${this.dadosTela.masculino ? 'do' : 'da'} ${this.dadosTela.nomeCadastro}: ${ObjectService.getProperty<T>(this.registry, propertyDescripton)}`;\r\n  //   }\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.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    return valid;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,67 @@
+import { Component } from "@angular/core";
+import { BaseComponentCrud } from "./base-component-crud";
+import { TablePaginate } from "../components/table/table.paginate";
+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,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

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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

package/esm2020/lib/api/services/form.service.mjs

@@ -0,0 +1,102 @@
+import { Injectable } from '@angular/core';
+import { ObjectService } from './object.service';
+import * as i0 from "@angular/core";
+export class FormService {
+    static disableControl(formGroup, controName) {
+        formGroup?.controls[controName]?.disable();
+    }
+    static disableAndClearControl(formGroup, controName, value) {
+        this.disableControl(formGroup, controName);
+        this.setControlValue(formGroup, controName, null || value);
+    }
+    static enableControl(formGroup, controName) {
+        formGroup?.controls[controName]?.enable();
+    }
+    static getFormValue(formGroup, controName) {
+        return formGroup?.controls[controName]?.value;
+    }
+    static hasControlError(formGroup, control, errorCode) {
+        const formControl = formGroup.get(control);
+        let hasError = false;
+        if (!formControl)
+            return false;
+        if (errorCode)
+            hasError = formControl.hasError(errorCode);
+        else
+            hasError = formControl.errors ? true : false;
+        return hasError && formControl.touched;
+    }
+    static invalidForm(formGroup, notification) {
+        const keys = Object.keys(formGroup.getRawValue());
+        keys.forEach(k => {
+            const control = formGroup.controls[k];
+            if (notification) {
+                if (notification?.item2) {
+                    const item = ObjectService.findObject(notification.item2, 'property', k);
+                    if (item)
+                        control.setErrors({ backendError: true, erroMessage: item.message });
+                }
+                else {
+                    const item = ObjectService.findObject(notification, 'key', k);
+                    if (item)
+                        control.setErrors({ backendError: true, erroMessage: item.message });
+                }
+            }
+            if (!control.valid) {
+                control.markAsTouched();
+            }
+        });
+    }
+    static openDialog(dialogService, componentType, callBackFunction, paramsDialog) {
+        const ref = dialogService.open(componentType, {
+            closable: paramsDialog?.closable || false,
+            maximizable: paramsDialog?.maximizable || true,
+            height: paramsDialog?.height || 'auto',
+            width: paramsDialog?.width,
+            styleClass: paramsDialog?.styleClass,
+            data: { id: paramsDialog?.id, popup: paramsDialog?.popup || true }
+        });
+        ref.onClose.subscribe((data) => {
+            if (data)
+                callBackFunction(data);
+        });
+    }
+    // static openDialog(
+    //   dialogService: DialogService,
+    //   componentType: Type<any>,
+    //   callBackFunction: Function,
+    //   id?: any,
+    //   width?: string,
+    //   height?: string
+    // ) {
+    //   const ref = dialogService.open(componentType, {
+    //     width: width,
+    //     height: height,
+    //     closable: false,
+    //     maximizable: true,
+    //     data: { id: id, popup: true }
+    //   });
+    //   ref.onClose.subscribe((data: any) => {
+    //     if (data) callBackFunction(data);
+    //   });
+    // }
+    static setControlValue(formGroup, controName, value) {
+        formGroup?.controls[controName]?.setValue(value);
+    }
+    static setValidators(formGroup, controName, validators) {
+        formGroup?.controls[controName]?.setValidators(validators);
+        formGroup?.controls[controName]?.updateValueAndValidity();
+    }
+    static clearValidators(formGroup, controName) {
+        formGroup?.controls[controName]?.updateValueAndValidity();
+    }
+}
+FormService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FormService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+FormService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FormService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: FormService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.service.js","sourceRoot":"","sources":["../../../../../../projects/keevo-components/src/lib/api/services/form.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Type } from '@angular/core';\r\nimport { FormGroup, ValidatorFn } from '@angular/forms';\r\nimport { ObjectService } from './object.service';\r\nimport { DialogService } from 'primeng/dynamicdialog';\r\n\r\nexport interface paramsDialog {\r\n  id?: any;\r\n  closable?: boolean;\r\n  maximizable?: boolean;\r\n  popup?: boolean;\r\n  height?: string;\r\n  width?: string;\r\n  styleClass?: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class FormService {\r\n\r\n  static disableControl(formGroup: FormGroup, controName: string) {\r\n    formGroup?.controls[controName]?.disable();\r\n  }\r\n\r\n  static disableAndClearControl(formGroup: FormGroup, controName: string, value?: any) {\r\n    this.disableControl(formGroup, controName);\r\n    this.setControlValue(formGroup, controName, null || value);\r\n  }\r\n\r\n  static enableControl(formGroup: FormGroup, controName: string) {\r\n    formGroup?.controls[controName]?.enable();\r\n  }\r\n\r\n  static getFormValue<T>(formGroup: FormGroup, controName: string): T {\r\n    return <T>formGroup?.controls[controName]?.value;\r\n  }\r\n\r\n  static hasControlError(formGroup: FormGroup, control: string, errorCode?: string): boolean {\r\n    const formControl = formGroup.get(control);\r\n    let hasError: boolean = false;\r\n\r\n    if (!formControl) return false;\r\n    if (errorCode) hasError = formControl.hasError(errorCode);\r\n    else hasError = formControl.errors ? true : false;\r\n\r\n    return hasError && formControl.touched;\r\n  }\r\n\r\n  static invalidForm(formGroup: FormGroup, notification?: any) {\r\n    const keys = Object.keys(formGroup.getRawValue());\r\n\r\n    keys.forEach(k => {\r\n      const control = formGroup.controls[k];\r\n\r\n      if (notification) {\r\n        if (notification?.item2) {\r\n          const item = ObjectService.findObject(notification.item2, 'property', k);\r\n          if (item) control.setErrors({ backendError: true, erroMessage: item.message });\r\n        }\r\n        else {\r\n          const item = ObjectService.findObject(notification, 'key', k);\r\n          if (item) control.setErrors({ backendError: true, erroMessage: item.message });\r\n        }\r\n      }\r\n\r\n      if (!control.valid) {\r\n        control.markAsTouched();\r\n      }\r\n    });\r\n  }\r\n\r\n  static openDialog(\r\n    dialogService: DialogService,\r\n    componentType: Type<any>,\r\n    callBackFunction: Function,\r\n    paramsDialog?: paramsDialog\r\n  ) {\r\n    const ref = dialogService.open(componentType, {\r\n      closable: paramsDialog?.closable || false,\r\n      maximizable: paramsDialog?.maximizable || true,\r\n      height: paramsDialog?.height || 'auto',\r\n      width: paramsDialog?.width,\r\n      styleClass: paramsDialog?.styleClass,\r\n      data: { id: paramsDialog?.id, popup: paramsDialog?.popup || true }\r\n    });\r\n\r\n    ref.onClose.subscribe((data: any) => {\r\n      if (data) callBackFunction(data);\r\n    });\r\n  }\r\n\r\n  // static openDialog(\r\n  //   dialogService: DialogService,\r\n  //   componentType: Type<any>,\r\n  //   callBackFunction: Function,\r\n  //   id?: any,\r\n  //   width?: string,\r\n  //   height?: string\r\n  // ) {\r\n  //   const ref = dialogService.open(componentType, {\r\n  //     width: width,\r\n  //     height: height,\r\n  //     closable: false,\r\n  //     maximizable: true,\r\n  //     data: { id: id, popup: true }\r\n  //   });\r\n\r\n  //   ref.onClose.subscribe((data: any) => {\r\n  //     if (data) callBackFunction(data);\r\n  //   });\r\n  // }\r\n\r\n  static setControlValue(formGroup: FormGroup, controName: string, value: any) {\r\n    formGroup?.controls[controName]?.setValue(value);\r\n  }\r\n\r\n  static setValidators(formGroup: FormGroup, controName: string, validators: ValidatorFn | ValidatorFn[] | null) {\r\n    formGroup?.controls[controName]?.setValidators(validators);\r\n    formGroup?.controls[controName]?.updateValueAndValidity();\r\n  }\r\n\r\n  static clearValidators(formGroup: FormGroup, controName: string) {\r\n    formGroup?.controls[controName]?.updateValueAndValidity();\r\n  }\r\n}\r\n"]}

package/esm2020/lib/buttons/button-personalize/button-personalize.component.mjs

@@ -9,9 +9,9 @@ export class ButtonPersonalizeComponent extends BaseComponentButton {
     }
 }
 ButtonPersonalizeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ButtonPersonalizeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-ButtonPersonalizeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ButtonPersonalizeComponent, selector: "kv-button-personalize", usesInheritance: true, ngImport: i0, template: "\r\n<button\r\n  pButton\r\n  pRipple\r\n  [class]=\"color\"\r\n  [icon]=\"icon\"\r\n  [label]=\"label\"\r\n  [loading]=\"loading\"\r\n  (click)=\"click($event)\">\r\n</button>\r\n\r\n", styles: [""], dependencies: [{ kind: "directive", type: i1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "directive", type: i2.Ripple, selector: "[pRipple]" }] });
+ButtonPersonalizeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.8", type: ButtonPersonalizeComponent, selector: "kv-button-personalize", usesInheritance: true, ngImport: i0, template: "\r\n<button\r\n  pButton\r\n  pRipple\r\n  [class]=\"color\"\r\n  [icon]=\"icon\"\r\n  [label]=\"label\"\r\n  [loading]=\"loading\"\r\n  (click)=\"click($event)\"\r\n  class=\"btn-personalize\">\r\n</button>\r\n\r\n", styles: [".btn-personalize{height:40px}\n"], dependencies: [{ kind: "directive", type: i1.ButtonDirective, selector: "[pButton]", inputs: ["iconPos", "loadingIcon", "label", "icon", "loading"] }, { kind: "directive", type: i2.Ripple, selector: "[pRipple]" }] });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ButtonPersonalizeComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'kv-button-personalize', template: "\r\n<button\r\n  pButton\r\n  pRipple\r\n  [class]=\"color\"\r\n  [icon]=\"icon\"\r\n  [label]=\"label\"\r\n  [loading]=\"loading\"\r\n  (click)=\"click($event)\">\r\n</button>\r\n\r\n" }]
+            args: [{ selector: 'kv-button-personalize', template: "\r\n<button\r\n  pButton\r\n  pRipple\r\n  [class]=\"color\"\r\n  [icon]=\"icon\"\r\n  [label]=\"label\"\r\n  [loading]=\"loading\"\r\n  (click)=\"click($event)\"\r\n  class=\"btn-personalize\">\r\n</button>\r\n\r\n", styles: [".btn-personalize{height:40px}\n"] }]
         }], ctorParameters: function () { return []; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnV0dG9uLXBlcnNvbmFsaXplLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2tlZXZvLWNvbXBvbmVudHMvc3JjL2xpYi9idXR0b25zL2J1dHRvbi1wZXJzb25hbGl6ZS9idXR0b24tcGVyc29uYWxpemUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2J1dHRvbnMvYnV0dG9uLXBlcnNvbmFsaXplL2J1dHRvbi1wZXJzb25hbGl6ZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlEQUFpRCxDQUFDOzs7O0FBT3RGLE1BQU0sT0FBTywwQkFBMkIsU0FBUSxtQkFBbUI7SUFDakU7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7O3VIQUhVLDBCQUEwQjsyR0FBMUIsMEJBQTBCLG9GQ1J2QywwTEFXQTsyRkRIYSwwQkFBMEI7a0JBTHRDLFNBQVM7K0JBQ0UsdUJBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEJhc2VDb21wb25lbnRCdXR0b24gfSBmcm9tICcuLi8uLi9hcGkvYmFzZS1jb21wb25lbnRzL2Jhc2UtY29tcG9uZW50LWJ1dHRvbic7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2t2LWJ1dHRvbi1wZXJzb25hbGl6ZScsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL2J1dHRvbi1wZXJzb25hbGl6ZS5jb21wb25lbnQuaHRtbCcsXHJcbiAgc3R5bGVVcmxzOiBbJy4vYnV0dG9uLXBlcnNvbmFsaXplLmNvbXBvbmVudC5zY3NzJ11cclxufSlcclxuZXhwb3J0IGNsYXNzIEJ1dHRvblBlcnNvbmFsaXplQ29tcG9uZW50IGV4dGVuZHMgQmFzZUNvbXBvbmVudEJ1dHRvbiB7XHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgICBzdXBlcigpO1xyXG4gIH1cclxufVxyXG4iLCJcclxuPGJ1dHRvblxyXG4gIHBCdXR0b25cclxuICBwUmlwcGxlXHJcbiAgW2NsYXNzXT1cImNvbG9yXCJcclxuICBbaWNvbl09XCJpY29uXCJcclxuICBbbGFiZWxdPVwibGFiZWxcIlxyXG4gIFtsb2FkaW5nXT1cImxvYWRpbmdcIlxyXG4gIChjbGljayk9XCJjbGljaygkZXZlbnQpXCI+XHJcbjwvYnV0dG9uPlxyXG5cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnV0dG9uLXBlcnNvbmFsaXplLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2tlZXZvLWNvbXBvbmVudHMvc3JjL2xpYi9idXR0b25zL2J1dHRvbi1wZXJzb25hbGl6ZS9idXR0b24tcGVyc29uYWxpemUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMva2Vldm8tY29tcG9uZW50cy9zcmMvbGliL2J1dHRvbnMvYnV0dG9uLXBlcnNvbmFsaXplL2J1dHRvbi1wZXJzb25hbGl6ZS5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLGlEQUFpRCxDQUFDOzs7O0FBT3RGLE1BQU0sT0FBTywwQkFBMkIsU0FBUSxtQkFBbUI7SUFDakU7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7O3VIQUhVLDBCQUEwQjsyR0FBMUIsMEJBQTBCLG9GQ1J2Qyx5TkFZQTsyRkRKYSwwQkFBMEI7a0JBTHRDLFNBQVM7K0JBQ0UsdUJBQXVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEJhc2VDb21wb25lbnRCdXR0b24gfSBmcm9tICcuLi8uLi9hcGkvYmFzZS1jb21wb25lbnRzL2Jhc2UtY29tcG9uZW50LWJ1dHRvbic7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2t2LWJ1dHRvbi1wZXJzb25hbGl6ZScsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL2J1dHRvbi1wZXJzb25hbGl6ZS5jb21wb25lbnQuaHRtbCcsXHJcbiAgc3R5bGVVcmxzOiBbJy4vYnV0dG9uLXBlcnNvbmFsaXplLmNvbXBvbmVudC5zY3NzJ11cclxufSlcclxuZXhwb3J0IGNsYXNzIEJ1dHRvblBlcnNvbmFsaXplQ29tcG9uZW50IGV4dGVuZHMgQmFzZUNvbXBvbmVudEJ1dHRvbiB7XHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgICBzdXBlcigpO1xyXG4gIH1cclxufVxyXG4iLCJcclxuPGJ1dHRvblxyXG4gIHBCdXR0b25cclxuICBwUmlwcGxlXHJcbiAgW2NsYXNzXT1cImNvbG9yXCJcclxuICBbaWNvbl09XCJpY29uXCJcclxuICBbbGFiZWxdPVwibGFiZWxcIlxyXG4gIFtsb2FkaW5nXT1cImxvYWRpbmdcIlxyXG4gIChjbGljayk9XCJjbGljaygkZXZlbnQpXCJcclxuICBjbGFzcz1cImJ0bi1wZXJzb25hbGl6ZVwiPlxyXG48L2J1dHRvbj5cclxuXHJcbiJdfQ==