@rededor/site-front-end-lib 20.0.26 → 20.0.27

package/core/services/geoloc/geoloc.service.ts

@@ -0,0 +1,225 @@
+import { Injectable, PLATFORM_ID, DOCUMENT, inject } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+import { BehaviorSubject, map, Observable } from 'rxjs';
+import { MapBoxReverseGeocodingParams, MapBoxService } from '../mapbox/mapbox.service';
+import { LogService } from '../log/log.service';
+import { checkSafariAgent } from '../../helpers/check-safari-agent.func';
+import { getCircularReplacer } from '../../helpers/getCircularReplacer.func';
+
+export enum GeolocationPermissions {
+  GRANTED = 'granted',
+  PROMPT = 'prompt',
+  DENIED = 'denied',
+}
+
+export interface Geolocation {
+  lat: number;
+  lng: number;
+}
+
+export interface Address {
+  city: string;
+  state: {
+    name: string;
+    shortCode: string;
+  };
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class GeolocService {
+  private readonly document = inject<Document>(DOCUMENT);
+  private readonly platformId = inject(PLATFORM_ID);
+  private mapboxService = inject(MapBoxService);
+  private readonly logService = inject(LogService);
+
+  private _mapboxGeocodingParams: MapBoxReverseGeocodingParams = {
+    types: 'place',
+    limit: 1,
+    language: 'pt-BR',
+    country: 'BR',
+  };
+
+  private _hasConsent = false;
+  private _switchStatus = false;
+  public get switchStatus(): boolean {
+    return this._switchStatus;
+  }
+  private _address: Address | null = null;
+  public get address(): Address | null {
+    return this._address;
+  }
+
+  private _permission: PermissionState = GeolocationPermissions.PROMPT;
+  public get permission(): PermissionState {
+    return this._permission;
+  }
+
+  public geolocation: BehaviorSubject<Geolocation | null> = new BehaviorSubject<Geolocation | null>(null);
+  public isChecked: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false); // Emite true quando o geoloc está estável
+
+  private _isSafariAgent: boolean = false;
+  private _disableSwitch = false;
+  public get disableSwitch(): boolean {
+    return this._disableSwitch;
+  }
+
+  constructor() {
+    if (isPlatformServer(this.platformId)) {
+      this.isChecked.next(true);
+      return;
+    }
+
+    this._isSafariAgent = checkSafariAgent();
+    if (this._isSafariAgent) {
+      this._hasConsent = this.checkACookieExists('geolocation_consent');
+      this.initGeolocation(this._hasConsent);
+      return;
+    }
+
+    navigator?.permissions
+      ?.query({ name: 'geolocation' })
+      .then((permission) => {
+        this._permission = permission.state;
+        this.initGeolocation(this._permission === GeolocationPermissions.GRANTED);
+
+        permission.onchange = () => {
+          this._permission = permission.state;
+          this.initGeolocation(this._permission === GeolocationPermissions.GRANTED);
+        };
+      })
+      .catch((error) => {
+        this.logService.logMsg(JSON.stringify(error, getCircularReplacer()), 'ERROR');
+        this._permission = GeolocationPermissions.DENIED;
+        this._disableSwitch = true;
+        this.initGeolocation(false);
+      });
+  }
+
+  initGeolocation(geolocAllowed = false): void {
+    this._switchStatus = true;
+    if (geolocAllowed) {
+      this.getCurrentPosition().subscribe({
+        next: (position) => {
+          this._disableSwitch = false;
+          this.setGeolocation(position);
+          this.setConsentCookie(true, 3650);
+          this._hasConsent = true;
+          this._permission = GeolocationPermissions.GRANTED;
+        },
+        error: () => {
+          if (this._permission === GeolocationPermissions.DENIED) {
+            this._disableSwitch = true;
+            this.setConsentCookie(false, 15);
+          }
+          this.geolocation.next(null);
+          this._address = null;
+          this._hasConsent = false;
+          this._switchStatus = false;
+          this.isChecked.next(true);
+        },
+      });
+    } else {
+      if (this.permission === GeolocationPermissions.DENIED) {
+        this._disableSwitch = true;
+        this.setConsentCookie(false, 15);
+      }
+      this.geolocation.next(null);
+      this._address = null;
+      this._hasConsent = false;
+      this._switchStatus = false;
+      this.isChecked.next(true);
+    }
+  }
+
+  private getCurrentPosition(): Observable<GeolocationPosition> {
+    return new Observable((observer) => {
+      navigator.geolocation.getCurrentPosition(
+        (position) => {
+          observer.next(position);
+          observer.complete();
+        },
+        (error) => observer.error(error),
+        { enableHighAccuracy: true },
+      );
+    });
+  }
+
+  private setGeolocation(position: GeolocationPosition): void {
+    if (position) {
+      if (position.coords.latitude === this.geolocation.value?.lat && position.coords.longitude === this.geolocation.value?.lng) return;
+
+      this.geolocation.next({
+        lat: position.coords.latitude,
+        lng: position.coords.longitude,
+      });
+
+      this.getMapboxAdress()
+        .pipe(
+          map((response) => {
+            const city = response?.features[0]?.properties?.name;
+            const state = {
+              name: response?.features[0]?.properties?.context?.region?.name,
+              shortCode: response?.features[0]?.properties?.context?.region?.region_code,
+            };
+            return { city, state };
+          }),
+        )
+        .subscribe({
+          next: (response) => {
+            this._address = response;
+            this._switchStatus = true;
+            this.isChecked.next(true);
+          },
+          error: (error) => {
+            this.logService.logMsg(JSON.stringify(error, getCircularReplacer()), 'ERROR');
+            this._switchStatus = false;
+            this.geolocation.next(null);
+            this._address = null;
+            this.isChecked.next(true);
+          },
+        });
+    } else {
+      this.geolocation.next(null);
+      this._address = null;
+      this._switchStatus = false;
+      this.isChecked.next(true);
+    }
+  }
+
+  private getMapboxAdress(): Observable<any> {
+    const lng = `${this.geolocation.value?.lng}`;
+    const lat = `${this.geolocation.value?.lat}`;
+    return this.mapboxService.reverseGeocoding(lng, lat, this._mapboxGeocodingParams, 'geolocalizacao.service getMapboxAdress');
+  }
+
+  checkACookieExists(name: string): boolean {
+    if (isPlatformServer(this.platformId) || typeof this.document === 'undefined' || !this.document?.cookie) {
+      return false;
+    }
+    return this.document.cookie
+      .split(';')
+      .map((item) => item.trim())
+      .some((item) => item.trim().startsWith(name));
+  }
+
+  private setConsentCookie(status: boolean, days: number): void {
+    if (this.getCookieValue('geolocation_consent') !== status.toString()) {
+      const lifetime = new Date(Date.now() + days * 86400000).toUTCString();
+      this.document.cookie = `geolocation_consent=${status}; path=/; expires=${lifetime}; SameSite=None; Secure`;
+    }
+  }
+
+  private getCookieValue(prop: string): string {
+    if (isPlatformBrowser(this.platformId)) {
+      const value = this.document.cookie
+        .split(';')
+        .map((item) => item.trim())
+        .find((item) => item.startsWith(`${prop}=`));
+
+      return value ? value.slice(prop.length + 1) : '';
+    }
+    return '';
+  }
+}

