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

package/core/interceptors/log.interceptor.ts

@@ -0,0 +1,35 @@
+import { inject, Injectable } from '@angular/core';
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse } from '@angular/common/http';
+import { Observable, tap } from 'rxjs';
+import { differenceInMilliseconds } from 'date-fns';
+import { v4 as uuidv4 } from 'uuid';
+import { LogService } from '../services/log/log.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LogInterceptor implements HttpInterceptor {
+  private logService = inject(LogService);
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const requestId = uuidv4();
+    const startTime = Date.now();
+    const queryParams = req.params.keys().length ? `?${req.params.toString()}` : '';
+    const requestUrl = `${req.url}${queryParams}`;
+
+    this.logService.logMsg(`REQUEST ${requestId} => ${req.method} ${requestUrl}`, 'INTERCEPTOR');
+
+    return next.handle(req).pipe(
+      tap((response) => {
+        const res = response as HttpResponse<any>;
+        if (res?.status) {
+          const elapsedTime = differenceInMilliseconds(Date.now(), startTime);
+          this.logService.logMsg(
+            `RESPONSE ${requestId} => ${req.method} ${requestUrl} | Duração: ${elapsedTime}ms | Status: ${res.status} - ${res.statusText} | Body: ${!!res.body}`,
+            'INTERCEPTOR',
+          );
+        }
+      }),
+    );
+  }
+}

package/core/interceptors/transfer-state-url.interceptor.ts

@@ -0,0 +1,137 @@
+import { inject, Injectable, PLATFORM_ID, TransferState, makeStateKey, StateKey } from '@angular/core';
+import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest, HttpResponse } from '@angular/common/http';
+import { Observable, tap, of } from 'rxjs';
+import { isPlatformServer, isPlatformBrowser } from '@angular/common';
+import { LIB_CONFIG } from '../tokens/LibConfig';
+import { djb2Hash } from '../helpers/djb2Hash.func';
+
+/**
+ * Cria uma chave numérica única para o cache
+ * Gera um hash baseado em método + URL + parâmetros
+ */
+function createCacheKey(req: HttpRequest<any>, url: string): string {
+  const method = req.method;
+  const params = req.params.toString();
+
+  // Combina método, URL e parâmetros
+  const keyString = [method, url, params].filter((part) => part.length > 0).join('::');
+
+  // Gera hash numérico único
+  const hashNumber = djb2Hash(keyString);
+
+  return hashNumber.toString();
+}
+
+/**
+ * Cria StateKey para o TransferState
+ */
+function getTransferStateKey(req: HttpRequest<any>, url: string): StateKey<any> {
+  const cacheKey = createCacheKey(req, url);
+  return makeStateKey<any>(cacheKey);
+}
+
+/**
+ * Interceptor para resolver o problema de TransferState com urls diferentes
+ *
+ * Problema: O SiteBackendService usa urls diferentes no server (baseInternal) e no client (base), fazendo com que o TransferState nativo do Angular não funcione corretamente.
+ *
+ * Solução:
+ * - Server: Usa url interna, mas salva no TransferState baseado na url externa
+ * - Client: Verifica TransferState usando url externa antes de fazer alguma requisição
+ *
+ * Dessa forma é possivel fazer o uso do TransferState mesmo com urls diferentes ("baseInternal" no server e "base" no client).
+ */
+@Injectable({
+  providedIn: 'root',
+})
+export class TransferStateUrlInterceptor implements HttpInterceptor {
+  private platformId = inject(PLATFORM_ID);
+  private transferState = inject(TransferState);
+  private libConfig = inject(LIB_CONFIG);
+
+  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    if (isPlatformServer(this.platformId)) {
+      return this.handleServerRequest(req, next);
+    } else if (isPlatformBrowser(this.platformId)) {
+      return this.handleClientRequest(req, next);
+    }
+
+    return next.handle(req);
+  }
+
+  /**
+   * Filtra headers da resposta baseado na configuração no LibConfig
+   */
+  private filterHeaders(responseHeaders: any): Record<string, string> {
+    const includeHeaders = this.libConfig.transferState?.includeHeaders;
+
+    if (!includeHeaders || includeHeaders.length === 0) {
+      return {};
+    }
+
+    // Filtra apenas os headers configurados
+    const filteredHeaders: Record<string, string> = {};
+    includeHeaders.forEach((headerName) => {
+      const headerValue = responseHeaders.get(headerName.toLowerCase());
+      if (headerValue) {
+        filteredHeaders[headerName.toLowerCase()] = headerValue;
+      }
+    });
+
+    return filteredHeaders;
+  }
+
+  private handleServerRequest(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const siteApi = this.libConfig.siteApi;
+
+    // Para urls internas
+    if (req.url.startsWith(siteApi.baseInternal)) {
+      const externalUrl = req.url.replace(siteApi.baseInternal, siteApi.base);
+      const stateKey = getTransferStateKey(req, externalUrl);
+
+      return next.handle(req).pipe(
+        tap((event) => {
+          if (event instanceof HttpResponse) {
+            const filteredHeaders = this.filterHeaders(event.headers);
+
+            // Salva no TransferState baseado na url externa
+            this.transferState.set(stateKey, {
+              body: event.body,
+              status: event.status,
+              statusText: event.statusText,
+              headers: filteredHeaders,
+            });
+          }
+        }),
+      );
+    }
+
+    return next.handle(req);
+  }
+
+  private handleClientRequest(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    const siteApi = this.libConfig.siteApi;
+
+    // Para urls externas
+    if (req.url.startsWith(siteApi.base)) {
+      const stateKey = getTransferStateKey(req, req.url);
+      const cachedResponse = this.transferState.get(stateKey, null);
+
+      if (cachedResponse) {
+        this.transferState.remove(stateKey);
+
+        // Retorna resposta do TransferState
+        return of(
+          new HttpResponse({
+            body: cachedResponse.body,
+            status: cachedResponse.status,
+            statusText: cachedResponse.statusText,
+            headers: cachedResponse.headers,
+          }),
+        );
+      }
+    }
+
+    return next.handle(req);
+  }
+}

