keevo-components 1.8.539 → 1.8.541

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

@@ -0,0 +1,71 @@
+import { Injectable } from '@angular/core';
+
+import {
+  ActivatedRoute,
+  NavigationEnd,
+  Router
+} from '@angular/router';
+
+import { filter } from 'rxjs/operators';
+import { BehaviorSubject } from 'rxjs';
+import { BreadCrumbOption } from '../types/breadcrumb.model';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class BreadcrumbsService {
+  private breadcrumbsSubject = new BehaviorSubject<BreadCrumbOption[]>([]);
+  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: BreadCrumbOption[] = []): BreadCrumbOption[] {
+    const path = route.routeConfig && route.routeConfig.path ? route.routeConfig.path : '';
+    const label = route.routeConfig && route.routeConfig.data ? route.routeConfig.data['breadcrumb'] : '';
+    const showmenu = route.routeConfig && route.routeConfig.data ? route.routeConfig.data['showmenu'] : '';
+
+    // Ajuste para evitar múltiplas barras
+    let combinedUrl = url ? `${url}/${path}` : `/${path}`;
+    combinedUrl = combinedUrl.replace(/\/+/g, '/');  // Remove múltiplas barras
+
+    if (path && label) {
+      breadcrumbs.push({
+        label: label,
+        routerLink: combinedUrl,
+        showMenu: (showmenu === false ? false : true)
+      });
+    }
+
+    const nextRoute = route.firstChild;
+    if (nextRoute) {
+      return this.parseRoute(nextRoute, combinedUrl, breadcrumbs);
+    }
+
+    return breadcrumbs;
+  }
+
+  getBreadCrumbs(): BreadCrumbOption[] {
+    return this.breadcrumbsSubject.value;
+  }
+
+  public changeBreadCrumb(breadCrumbs: BreadCrumbOption[]) {
+    this.breadcrumbsSubject.next(breadCrumbs);
+  }
+
+  public changeLastBreadCrumb(callback: (breadCrumb: BreadCrumbOption | undefined) => BreadCrumbOption|undefined) {
+    const breadCrumbs = this.breadcrumbsSubject.value.map(x => ({ ...x }));
+
+    const lastBreadCrumb = breadCrumbs.pop();
+    const newBreadCrumb = callback(lastBreadCrumb);
+    
+    if(newBreadCrumb)
+      this.breadcrumbsSubject.next([...breadCrumbs, newBreadCrumb]);
+  }
+}

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

@@ -0,0 +1,39 @@
+import { Injectable, signal } from '@angular/core';
+import { Subject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class ChatService {
+
+  constructor() { }
+
+  private _visibleChatBalloon = signal<boolean>(true)
+  private _visibleChatBottom = signal<boolean>(false)
+  private _visibleChatHigher = signal<boolean>(false)
+
+  public visibleChatBalloon = this._visibleChatBalloon.asReadonly()
+  public visibleChatBottom = this._visibleChatBottom.asReadonly()
+  public visibleChatHigher = this._visibleChatHigher.asReadonly()
+
+  private onVisible = new Subject<boolean>()
+  public onVisible$ = this.onVisible.asObservable()
+
+
+  setvisibleChatBalloon(value: boolean){
+    this._visibleChatBalloon.set(value)
+    this.onVisible.next(value)
+    console.log('setvisibleChatBalloon dentro do Serviço', this._visibleChatBalloon())
+  }
+
+  setvisibleChatBottom(value: boolean){
+    this._visibleChatBottom.set(value)
+    value && this._visibleChatHigher.set(false)
+  }
+
+  setvisibleChatHigher(value: boolean){
+    this._visibleChatHigher.set(value)
+    value && this._visibleChatBottom.set(false)
+  }
+
+}

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

@@ -0,0 +1,44 @@
+import {
+  ChangeDetectorRef,
+  Injectable,
+  Injector
+} from '@angular/core';
+
+import {
+  FormControl,
+  FormControlDirective,
+  FormControlName,
+  FormGroupDirective,
+  NgControl
+} from '@angular/forms';
+
+@Injectable()
+// export class ComponentService {
+
+//   constructor(public readonly injector: Injector, public changeDetectorRef: ChangeDetectorRef) {}
+
+//   getFormControl(): FormControl<any> | undefined {
+//     const control = this.injector.get(NgControl)?.control;
+//     return control instanceof FormControl ? control : undefined;
+//   }
+// }
+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);
+      } else if (control instanceof FormControlDirective) {
+        return control.control;
+      }
+
+      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,139 @@
+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;
+  maximizable?: boolean;
+  popup?: boolean;
+  height?: string;
+  width?: string;
+  styleClass?: string;
+  header?: string;
+
+  /**
+   * @deprecated Essa propriedade sempre será false. Não é necessário atribuir valor para ela
+   */
+  closable?: boolean;
+}
+
+@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: 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 },
+      closeOnEscape: false,
+      focusOnShow: false,
+      focusTrap: false,
+    });
+
+    ref.onClose.subscribe((data: any) => {
+      if (data) callBackFunction(data);
+    });
+    return ref;
+  }
+
+  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();
+  }
+}

