keevo-components 1.8.42 → 1.8.45

package/src/lib/api/modules/primeng.module.ts

@@ -0,0 +1,130 @@
+import { NgModule } from '@angular/core';
+
+import { AccordionModule } from 'primeng/accordion';
+import { AutoFocusModule } from 'primeng/autofocus';
+import { BadgeModule } from 'primeng/badge';
+import { BreadcrumbModule } from 'primeng/breadcrumb';
+import { ButtonModule } from 'primeng/button';
+import { CalendarModule } from 'primeng/calendar';
+import { CardModule } from 'primeng/card';
+import { CarouselModule } from 'primeng/carousel';
+import { ChartModule } from 'primeng/chart';
+import { CheckboxModule } from 'primeng/checkbox';
+import { ChipModule } from 'primeng/chip';
+import { ConfirmationService, MessageService } from 'primeng/api';
+import { ConfirmDialogModule } from 'primeng/confirmdialog';
+import { ContextMenuModule } from 'primeng/contextmenu';
+import { DataViewModule } from 'primeng/dataview';
+import { DialogModule } from 'primeng/dialog';
+import { DialogService, DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { DividerModule } from 'primeng/divider';
+import { DropdownModule } from 'primeng/dropdown';
+import { DynamicDialogModule } from 'primeng/dynamicdialog';
+import { EditorModule } from 'primeng/editor';
+import { FieldsetModule } from 'primeng/fieldset';
+import { FileUploadModule } from 'primeng/fileupload';
+import { ImageModule } from 'primeng/image';
+import { InputMaskModule } from 'primeng/inputmask';
+import { InputNumberModule } from 'primeng/inputnumber';
+import { InputSwitchModule } from 'primeng/inputswitch';
+import { InputTextareaModule } from 'primeng/inputtextarea';
+import { InputTextModule } from 'primeng/inputtext';
+import { KnobModule } from 'primeng/knob';
+import { MenuModule } from 'primeng/menu';
+import { MessageModule } from 'primeng/message';
+import { MessagesModule } from 'primeng/messages';
+import { MultiSelectModule } from 'primeng/multiselect';
+import { OverlayModule } from 'primeng/overlay';
+import { OverlayPanelModule } from 'primeng/overlaypanel';
+import { PanelMenuModule } from 'primeng/panelmenu';
+import { PanelModule } from 'primeng/panel';
+import { PasswordModule } from 'primeng/password';
+import { PickListModule } from 'primeng/picklist';
+import { ProgressBarModule } from 'primeng/progressbar';
+import { RadioButtonModule } from 'primeng/radiobutton';
+import { RatingModule } from 'primeng/rating';
+import { RippleModule } from 'primeng/ripple';
+import { SidebarModule } from 'primeng/sidebar';
+import { SkeletonModule } from 'primeng/skeleton';
+import { SpeedDialModule } from 'primeng/speeddial';
+import { SplitButtonModule } from 'primeng/splitbutton';
+import { StepsModule } from 'primeng/steps'
+import { StyleClassModule } from 'primeng/styleclass';
+import { TableModule } from 'primeng/table';
+import { TabViewModule } from 'primeng/tabview';
+import { TagModule } from 'primeng/tag';
+import { ToastModule } from 'primeng/toast';
+import { ToolbarModule } from 'primeng/toolbar';
+import { TooltipModule } from 'primeng/tooltip';
+import { TreeModule } from 'primeng/tree';
+import { TreeTableModule } from 'primeng/treetable';
+
+@NgModule({
+  exports: [
+    AccordionModule,
+    AutoFocusModule,
+    BadgeModule,
+    BreadcrumbModule,
+    ButtonModule,
+    CalendarModule,
+    CardModule,
+    CarouselModule,
+    ChartModule,
+    CheckboxModule,
+    ChipModule,
+    ConfirmDialogModule,
+    ContextMenuModule,
+    DataViewModule,
+    DialogModule,
+    DividerModule,
+    DropdownModule,
+    DynamicDialogModule,
+    EditorModule,
+    FieldsetModule,
+    FileUploadModule,
+    ImageModule,
+    InputMaskModule,
+    InputNumberModule,
+    InputSwitchModule,
+    InputTextareaModule,
+    InputTextModule,
+    KnobModule,
+    MenuModule,
+    MessageModule,
+    MessagesModule,
+    MultiSelectModule,
+    OverlayModule,
+    OverlayPanelModule,
+    OverlayPanelModule,
+    PanelMenuModule,
+    PanelModule,
+    PasswordModule,
+    PickListModule,
+    ProgressBarModule,
+    RadioButtonModule,
+    RatingModule,
+    RippleModule,
+    SidebarModule,
+    SkeletonModule,
+    SpeedDialModule,
+    SplitButtonModule,
+    StepsModule,
+    StyleClassModule,
+    TableModule,
+    TabViewModule,
+    TagModule,
+    ToastModule,
+    ToolbarModule,
+    TooltipModule,
+    TreeModule,
+    TreeTableModule,
+  ],
+  providers: [
+    ConfirmationService,
+    DialogService,
+    DynamicDialogRef,
+    DynamicDialogConfig,
+    MessageService,
+  ]
+})
+export class PrimeNgModule { }

package/src/lib/api/pipes/cpfcnpj.pipe.ts

@@ -0,0 +1,21 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'cpfCnpj' })
+export class CpfCnpjPipe implements PipeTransform {
+
+  transform(value: string) {
+    if (value) {
+
+      const identificacao = value.replace(/[^0-9]/g, '');
+
+      if (identificacao.length === 11) {
+        return identificacao.replace(/(\d{3})(\d{3})(\d{3})(\d{2})/g, "\$1.\$2.\$3\-\$4");
+      } else if (identificacao.length === 14) {
+        return identificacao.replace(/(\d{2})(\d{3})(\d{3})(\d{4})(\d{2})/g, "\$1.\$2.\$3\/\$4\-\$5");
+      }
+
+      return value;
+    }
+    else return null;
+  }
+}