package/core/models/algolia-search-api.model.ts

@@ -0,0 +1,213 @@
+export interface AlgoliaResult<T> {
+  exhaustiveNbHits: boolean;
+  exhaustiveTypo: boolean;
+  hits: T[];
+  hitsPerPage: number;
+  indexUsed: string;
+  nbHits: number;
+  nbPages: number;
+  page: number;
+  params: string;
+  parsedQuery: string;
+  processingTimeMS: number;
+  query: string;
+  renderingContent: any;
+}
+
+export interface AlgoliaMultipleResults {
+  results: AlgoliaResult<any>[];
+}
+
+export interface RdslAlgoliaMultipleIndex {
+  indexName: string;
+  params?: RdslAlgoliaSearchParams;
+  query?: string;
+}
+
+export interface RdslAlgoliaSearchParams {
+  // Search
+  query?: string;
+  similarQuery?: string;
+  // Attributes
+  attributesToRetrieve?: string[];
+  restrictSearchableAttributes?: string[];
+  // Filtering
+  filters?: string;
+  facetFilters?: any[];
+  optionalFilters?: any[];
+  numericFilters?: string[];
+  tagFilters?: any[];
+  sumOrFiltersScores?: boolean;
+  // Faceting
+  facets?: string[];
+  maxValuesPerFacet?: number;
+  facetingAfterDistinct?: boolean;
+  sortFacetValuesBy?: 'count' | 'alpha';
+  // Highlighting-snippeting
+  attributesToHighlight?: string[];
+  attributesToSnippet?: string[];
+  highlightPreTag?: string;
+  highlightPostTag?: string;
+  snippetEllipsisText?: string;
+  restrictHighlightAndSnippetArrays?: boolean;
+  // Pagination
+  page?: number;
+  hitsPerPage?: number;
+  offset?: number;
+  length?: number;
+  // Typos
+  minWordSizefor1Typo?: number;
+  minWordSizefor2Typos?: number;
+  typoTolerance?: boolean | 'min' | 'strict';
+  allowTyposOnNumericTokens?: boolean;
+  disableTypoToleranceOnAttributes?: string[];
+  // Geo-search
+  aroundLatLng?: string;
+  aroundLatLngViaIP?: boolean;
+  aroundRadius?: number | 'all';
+  aroundPrecision?: number | any[];
+  minimumAroundRadius?: number;
+  insideBoundingBox?: any[];
+  insidePolygon?: any[];
+  // Languages
+  ignorePlurals?: boolean | string[];
+  removeStopWords?: boolean | string[];
+  queryLanguages?: string[];
+  naturalLanguages?: string[];
+  // Rules
+  enableRules?: boolean;
+  ruleContexts?: string[];
+  // Personalization
+  enablePersonalization?: boolean;
+  personalizationImpact?: number;
+  userToken?: string;
+  // Query-strategy
+  queryType?: 'prefixLast' | 'prefixAll' | 'prefixNone';
+  removeWordsIfNoResults?: 'none' | 'lastWords' | 'firstWords' | 'allOptional';
+  advancedSyntax?: boolean;
+  optionalWords?: string[];
+  disableExactOnAttributes?: string[];
+  exactOnSingleWordQuery?: 'attribute' | 'none' | 'word';
+  alternativesAsExact?: string[];
+  advancedSyntaxFeatures?: string[];
+  // Advanced
+  distinct?: 0 | 1 | 2 | 3;
+  getRankingInfo?: boolean;
+  clickAnalytics?: boolean;
+  analytics?: boolean;
+  analyticsTags?: string[];
+  synonyms?: boolean;
+  replaceSynonymsInHighlight?: boolean;
+  minProximity?: number;
+  responseFields?: string[];
+  maxFacetHits?: number;
+  percentileComputation?: boolean;
+  attributeCriteriaComputedByMinProximity?: boolean;
+  enableABTest?: boolean;
+  // Custom headers
+  [propName: string]: any;
+}
+
+export interface AlgoliaSearchParams {
+  // Search
+  query?: string;
+  similarQuery?: string;
+  // Attributes
+  attributesToRetrieve?: string[];
+  restrictSearchableAttributes?: string[];
+  // Filtering
+  filters?: string;
+  facetFilters?: string[];
+  optionalFilters?: any[];
+  numericFilters?: string[];
+  tagFilters?: any[];
+  sumOrFiltersScores?: boolean;
+  // Faceting
+  facets?: string[];
+  maxValuesPerFacet?: number;
+  facetingAfterDistinct?: boolean;
+  sortFacetValuesBy?: 'count' | 'alpha';
+  // Highlighting-snippeting
+  attributesToHighlight?: string[];
+  attributesToSnippet?: string[];
+  highlightPreTag?: string;
+  highlightPostTag?: string;
+  snippetEllipsisText?: string;
+  restrictHighlightAndSnippetArrays?: boolean;
+  // Pagination
+  page?: number;
+  hitsPerPage?: number;
+  offset?: number;
+  length?: number;
+  // Typos
+  minWordSizefor1Typo?: number;
+  minWordSizefor2Typos?: number;
+  typoTolerance?: boolean | 'min' | 'strict';
+  allowTyposOnNumericTokens?: boolean;
+  disableTypoToleranceOnAttributes?: string[];
+  // Geo-search
+  aroundLatLng?: string;
+  aroundLatLngViaIP?: boolean;
+  aroundRadius?: number | string;
+  aroundPrecision?: number | any[];
+  minimumAroundRadius?: number;
+  insideBoundingBox?: any[];
+  insidePolygon?: any[];
+  // Languages
+  ignorePlurals?: boolean | string[];
+  removeStopWords?: boolean | string[];
+  queryLanguages?: string[];
+  naturalLanguages?: string[];
+  // Rules
+  enableRules?: boolean;
+  ruleContexts?: string[];
+  // Personalization
+  enablePersonalization?: boolean;
+  personalizationImpact?: number;
+  userToken?: string;
+  // Query-strategy
+  queryType?: 'prefixLast' | 'prefixAll' | 'prefixNone';
+  removeWordsIfNoResults?: 'none' | 'lastWords' | 'firstWords' | 'allOptional';
+  advancedSyntax?: boolean;
+  optionalWords?: string[];
+  disableExactOnAttributes?: string[];
+  exactOnSingleWordQuery?: 'attribute' | 'none' | 'word';
+  alternativesAsExact?: string[];
+  advancedSyntaxFeatures?: string[];
+  // Advanced
+  distinct?: 0 | 1 | 2 | 3;
+  getRankingInfo?: boolean;
+  clickAnalytics?: boolean;
+  analytics?: boolean;
+  analyticsTags?: string[];
+  synonyms?: boolean;
+  replaceSynonymsInHighlight?: boolean;
+  minProximity?: number;
+  responseFields?: string[];
+  maxFacetHits?: number;
+  percentileComputation?: boolean;
+  attributeCriteriaComputedByMinProximity?: boolean;
+  enableABTest?: boolean;
+  // Custom headers
+  [propName: string]: any;
+}
+
+export interface AlgoliaConfig {
+  id: string;
+  key: string;
+  index?: string;
+  multipleIndex?: RdslAlgoliaMultipleIndex[];
+}
+
+export interface AlgoliaOption {
+  hit?: any;
+  value: string;
+  subtitle?: string | null;
+  icon?: string | null;
+  imageSrc?: string | null;
+  distance?: string | null;
+  avatar?: boolean;
+  deleteButton?: false;
+  type: string;
+  title: boolean;
+}