package/core/services/http-client/http-client.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { HttpClientService } from './http-client.service';
+
+describe('HttpClientService', () => {
+  let service: HttpClientService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(HttpClientService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/core/services/http-client/http-client.service.ts

@@ -0,0 +1,49 @@
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Injectable, PLATFORM_ID, inject } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { Observable } from 'rxjs';
+import { LIB_CONFIG, LibConfig } from '../../tokens/LibConfig';
+
+/* Adiciona os Headers necessários para funcionamento do site back-end */
+@Injectable({ providedIn: 'root' })
+export class HttpClientService {
+  private platformId = inject(PLATFORM_ID);
+  private libConfig = inject<LibConfig>(LIB_CONFIG);
+  private http = inject(HttpClient);
+  private deviceService = inject(DeviceDetectorService);
+
+  get<T = any>(url: string): Observable<T> {
+    const headers = this.getHeaders();
+    return this.http.get<T>(url, { headers });
+  }
+
+  post<T = any>(url: string, data?: any): Observable<T> {
+    const headers = this.getHeaders();
+    return this.http.post<T>(url, data, { headers });
+  }
+
+  private getHeaders(): HttpHeaders {
+    const baseHeaders = new HttpHeaders()
+      .set('x-origin-application', this.libConfig.xOriginApplication)
+      .set('x-origin-channel', this.getOriginChannel())
+      .set('x-origin-device', this.getOriginDevice());
+
+    if (isPlatformServer(this.platformId) && this.libConfig.server) {
+      return baseHeaders.append(
+        'authorization',
+        'Basic ' + Buffer.from(`${this.libConfig.siteApi.auth.user}:${this.libConfig.siteApi.auth.password}`).toString('base64'),
+      );
+    } else {
+      return baseHeaders.append('client_id', this.libConfig.client_id);
+    }
+  }
+
+  private getOriginChannel(): string {
+    return this.deviceService.isDesktop() ? 'desktop' : 'mobile';
+  }
+
+  private getOriginDevice(): string {
+    return `app-${this.deviceService.getDeviceInfo().os}`;
+  }
+}

package/core/services/log/log.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { LogService } from './log.service';
+
+describe('LogService', () => {
+  let service: LogService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(LogService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/core/services/log/log.service.ts

@@ -0,0 +1,36 @@
+import { Injectable, PLATFORM_ID, inject } from '@angular/core';
+import { isPlatformBrowser, Location } from '@angular/common';
+import { LIB_CONFIG, LibConfig } from '../../tokens/LibConfig';
+import { getSiteUrl } from '../../helpers/getSiteUrl.func';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LogService {
+  private libConfig = inject<LibConfig>(LIB_CONFIG);
+  private platformId = inject(PLATFORM_ID);
+  private location = inject(Location);
+
+  logMsg(msg: any, label?: string) {
+    label = label ? `${label} ` : '';
+    if (!isPlatformBrowser(this.platformId) || (isPlatformBrowser(this.platformId) && !this.libConfig?.production)) {
+      console.log(`${label}${msg}`);
+    }
+  }
+
+  logLoad(component?: string) {
+    this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, 'LOAD');
+  }
+
+  log404(component?: string) {
+    this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '404');
+  }
+
+  log500(component?: string) {
+    this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '500');
+  }
+
+  getPageURL() {
+    return `${getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix)}${this.location.path()}`;
+  }
+}

package/core/services/mapbox/mapbox.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { MapboxService } from './mapbox.service';
+
+describe('MapboxService', () => {
+  let service: MapboxService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(MapboxService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/core/services/mapbox/mapbox.service.ts

@@ -0,0 +1,84 @@
+import { Injectable, PLATFORM_ID, inject } from '@angular/core';
+import { isPlatformBrowser, isPlatformServer } from '@angular/common';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { LogService } from '../log/log.service';
+import { LIB_CONFIG, LibConfig } from '../../tokens/LibConfig';
+
+export interface MapBoxGeocodingParams {
+  autocomplete?: boolean;
+  bbox?: string; // minLon, minLat, maxLon, maxLat
+  country?: string; // country codes separated by commas
+  fuzzyMatch?: boolean;
+  language?: string;
+  limit?: number; // default: 5, max: 10
+  proximity?: string; // longitude, latitude
+  routing?: boolean;
+  // Types can be comma separated
+  types?: string; // "country" | "region" | "postcode" | "district" | "place" | "locality" | "neighborhood" | "address" | "poi"
+  [propName: string]: any;
+}
+
+export interface MapBoxReverseGeocodingParams {
+  country?: string; // country codes separated by commas
+  language?: string;
+  limit?: number; // default: 5, max: 10
+  reverseMode?: 'distance' | 'score';
+  routing?: boolean;
+  // Types can be comma separated
+  types?: string; // "country" | "region" | "postcode" | "district" | "place" | "locality" | "neighborhood" | "address" | "poi"
+  [propName: string]: any;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class MapBoxService {
+  private readonly http = inject(HttpClient);
+  private readonly logService = inject(LogService);
+  private libConfig = inject<LibConfig>(LIB_CONFIG);
+  private readonly platformId = inject(PLATFORM_ID);
+
+  private mapboxAccessToken = this.libConfig.mapboxAccessToken;
+  private mapboxSSRAccessToken = this.libConfig.mapboxSSRAccessToken;
+  private mapboxApiUrl = 'https://api.mapbox.com';
+  private geocodingEp = 'search/geocode/v6';
+
+  /**
+   * Busca geocalizada por nome do local.
+   * Ex.: barra da tijuca, rio de janeiro - rio de janeiro, brasil
+   * @param query nome de local para a busca
+   * @param params parâmetros opcionais de busca e filtro
+   */
+  forwardGeocoding(query: string, params: MapBoxGeocodingParams = {}, logContext?: string): Observable<any> {
+    this.logMapbox('forwardGeocoding', logContext);
+    if (query.length >= 256) {
+      return throwError(() => 'Query length exceeds 255 characters.');
+    }
+    const url = `${this.mapboxApiUrl}/${this.geocodingEp}/forward?q=${query}`;
+    params['access_token'] = isPlatformBrowser(this.platformId) ? this.mapboxAccessToken : this.mapboxSSRAccessToken;
+    return this.http.get(url, { params, headers: this.getHeaders() });
+  }
+
+  /**
+   * Busca local por longitude e latitude
+   * @param lng formato longitude
+   * @param lat formato latitude
+   * @param params parâmetros opcionais de busca e filtro
+   */
+  reverseGeocoding(lng: string, lat: string, params: MapBoxReverseGeocodingParams = {}, logContext?: string): Observable<any> {
+    this.logMapbox('reverseGeocoding', logContext);
+    const url = `${this.mapboxApiUrl}/${this.geocodingEp}/reverse?longitude=${lng}&latitude=${lat}`;
+    params['access_token'] = isPlatformBrowser(this.platformId) ? this.mapboxAccessToken : this.mapboxSSRAccessToken;
+    return this.http.get(url, { params });
+  }
+
+  private logMapbox(callerFunction: string, context = 'no-context') {
+    const platform = isPlatformServer(this.platformId) ? 'server' : 'browser';
+    this.logService.logMsg(`${platform} - ${callerFunction} - ${context}`, 'MAPBOX');
+  }
+
+  private getHeaders(): HttpHeaders {
+    return new HttpHeaders().set('Referrer-Policy', 'origin');
+  }
+}

package/core/services/modal/modal.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ModalService } from './modal.service';
+
+describe('ModalService', () => {
+  let service: ModalService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ModalService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/core/services/modal/modal.service.ts

@@ -0,0 +1,124 @@
+import { Injectable, signal, TemplateRef } from '@angular/core';
+import { RdsiteModalComponentStyle } from '../../enums/RdsiteModalComponentStyle.enum';
+import { executeWithRetry } from '../../helpers/executeWithRetry.func';
+
+export abstract class AbstractModalComponent {
+  abstract id?: string;
+  abstract modalTitle?: string | null;
+  abstract modalHeader?: TemplateRef<any> | null;
+  abstract modalContent: TemplateRef<any> | null;
+  abstract modalContentContext: Record<string, any> | null;
+  abstract modalActions?: TemplateRef<any> | null;
+  abstract componentStyle?: any;
+  abstract modal: HTMLDialogElement;
+  abstract open(): void;
+  abstract close(): void;
+  abstract reset?(): void;
+}
+
+@Injectable({
+  providedIn: 'root',
+})
+export class ModalService {
+  reference: AbstractModalComponent | null = null;
+  defaultPhoneModal!: TemplateRef<any>;
+
+  firstInteraction = signal(false);
+  maxTries = 10;
+  delay = 200;
+
+  open() {
+    this.firstInteraction.set(true);
+    executeWithRetry(
+      () => {
+        this.reference?.open();
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setReference(element: AbstractModalComponent) {
+    this.reference = element;
+  }
+
+  setHeader(header: TemplateRef<any>) {
+    executeWithRetry(
+      () => {
+        if (this.reference) {
+          this.reference.modalHeader = header;
+        }
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setTitle(title: string) {
+    executeWithRetry(
+      () => {
+        if (this.reference) {
+          this.reference.modalTitle = title;
+        }
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setContent(content: TemplateRef<any>, context: Record<string, any> = {}) {
+    executeWithRetry(
+      () => {
+        if (this.reference) {
+          this.reference.modalContent = content;
+          this.reference.modalContentContext = context;
+        }
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setActions(actions: TemplateRef<any>) {
+    executeWithRetry(
+      () => {
+        if (this.reference) {
+          this.reference.modalActions = actions;
+        }
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setStyle(style: RdsiteModalComponentStyle) {
+    executeWithRetry(
+      () => {
+        if (this.reference) {
+          this.reference.componentStyle = style;
+        }
+      },
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+
+  setDefaultPhoneModal(modal: TemplateRef<any>) {
+    this.defaultPhoneModal = modal;
+  }
+
+  close() {
+    executeWithRetry(
+      () => this.reference?.close(),
+      () => !!this.reference,
+      this.maxTries,
+      this.delay,
+    );
+  }
+}

package/core/services/modal-drawer/modal-drawer.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ModalDrawerService } from './modal-drawer.service';
+
+describe('ModalDrawerService', () => {
+  let service: ModalDrawerService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ModalDrawerService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});