keevo-components 1.8.125 → 1.8.127

package/src/lib/api/directives/template/template.directive.ts

@@ -0,0 +1,15 @@
+import { Directive, Input, TemplateRef } from '@angular/core';
+
+@Directive({
+  selector: '[cTemplate]'
+})
+export class TemplateDirective {
+  @Input() type!: string;
+  @Input('cTemplate') name!: string;
+
+  constructor(public template: TemplateRef<any>) { }
+
+  getType(): string {
+    return this.name;
+  }
+}

package/src/lib/api/helpers/component-providers.ts

@@ -0,0 +1,16 @@
+import { Provider, forwardRef } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { ComponentService } from '../services/component.service';
+
+export function ComponentProviders(ref: any): Provider[] {
+  return [
+    {
+      provide: NG_VALUE_ACCESSOR,
+      useExisting: forwardRef(() => ref),
+      multi: true,
+    },
+    {
+      provide: ComponentService
+    }
+  ]
+}

package/src/lib/api/helpers/keevo-validators.ts

@@ -0,0 +1,97 @@
+import { AbstractControl, FormGroup, ValidationErrors, ValidatorFn, Validators } from '@angular/forms';
+import { DocsService } from '../services/docs.service';
+
+export class KeevoValidators {
+  static required(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.required(control))
+        return { required: true, erroMessage: `${erroMessage ? erroMessage : 'Campo obrigatório'}` };
+
+      return null;
+    };
+  }
+
+  static dateGreaterThan(startControlName: string, erroMessage?: string): ValidatorFn {
+    return (endControl: AbstractControl): ValidationErrors | null => {
+      const parent = endControl.parent as FormGroup;
+
+      if (!parent) return null;
+
+      const startControl: AbstractControl = parent.get(startControlName) as AbstractControl;
+
+      const startDate: Date = startControl.value;
+      const endDate: Date = endControl.value;
+
+      if (!startDate || !endDate) {
+        return null;
+      }
+      if (startDate > endDate) {
+        return { greaterThan: true, erroMessage: erroMessage };
+      }
+      return null;
+    };
+  }
+
+  static min(min: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.min(min)(control))
+        return { min: true, erroMessage: `${erroMessage ? erroMessage : 'Informe um valor maior ou igual à '}${min}` };
+
+      return null;
+    };
+  }
+
+  static max(min: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.max(min)(control))
+        return { min: true, erroMessage: `${erroMessage ? erroMessage : 'Informe um valor menor ou igual à '}${min}` };
+
+      return null;
+    };
+  }
+
+  static email(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.email(control)) {
+        return { email: true, erroMessage: `${erroMessage ? erroMessage : 'Endereço de e-mail inválido!'}` };
+      }
+      return null;
+    };
+  }
+
+  static maxLengthArray(max: number): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (control.value.length < max)
+        return null;
+
+      return { maxLengthArray: true, erroMessage: 'Tamanho máximo excedido!' };
+    }
+  }
+
+  static maxLength(max: number, erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      if (Validators.maxLength(max)(control))
+        return { maxLength: true, erroMessage: `${erroMessage ? erroMessage : 'Limite máximo de ${max} caracteres atingido!'}` };
+      return null;
+    }
+  }
+
+  static nome(): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      let palavras = control.value.trim().split(' ');
+      if (palavras?.length < 2)
+        return { nome: true, erroMessage: 'Digite seu nome completo.' };
+      return null;
+    }
+  }
+
+  static cpfCnpjValido(erroMessage?: string): ValidatorFn {
+    return (control: AbstractControl): ValidationErrors | null => {
+      let value = (control.value ?? '').replace(/\D/g, '');
+      if (!DocsService.validaCpfCnpj(value)) {
+        return { cpfcnpj: true, erroMessage: `${erroMessage ? erroMessage : 'CPF/CNPJ inválido!'}` };
+      }
+      return null;
+    };
+  }
+}

package/src/lib/api/helpers/severity-color.ts