package/src/lib/api/pipes/mask.pipe.ts

@@ -0,0 +1,24 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'mask'
+})
+export class MaskPipe implements PipeTransform {
+  transform(value: string, mask: string): any {
+    if (!value) return '';
+
+    let i = 0;
+    let maskedValue = '';
+    for (let m of mask) {
+      if (m !== '9' && m !== 'X') {
+        maskedValue += m;
+        continue;
+      }
+
+      if (i >= value.length) break;
+
+      maskedValue += value[i++];
+    }
+    return maskedValue;
+  }
+}

package/src/lib/api/pipes/pipes.module.ts

@@ -0,0 +1,23 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+
+import { CpfCnpjPipe } from './cpfcnpj.pipe';
+import { MaskPipe } from './mask.pipe';
+import { TelefonePipe } from './telefone.pipe';
+
+@NgModule({
+  imports: [
+    CommonModule
+  ],
+  declarations: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+  ],
+  exports: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+  ]
+})
+export class PipesModule { }

package/src/lib/api/pipes/telefone.pipe.ts

@@ -0,0 +1,38 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'Telefone'
+})
+export class TelefonePipe implements PipeTransform {
+
+  transform(tel: string) {
+    if (tel) {
+      const value = tel.toString().replace(/\D/g, '');
+
+      let foneFormatado = '';
+
+      if (value.length > 12) {
+        foneFormatado = value.replace(/(\d{2})?(\d{2})?(\d{5})?(\d{4})/, '+$1 ($2) $3-$4');
+
+      } else if (value.length > 11) {
+        foneFormatado = value.replace(/(\d{2})?(\d{2})?(\d{4})?(\d{4})/, '+$1 ($2) $3-$4');
+
+      } else if (value.length > 10) {
+        foneFormatado = value.replace(/(\d{2})?(\d{5})?(\d{4})/, '($1) $2-$3');
+
+      } else if (value.length > 9) {
+        foneFormatado = value.replace(/(\d{2})?(\d{4})?(\d{4})/, '($1) $2-$3');
+
+      } else if (value.length > 5) {
+        foneFormatado = value.replace(/^(\d{2})?(\d{4})?(\d{0,4})/, '($1) $2-$3');
+
+      } else if (value.length > 1) {
+        foneFormatado = value.replace(/^(\d{2})?(\d{0,5})/, '($1) $2');
+      } else {
+        if (tel !== '') { foneFormatado = value.replace(/^(\d*)/, '($1'); }
+      }
+      return foneFormatado;
+    }
+    else return null;
+  }
+}

package/src/lib/api/services/base.api.service.ts