package/core/models/breadcrumbs/breadcrumbs-items.model.ts

@@ -0,0 +1,10 @@
+export interface BreadcrumbsItems {
+  label: string;
+  url?: string[];
+  helper?: string;
+  groupName?: string;
+  icon?: string;
+  iconColor?: string;
+  iconSize?: number;
+  iconDisabled?: boolean;
+}

package/core/models/breadcrumbs/breadcrumbs-json-item.model.ts

@@ -0,0 +1,8 @@
+export interface BreadcrumbsJsonItem {
+  '@type': 'ListItem';
+  position: number;
+  item: {
+    '@id': string;
+    name: string;
+  };
+}

package/core/models/centro-estudos-backend.model.ts

@@ -0,0 +1,8 @@
+export interface CentroEstudosBackendMedico {
+  nome: string;
+  email: string;
+  telefone: string;
+  conselhoTipo: string;
+  conselhoCodigo: string;
+  especialidade: string;
+}

package/core/models/centro-medico.model.ts

@@ -0,0 +1,33 @@
+export interface CentroMedico {
+  titulo: string;
+  slug: string;
+  logo: {
+    url: string;
+    alt: string;
+    title: string;
+  };
+  idqd: string;
+  idMotion: string;
+  unidadeSlug: string;
+  facilidades: string[];
+  especialidades: {
+    nome: string;
+    slug: string;
+  }[];
+  exames: {
+    nome: string;
+    slug: string;
+  }[];
+  localizacao: {
+    estado: {
+      nome: string;
+      sigla: string;
+    };
+    cidade: string;
+    logradouro: string;
+    bairro: string;
+    numero: string;
+    cep: string;
+    rota: string;
+  };
+}