@@ -0,0 +1,77 @@
+import Severity from "../types/severity";
+
+export function severityColorNormal(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#002542";
+    case "secondary":
+      return "#F2F3F5";
+    case "success":
+      return "#29B92D";
+    case "info":
+      return "#03A9F4";
+    case "warning":
+      return "#FFC107";
+    case "help":
+      return "#9C27B0";
+    case "danger":
+      return "#F44336";
+  }
+}
+
+export function severityColorHover(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#002038";
+    case "secondary":
+      return "#D9DADB";
+    case "success":
+      return "#249A29";
+    case "info":
+      return "#039BE5";
+    case "warning":
+      return "#FFB300";
+    case "help":
+      return "#8E24AA";
+    case "danger":
+      return "#E53935";
+  }
+}
+
+export function severityColorActive(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#001729";
+    case "secondary":
+      return "#C0C1C2";
+    case "success":
+      return "#1C801F";
+    case "info":
+      return "#0288D1";
+    case "warning":
+      return "#FFA000";
+    case "help":
+      return "#7B1FA2";
+    case "danger":
+      return "#d32f2f";
+  }
+}
+
+export function severityColorText(severity: Severity): string {
+  switch (severity) {
+    case "primary":
+      return "#FFFFFF";
+    case "secondary":
+      return "#212121";
+    case "success":
+      return "#FFFFFF";
+    case "info":
+      return "#FFFFFF";
+    case "warning":
+      return "#495057"
+    case "help":
+      return "#FFFFFF";
+    case "danger":
+      return "#FFFFFF";
+  }
+}

package/src/lib/api/helpers/translate-primeng.ts

@@ -0,0 +1,25 @@
+import { PrimeNGConfig } from 'primeng/api';
+
+export class TranslatePrimeng {
+  public config(config: PrimeNGConfig): void {
+    config.ripple = true;
+
+    config.setTranslation({
+      monthNames: ['Janeiro', 'Fevereiro', 'Março', 'Abril', 'Maio', 'Junho', 'Julho', 'Agosto', 'Setembro', 'Outubro', 'Novembro', 'Dezembro'],
+      monthNamesShort: ['Jan', 'Fev', 'Mar', 'Abr', 'Mai', 'Jun', 'Jul', 'Ago', 'Set', 'Out', 'Nov', 'Dez'],
+      dayNames: ['Domingo', 'Segunda', 'Terça', 'Quarta', 'Quinta', 'Sexta', 'Sabádo'],
+      dayNamesShort: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'],
+      dayNamesMin: ['Dom', 'Seg', 'Ter', 'Qua', 'Qui', 'Sex', 'Sab'],
+      today: 'Hoje',
+      weekHeader: 'Semana',
+      emptyMessage: 'Nenhum resultado encontrado',
+      emptyFilterMessage: 'Nenhum registro encontrado com o filtro informado',
+      weak: 'Fraca',
+      medium: 'Média',
+      strong: 'Forte',
+      passwordPrompt: 'Informe a senha',
+      clear: 'Limpar',
+      apply: 'Aplicar'
+    });
+  }
+}

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

@@ -0,0 +1,134 @@
+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';
+import { SelectButtonModule } from 'primeng/selectbutton';
+import { StepperModule } from 'primeng/stepper';
+
+@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,
+    SelectButtonModule,
+    StepperModule
+  ],
+  providers: [
+    ConfirmationService,
+    DialogService,
+    DynamicDialogRef,
+    DynamicDialogConfig,
+    MessageService,
+  ]
+})
+export class PrimeNgModule { }

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

@@ -0,0 +1,23 @@
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'capitalize'
+})
+export class CapitalizePipe implements PipeTransform {
+
+  private prepositions: string[] = [
+    'de', 'da', 'do', 'em', 'no', 'na', 'para', 'por', 'com', 'a', 'o', 'e'
+  ];
+
+  transform(value: string): string {
+    if (!value) return value;
+
+    return value.split(' ').map((word, index) => {
+      if (index !== 0 && this.prepositions.includes(word.toLocaleLowerCase())) {
+        return word.toLocaleLowerCase();
+      }
+      return word.charAt(0).toLocaleUpperCase() + word.slice(1).toLocaleLowerCase();
+    }).join(' ');
+  }
+
+}

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,26 @@
+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';
+import { CapitalizePipe } from './capitalize.pipe';
+
+@NgModule({
+  imports: [
+    CommonModule
+  ],
+  declarations: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+    CapitalizePipe
+  ],
+  exports: [
+    CpfCnpjPipe,
+    MaskPipe,
+    TelefonePipe,
+    CapitalizePipe
+  ]
+})
+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;
+  }
+
+}