@@ -0,0 +1,115 @@
+import { HttpClient, HttpHeaders, HttpParams } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+
+const httpOptions = {
+    headers: new HttpHeaders({
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    }),
+};
+
+@Injectable({
+    providedIn: 'root',
+})
+export class BaseApiService {
+    constructor(private http: HttpClient) { }
+
+    delete(
+        baseUrl: string,
+        rota: string) {
+        return this.http.delete(`${baseUrl}${rota}`);
+    }
+
+    deleteAllBody<T>(
+        baseUrl: string,
+        rota: string,
+        body: T): Observable<T[]> {
+        return this.http.delete(`${baseUrl}${rota}`, {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+            }),
+            body: body
+        }) as Observable<T[]>;
+    }
+
+    deleteAllHeaders<T>(
+        baseUrl: string,
+        rota: string,
+        headers: HttpHeaders): Observable<T> {
+        return this.http.delete(`${baseUrl}${rota}`, {
+            headers: headers,
+        }) as Observable<T>;
+    }
+
+    get<T>(
+        baseUrl: string,
+        rota: string): Observable<T> {
+        return this.http.get(`${baseUrl}${rota}`) as Observable<T>;
+    }
+
+    getHeaders<T>(
+        baseUrl: string,
+        rota: string,
+        headers: HttpHeaders): Observable<T> {
+        return this.http.get(`${baseUrl}${rota}`, {
+            headers: headers,
+        }) as Observable<T>;
+    }
+
+    getAll<T>(
+        baseUrl: string,
+        rota: string): Observable<T[]> {
+        return this.http.get(`${baseUrl}${rota}`) as Observable<T[]>;
+    }
+
+    getAllHeaders<T>(
+        baseUrl: string,
+        rota: string,
+        headers: HttpHeaders): Observable<T[]> {
+        return this.http.get(`${baseUrl}${rota}`, {
+            headers: headers,
+        }) as Observable<T[]>;
+    }
+
+    getAllParams<T>(
+        baseUrl: string,
+        rota: string,
+        params?: HttpParams): Observable<T[]> {
+        return this.http.get(`${baseUrl}${rota}`, {
+            params: params,
+        }) as Observable<T[]>;
+    }
+
+    getArquivo(
+        baseUrl: string,
+        rota: string,
+        id?: string,
+        paramCabecalho?: { headers: HttpHeaders }
+    ): Observable<any> {
+        return this.http.get<any>(`${baseUrl}${rota}/${id}`, paramCabecalho);
+    }
+
+    getArquivos(
+        baseUrl: string,
+        rota: string,
+        paramCabecalho?: { headers: HttpHeaders }
+    ): Observable<any> {
+        return this.http.get<any>(`${baseUrl}${rota}`, paramCabecalho) as Observable<any>;
+    }
+
+    post<T>(
+        baseUrl: string,
+        rota: string,
+        data?: T): Observable<T> {
+        return this.http.post(`${baseUrl}${rota}`, data) as Observable<T>;
+    }
+
+    put<T>(
+        baseUrl: string,
+        rota: string,
+        data: T): Observable<T> {
+        return this.http.put(`${baseUrl}${rota}`, data) as Observable<T>;
+    }
+}

package/src/lib/api/services/breadcrumbs.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+
+import {
+  ActivatedRoute,
+  NavigationEnd,
+  Router
+} from '@angular/router';
+
+import { filter } from 'rxjs/operators';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class BreadcrumbsService {
+  private breadcrumbsSubject = new BehaviorSubject<{ label: string; routerLink: string }[]>([]);
+  breadcrumbs$ = this.breadcrumbsSubject.asObservable();
+
+  constructor(private router: Router, private activatedRoute: ActivatedRoute) {
+    this.router.events
+      .pipe(filter((event) => event instanceof NavigationEnd))
+      .subscribe(() => {
+        const breadcrumbs = this.parseRoute(this.router.routerState.root);
+        this.breadcrumbsSubject.next(breadcrumbs);
+      });
+  }
+
+  private parseRoute(route: ActivatedRoute, url: string = '', breadcrumbs: { label: string; routerLink: string }[] = []): { label: string; routerLink: string }[] {
+    const path = route.routeConfig && route.routeConfig.path ? route.routeConfig.path : '';
+    const label = route.routeConfig && route.routeConfig.data ? route.routeConfig.data['breadcrumb'] : '';
+
+    if (path && label) {
+      if (url === '') {
+        breadcrumbs.push({
+          label: label,
+          routerLink: `/${path}`,
+        });
+      } else {
+        breadcrumbs.push({
+          label: label,
+          routerLink: `${url}/${path}`,
+        });
+      }
+    }
+
+    const nextRoute = route.firstChild;
+    if (nextRoute) {
+      if (url === '') {
+        return this.parseRoute(nextRoute, path, breadcrumbs);
+      } else {
+        return this.parseRoute(nextRoute, `${url}/${path}`, breadcrumbs);
+      }
+    }
+
+    return breadcrumbs;
+  }
+
+}