package/core/models/content-banner.model.ts

@@ -0,0 +1,7 @@
+export interface ContentBanner {
+  image: any;
+  title: string;
+  text: string;
+  info: { icon: string; text: string; link: string }[];
+  cta: { icon: string; text: string; link: string };
+}

package/core/models/cta-wrapper.model.ts

@@ -0,0 +1,9 @@
+export interface CtaWrapper {
+  title?: string;
+  text?: string;
+  ctas?: {
+    label: string;
+    link: string;
+    icon: string;
+  }[];
+}

package/core/models/doenca-backend.model.ts

@@ -0,0 +1,27 @@
+import { DoencaTaxonomy } from './doenca-taxonomy.model';
+import { WpPage } from './wordpress/page/page.model';
+
+export interface WpDoenca extends WpPage {
+  parent_slug?: string;
+  parent_title?: string;
+  acf: {
+    doenca_subtitulo: string;
+    doenca_icone: string;
+    doenca_imagem: any;
+    doenca_especialidades: any[];
+  };
+  doencas_cat: DoencaTaxonomy[];
+  doencas_tag: DoencaTaxonomy[];
+}
+
+export interface DoencaBackend {
+  slug: string;
+  title: string;
+  content: string;
+  imagem: {
+    default: any;
+    webp: any;
+  };
+  doencas_cat: DoencaTaxonomy[];
+  doencas_tag: DoencaTaxonomy[];
+}