package/src/lib/api/services/image.cutter.service.ts

@@ -0,0 +1,290 @@
+import { Component, ComponentRef, Injectable, signal } from '@angular/core';
+import { DialogService, DynamicDialogComponent, DynamicDialogConfig, DynamicDialogRef } from 'primeng/dynamicdialog';
+import { DialogModule } from 'primeng/dialog';
+import { ImageCroppedEvent, ImageCropperComponent, LoadedImage } from 'ngx-image-cropper';
+
+@Injectable({providedIn: 'root'})
+export class ImageCutterService {
+
+  constructor(private readonly dialogservice: DialogService) {}
+
+  cut(imageBase64: string, width: number, height: number, indCircle: boolean = false, avatar?: boolean): Promise<string> {
+    const cutConfig = { imageBase64, width, height, indCircle };
+    this.abrirModal(cutConfig, avatar);
+
+    return new Promise<string>((resolve, reject) => {
+      window.addEventListener('cropImage', (event: any) => {
+        if(event.detail.status == true ) {
+          resolve(event.detail.result);
+        }else{
+          reject('Operacao cancelada.');
+        }
+      });
+    });
+  }
+
+  abrirModal(cutConfig: { imageBase64: string, width: number, height: number, indCircle: boolean }, avatar?: boolean) {
+    let quality = 100
+    if(avatar) {
+      quality = 80
+    }
+    const params =       {
+      closable: true,
+      maximizable: false,
+      popup: true,
+      width: '75vw',
+      header: `Cortar` ,
+      id: { imagem: cutConfig.imageBase64, width: cutConfig.width, height: cutConfig.height, indCircle: cutConfig.indCircle, quality: quality },
+      styleClass: 'modal',
+    }
+    const dialogRef: DynamicDialogRef = FormService.openDialog(this.dialogservice, SimpleComponent, ()=>{}, params);
+  }
+
+}
+
+
+// ? Componente de modal usado no cutter
+import { CommonModule } from '@angular/common';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { KvLabelModule } from '../../components/kv-label/kv-label.module';
+import { FormService } from './form.service';
+import { KvModalModule } from '../../components/kv-modal/kv-modal.module';
+import { KvButtonModule } from '../../components/kv-button/kv-button.module';
+import { DomSanitizer, SafeUrl } from '@angular/platform-browser';
+
+@Component({
+  selector: 'app-simple-component',
+  template: `
+      <div class="modal-content">
+
+          <image-cropper
+            [imageBase64]="_variaviesDialog()?.imagem"
+            (imageCropped)="imageCropped($event)"
+            [aspectRatio]="aspectRatio()"
+            (imageLoaded)="imageLoaded($event)"
+            (cropperReady)="cropperReady()"
+            (loadImageFailed)="loadImageFailed()"
+            [roundCropper]="this._variaviesDialog()?.indCircle"
+            [maintainAspectRatio]="true"
+            [imageQuality]="quality"
+            format="jpeg"
+            output='base64'
+            alignImage="center"
+          />
+
+          
+        </div>
+        <div class="button-container">
+          <kv-button label="Cancelar" severity="tertiary" icon="close" (click)="cancel()"></kv-button>
+          <kv-button label="Recortar" severity="primary" icon="crop" (click)="cropImage()" class="ml-2"></kv-button>
+        </div>
+
+
+
+  `,
+  styles: [`
+
+    img {
+      border-style: solid;
+      border-width: 2px;
+      border-radius: 50%;
+      object-fit: cover;
+    }
+    
+    i {
+      font-size: 22px;
+    }
+    
+    .botao-alterar-foto {
+      border-style: none;
+      width: max-content;
+      background-color: #002542;
+      color: black;
+      font-weight: bold;
+      cursor: pointer;
+      padding: 7px 9px;
+    }
+    
+    .botao-alterar-foto i {
+      color: #fff;
+    }
+    
+    .botao-excluir-foto {
+      border-style: none;
+      width: max-content;
+      background-color: #002542;
+      color: black;
+      font-weight: bold;
+      cursor: pointer;
+      padding: 7px 9px;
+    }
+    
+    .botao-excluir-foto i {
+      color: #fff;
+    }
+    
+    .btn {
+      position: absolute;
+      top: 87%;
+      left: 87%;
+      transform: translate(-50%, -50%);
+    }
+    
+    .image-container {
+      display: inline-block;
+      position: relative;
+    }
+    
+    .modal-content {
+      height: 60vh;
+      position: relative;
+      background-color: #fefefe;
+      margin: 1% auto;
+      padding: 20px;
+      width: 80%;
+      max-width: fit-content;
+      text-align: center;
+      border-radius: 12px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    
+    .crop-container {
+      display: flex;
+      justify-content: center;
+      align-items: center;
+    }
+    
+    .crop-canvas {
+      border: 1px solid #d1d5db;
+      border-radius: 12px;
+      width: 100%;
+      height: auto;
+    }
+    
+    .crop-border {
+      position: absolute;
+      border: 2px dashed #9ca3af;
+      pointer-events: none;
+    }
+    
+    .zoom-container {
+      padding-top: 20px;
+      padding-bottom: 20px;
+    }
+    
+    .button-container {
+      display: flex;
+      align-items: center;
+      justify-content: flex-end;
+      flex-direction: row;
+      margin-top: 24px;
+      position: fixed;
+      bottom: 0px;
+      background: #fff;
+      width: 90%;
+      padding: 15px;
+    }
+    
+    
+    
+      `],
+  standalone: true,
+  imports: [
+    CommonModule,
+    DialogModule,
+    KvModalModule,
+    FormsModule,
+    ReactiveFormsModule,
+    KvButtonModule,
+    KvLabelModule,
+    ImageCropperComponent
+  ]
+})
+
+class SimpleComponent {
+
+  constructor(private dynamicDialogRef: DynamicDialogRef, private readonly dialogService: DialogService, private dynamicDialogConfig: DynamicDialogConfig) {}
+  imageChangedEvent: Event | null = null;
+  croppedImage: SafeUrl  = '';
+  
+  quality: number = this.dynamicDialogConfig.data.id.quality;
+    
+    fileChangeEvent(event: Event): void {
+      this.imageChangedEvent = event;
+    }
+    imageCropped(event: ImageCroppedEvent) {
+      this.croppedImage = event.base64!;
+    }
+    imageLoaded(image: LoadedImage) {}
+    cropperReady() {}
+    loadImageFailed() {}
+
+
+
+  //#region Variáveis de controle
+    _variaviesDialog = signal<{ imagem: string, width: number, height: number, indCircle: boolean }|null>(null)
+    private dialogInstance!:DynamicDialogComponent;
+    aspectRatio = signal<any>(1/1)
+  //#endregion
+
+
+  ngAfterContentInit(): void {
+    this.recuperarVariaviesDialog()
+    this.recuperaInstanciaDialog()
+    this.setAspectRatio()
+  }
+
+
+
+  setAspectRatio(width: number = this._variaviesDialog()?.width!, height: number = this._variaviesDialog()?.height!) {
+    const gcd = (a: number, b: number): number => (b === 0 ? a : gcd(b, a % b));
+    const divisor = gcd(width, height);
+    const aspectWidth = width / divisor;
+    const aspectHeight = height / divisor;
+    this.aspectRatio.set(aspectWidth/aspectHeight)
+
+  }
+
+  //#region Métodos de recuperação de dados
+  recuperaInstanciaDialog(): DynamicDialogComponent {
+    const arr: Map<DynamicDialogRef<any>, ComponentRef<any>> = this.dialogService.dialogComponentRefMap
+    const entries = arr.entries();
+    const firstEntry = entries.next().value;
+    const [firstKey, firstValue] = firstEntry!;
+    const instance = this.dialogService.getInstance(firstKey)
+    this.dialogInstance = instance
+    return instance
+  }
+
+  recuperarVariaviesDialog(): void{
+    this._variaviesDialog.set(this.recuperaInstanciaDialog().data.id)
+  }
+  //#endregion
+
+
+  //#region Métodos de corte e fechamento do modal
+  cropImage() {
+          window.dispatchEvent(new CustomEvent('cropImage', { detail: {
+            result: this.croppedImage,
+            status: true
+          } }));
+          this.closeCropModal();
+  }
+
+  closeCropModal() {
+    this.dialogInstance.close();
+  }
+
+  cancel(){
+    window.dispatchEvent(new CustomEvent('cropImage', { detail:{
+      result: Promise.resolve('cancel'),
+      status: false
+    } }));
+
+    this.closeCropModal()
+  }
+  //#endregion
+
+}