package/src/lib/api/services/component.service.ts

@@ -0,0 +1,32 @@
+import {
+  ChangeDetectorRef,
+  Injectable,
+  Injector
+} from '@angular/core';
+
+import {
+  FormControl,
+  FormControlName,
+  FormGroupDirective,
+  NgControl
+} from '@angular/forms';
+
+@Injectable()
+export class ComponentService {
+
+  constructor(public readonly injector: Injector, public changeDetectorRef: ChangeDetectorRef) { }
+
+  getFormControl(): FormControl<any> | undefined {
+    try {
+      const control = this.injector.get(NgControl);
+      if (control.constructor === FormControlName) {
+        return this.injector.get(FormGroupDirective).getControl(control as FormControlName);
+      }
+
+      return undefined;
+    }
+    catch (ex) {
+      return undefined;
+    }
+  }
+}

package/src/lib/api/services/docs.service.ts

@@ -0,0 +1,129 @@
+import { Injectable } from "@angular/core";
+import { FormControl } from "@angular/forms";
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DocsService {
+
+    public static validaCpfCnpj(cpfcnpj: string): boolean {
+        cpfcnpj = cpfcnpj.replace(/\D/g, '');
+
+        if (cpfcnpj.length === 11) {
+            return DocsService.validaCpf(cpfcnpj);
+        } else if (cpfcnpj.length === 14) {
+            return DocsService.validaCnpj(cpfcnpj);
+        } else {
+            return false;
+        }
+    }
+
+    public static validaCpf(cpf: string) {
+        cpf = cpf.replace(/\D+/g, '');
+        if (
+            !cpf ||
+            cpf.length !== 11 ||
+            cpf === '0'.repeat(11) ||
+            cpf === '1'.repeat(11) ||
+            cpf === '2'.repeat(11) ||
+            cpf === '3'.repeat(11) ||
+            cpf === '4'.repeat(11) ||
+            cpf === '5'.repeat(11) ||
+            cpf === '6'.repeat(11) ||
+            cpf === '7'.repeat(11) ||
+            cpf === '8'.repeat(11) ||
+            cpf === '9'.repeat(11)
+        ) {
+            return false;
+        }
+        let soma = 0;
+        let resto;
+        for (let i = 1; i <= 9; i++) {
+            soma = soma + parseInt(cpf.substring(i - 1, i)) * (11 - i);
+        }
+        resto = (soma * 10) % 11;
+        if (resto === 10 || resto === 11) {
+            resto = 0;
+        }
+        if (resto !== parseInt(cpf.substring(9, 10))) {
+            return false;
+        }
+        soma = 0;
+        for (let i = 1; i <= 10; i++) {
+            soma = soma + parseInt(cpf.substring(i - 1, i)) * (12 - i);
+        }
+        resto = (soma * 10) % 11;
+        if (resto === 10 || resto === 11) {
+            resto = 0;
+        }
+        if (resto !== parseInt(cpf.substring(10, 11))) {
+            return false;
+        }
+        return true;
+    }
+
+    public static validaCnpj(cnpj: string) {
+        cnpj = cnpj.replace(/\D+/g, '');
+        if (
+            !cnpj ||
+            cnpj.length !== 14 ||
+            cnpj === '0'.repeat(14) ||
+            cnpj === '1'.repeat(14) ||
+            cnpj === '2'.repeat(14) ||
+            cnpj === '3'.repeat(14) ||
+            cnpj === '4'.repeat(14) ||
+            cnpj === '5'.repeat(14) ||
+            cnpj === '6'.repeat(14) ||
+            cnpj === '7'.repeat(14) ||
+            cnpj === '8'.repeat(14) ||
+            cnpj === '9'.repeat(14)
+        ) {
+            return false;
+        }
+        let tamanho = cnpj.length - 2;
+        let numeros: any = cnpj.substring(0, tamanho);
+        const digitos = cnpj.substring(tamanho);
+        let soma = 0;
+        let pos: number = tamanho - 7;
+        for (let i = tamanho; i >= 1; i--) {
+            soma += numeros.charAt(tamanho - i) * pos--;
+            if (pos < 2) {
+                pos = 9;
+            }
+        }
+        let resultado = soma % 11 < 2 ? 0 : 11 - (soma % 11);
+        if (resultado !== (+digitos.charAt(0))) {
+            return false;
+        }
+        tamanho = tamanho + 1;
+        numeros = cnpj.substring(0, tamanho);
+        soma = 0;
+        pos = tamanho - 7;
+        for (let i = tamanho; i >= 1; i--) {
+            soma += numeros.charAt(tamanho - i) * pos--;
+            if (pos < 2) {
+                pos = 9;
+            }
+        }
+        resultado = soma % 11 < 2 ? 0 : 11 - (soma % 11);
+        if (resultado !== (+digitos.charAt(1))) {
+            return false;
+        }
+        return true;
+    }
+
+    public static validatorCpfCnpj(fc: FormControl) {
+
+        if (!fc.value) return false;
+
+        if (fc.value.replace(/\D+/g, '') === '00000000000' || fc.value.replace(/\D+/g, '') === '000000000000000') {
+            return false;
+        } else if (fc.value.replace(/\D+/g, '').length === 11) {
+            return DocsService.validaCpf(fc.value) ? false : { cpfCnpj: true };
+        } else if (fc.value.replace(/\D+/g, '').length === 14) {
+            return DocsService.validaCnpj(fc.value) ? false : { cpfCnpj: true };
+        } else {
+            return { cpfCnpj: true };
+        }
+    }
+}