package/core/models/doenca-taxonomy.model.ts

@@ -0,0 +1,21 @@
+export enum EnumDoencaTaxonomy {
+  DOENCAS_CAT = 'doencas_cat',
+  DOENCAS_TAG = 'doencas_tag',
+}
+
+export enum EnumDoencaTaxonomyCat {
+  DOENCA = 'doencas',
+  SINTOMA = 'sintomas',
+}
+
+export interface DoencaTaxonomy {
+  id: number;
+  name: string;
+  slug: string;
+  taxonomy: EnumDoencaTaxonomy;
+}
+
+export interface TaxonomiasDoencasList {
+  doencas_cat: DoencaTaxonomy[];
+  doencas_tag: DoencaTaxonomy[];
+}

package/core/models/especialidade-backend.model.ts

@@ -0,0 +1,25 @@
+export interface EspecialidadeBackend {
+  agendamentoOnline?: boolean;
+  agendamentoOnlineUrl: string;
+  content: boolean;
+  especialistaComplemento: string;
+  especialistaDescricao: string;
+  id: number;
+  idmotion: string;
+  idrdsl: string;
+  parent: number;
+  slug: string;
+  titulo: string;
+  parent_slug: string;
+  parent_title: string;
+}
+
+export interface EspecialidadeGrupoBackend extends EspecialidadeBackend {
+  id: number;
+  idmotion: string;
+  idrdsl: string;
+  parent: number;
+  slug: string;
+  titulo: string;
+  children: EspecialidadeBackend[];
+}

package/core/models/exame-backend.model.ts

@@ -0,0 +1,26 @@
+export interface ExameBackend {
+  id: number;
+  slug: string;
+  titulo: string;
+  idrdsl?: number | string;
+  idmotion?: number | string;
+  content?: boolean;
+  parent: number;
+  parentSlug?: string;
+  parentTitulo?: string;
+  possuiAgendamento?: string; // "N"|"S"|"M"
+  agendamentoOnlineUrl?: string;
+  cta?: string;
+  children?: Array<ExameBackend>;
+  [prop: string]: any;
+}
+
+export interface ExameApiDados {
+  ID_DQ_EXAME: string;
+  CODIGO_EXAME_MOTION: string;
+  DESCRICAO_EXAME: string;
+  FLAG_POSSUI_AGENDAMENTO_ONLINE: string;
+  SINONIMIAS_EXAME: string;
+  ID_DQ_CATEG_EXAME: string;
+  DESCRICAO_CATEG_EXAME: string;
+}

package/core/models/filters/filter-planos-convenios.model.ts