package/src/lib/api/services/form.service.ts

@@ -0,0 +1,115 @@
+import {
+  Injectable,
+  Type
+} from '@angular/core';
+
+import {
+  FormGroup,
+  ValidatorFn
+} from '@angular/forms';
+
+import { ObjectService } from './object.service';
+import { DialogService } from 'primeng/dynamicdialog';
+
+export interface paramsDialog {
+  id?: any;
+  closable?: boolean;
+  maximizable?: boolean;
+  popup?: boolean;
+  height?: string;
+  width?: string;
+  styleClass?: string;
+  header?: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class FormService {
+
+  static disableControl(formGroup: FormGroup, controName: string) {
+    formGroup?.controls[controName]?.disable();
+  }
+
+  static disableAndClearControl(formGroup: FormGroup, controName: string, value?: any) {
+    this.disableControl(formGroup, controName);
+    this.setControlValue(formGroup, controName, null || value);
+  }
+
+  static enableControl(formGroup: FormGroup, controName: string) {
+    formGroup?.controls[controName]?.enable();
+  }
+
+  static getFormValue<T>(formGroup: FormGroup, controName: string): T {
+    return <T>formGroup?.controls[controName]?.value;
+  }
+
+  static hasControlError(formGroup: FormGroup, control: string, errorCode?: string): boolean {
+    const formControl = formGroup.get(control);
+    let hasError: boolean = false;
+
+    if (!formControl) return false;
+    if (errorCode) hasError = formControl.hasError(errorCode);
+    else hasError = formControl.errors ? true : false;
+
+    return hasError && formControl.touched;
+  }
+
+  static invalidForm(formGroup: FormGroup, notification?: any) {
+    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: DialogService,
+    componentType: Type<any>,
+    callBackFunction: Function,
+    paramsDialog?: paramsDialog
+  ) {
+    const ref = dialogService.open(componentType, {
+      closable: paramsDialog?.closable || false,
+      maximizable: paramsDialog?.maximizable || false,
+      height: paramsDialog?.height || 'auto',
+      width: paramsDialog?.width,
+      styleClass: paramsDialog?.styleClass,
+      showHeader: true,
+      header: paramsDialog?.header,
+      data: { id: paramsDialog?.id, popup: paramsDialog?.popup && true }
+    });
+
+    ref.onClose.subscribe((data: any) => {
+      if (data) callBackFunction(data);
+    });
+  }
+
+  static setControlValue(formGroup: FormGroup, controName: string, value: any) {
+    formGroup?.controls[controName]?.setValue(value);
+  }
+
+  static setValidators(formGroup: FormGroup, controName: string, validators: ValidatorFn | ValidatorFn[] | null) {
+    formGroup?.controls[controName]?.setValidators(validators);
+    formGroup?.controls[controName]?.updateValueAndValidity();
+  }
+
+  static clearValidators(formGroup: FormGroup, controName: string) {
+    formGroup?.controls[controName]?.updateValueAndValidity();
+  }
+}