@@ -0,0 +1,34 @@
+import { FilterAction } from './filter-section.type';
+
+export interface FilterPlanosConvenios {
+  label: string;
+  value: string;
+}
+
+export interface FilterPlanosConveniosCobertura extends FilterPlanosConvenios {
+  checked: boolean;
+}
+
+export interface FilterPlanosConveniosChange {
+  unidade: string | number | null;
+  estado: string | number | null;
+  cobertura: FilterPlanosConveniosCobertura[];
+}
+
+export interface FilterOption {
+  label: string;
+  value: string;
+  checked?: boolean;
+  disabled?: boolean;
+}
+
+export interface FilterEvent<T = any> {
+  data: T | null;
+  action: FilterAction;
+}
+
+export interface FilterSectionBase<T extends string, C> {
+  type: T;
+  config: C;
+  visible?: boolean;
+}

package/core/models/filters/filter-section.type.ts

@@ -0,0 +1,18 @@
+import { FormControl } from '@angular/forms';
+import { InputFilterSection } from './filter-sections.model';
+import { SelectFilterSection } from './filter-sections.model';
+import { CheckboxGroupFilterSection } from './filter-sections.model';
+import { RadioGroupFilterSection } from './filter-sections.model';
+import { CustomFilterSection } from './filter-sections.model';
+
+export interface RadioGroupValue {
+  value: any;
+}
+
+export type FilterSection = InputFilterSection | SelectFilterSection | CheckboxGroupFilterSection | RadioGroupFilterSection | CustomFilterSection;
+
+export type FilterControl = FormControl<FilterControlValue>;
+
+export type FilterAction = 'filter' | 'reset';
+
+export type FilterControlValue = string | number | boolean | any[] | RadioGroupValue | null;

package/core/models/filters/filter-sections.model.ts

@@ -0,0 +1,66 @@
+import { TemplateRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { FilterOption, FilterSectionBase } from './filter-planos-convenios.model';
+import { FilterControl } from './filter-section.type';
+
+export enum FilterType {
+  INPUT = 'input',
+  SELECT = 'select',
+  CHECKBOX_GROUP = 'checkbox-group',
+  RADIO_GROUP = 'radio-group',
+  CUSTOM = 'custom',
+}
+
+// Input
+export interface InputFilterConfig {
+  name: string;
+  placeholder?: string;
+  iconName?: string;
+  control: FilterControl;
+  options?: FilterOption[];
+}
+
+// Select
+export interface SelectFilterConfig {
+  name: string;
+  label?: string;
+  placeholder?: string;
+  includeDefaultOption?: boolean;
+  defaultOptionText?: string;
+  control: FilterControl;
+  options?: FilterOption[];
+}
+
+// Checkbox Group
+export interface CheckboxGroupFilterConfig {
+  name: string;
+  title?: string;
+  subtitle?: string;
+  description?: string;
+  control: FormControl<any[]>;
+  options: FilterOption[];
+}
+
+// Radio Group
+export interface RadioGroupFilterConfig {
+  name: string;
+  title?: string;
+  control: FilterControl;
+  options: FilterOption[];
+}
+
+// Custom
+export interface CustomFilterConfig {
+  template: TemplateRef<any>;
+  control?: any;
+  context?: any;
+  options?: FilterOption[];
+  count?: number;
+}
+
+// Interfaces completas por tipo
+export interface InputFilterSection extends FilterSectionBase<FilterType.INPUT, InputFilterConfig> {}
+export interface SelectFilterSection extends FilterSectionBase<FilterType.SELECT, SelectFilterConfig> {}
+export interface CheckboxGroupFilterSection extends FilterSectionBase<FilterType.CHECKBOX_GROUP, CheckboxGroupFilterConfig> {}
+export interface RadioGroupFilterSection extends FilterSectionBase<FilterType.RADIO_GROUP, RadioGroupFilterConfig> {}
+export interface CustomFilterSection extends FilterSectionBase<FilterType.CUSTOM, CustomFilterConfig> {}