@controleonline/ui-common 1.2.70

package/src/react/utils/menuCatalogDownload.js

@@ -0,0 +1,157 @@
+import {Platform} from 'react-native';
+import {env} from '@env';
+import {File, Paths} from 'expo-file-system';
+import * as Sharing from 'expo-sharing';
+
+import {api} from '@controleonline/ui-common/src/api';
+import {resolveAppDomain} from '@controleonline/ui-common/src/utils/appDomain';
+import {
+  normalizeModelReference,
+} from '@controleonline/ui-common/src/react/utils/menuCatalogConfig';
+
+const normalizeId = value => String(value || '').replace(/\D+/g, '').trim();
+
+const slugifyFileName = value => {
+  const normalized = String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+  return normalized || 'catalogo';
+};
+
+const extractFilenameFromDisposition = value => {
+  const utf8Match = String(value || '').match(/filename\*=UTF-8''([^;]+)/i);
+  if (utf8Match?.[1]) {
+    return decodeURIComponent(utf8Match[1]).trim();
+  }
+
+  const fallbackMatch = String(value || '').match(/filename="?([^";]+)"?/i);
+  return fallbackMatch?.[1]?.trim() || null;
+};
+
+const extractDownloadErrorMessage = async response => {
+  const fallback = 'Nao foi possivel baixar o cardapio.';
+
+  try {
+    const payload = await response.text();
+    if (!payload) {
+      return fallback;
+    }
+
+    try {
+      const parsed = JSON.parse(payload);
+      return parsed?.error || parsed?.description || parsed?.message || fallback;
+    } catch (error) {
+      return payload;
+    }
+  } catch (error) {
+    return fallback;
+  }
+};
+
+const buildDownloadUrl = ({apiEntrypoint, companyId, modelReference}) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set('company', String(companyId));
+
+  const normalizedModelReference = normalizeModelReference(modelReference);
+  if (normalizedModelReference) {
+    searchParams.set('model', normalizedModelReference);
+  }
+
+  return `${apiEntrypoint}/products/menu/download?${searchParams.toString()}`;
+};
+
+export const downloadMenuCatalog = async ({
+  companyId,
+  companyName,
+  modelReference,
+} = {}) => {
+  const normalizedCompanyId = normalizeId(companyId);
+  if (!normalizedCompanyId) {
+    throw new Error('Empresa nao selecionada.');
+  }
+
+  const apiEntrypoint = String(env.API_ENTRYPOINT || '').replace(/\/$/, '');
+  if (!apiEntrypoint) {
+    throw new Error('API_ENTRYPOINT nao configurado.');
+  }
+
+  const baseFileName = `cardapio-${slugifyFileName(
+    companyName || normalizedCompanyId,
+  )}.pdf`;
+
+  const headers = {
+    Accept: 'application/pdf',
+    'App-Domain': resolveAppDomain(env.DOMAIN),
+  };
+
+  const token = await api.getToken();
+  if (token) {
+    headers['API-TOKEN'] = token;
+  }
+
+  const response = await fetch(
+    buildDownloadUrl({
+      apiEntrypoint,
+      companyId: normalizedCompanyId,
+      modelReference,
+    }),
+    {
+      method: 'GET',
+      headers,
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error(await extractDownloadErrorMessage(response));
+  }
+
+  const fileName =
+    extractFilenameFromDisposition(response.headers.get('content-disposition')) ||
+    baseFileName;
+  const blob = await response.blob();
+
+  if (Platform.OS === 'web') {
+    const objectUrl = URL.createObjectURL(blob);
+    const anchor = document.createElement('a');
+    anchor.href = objectUrl;
+    anchor.download = fileName;
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    window.setTimeout(() => URL.revokeObjectURL(objectUrl), 1000);
+
+    return {
+      fileName,
+      shared: false,
+      savedUri: null,
+    };
+  }
+
+  const file = new File(Paths.cache, fileName);
+  file.create({intermediates: true, overwrite: true});
+  file.write(new Uint8Array(await blob.arrayBuffer()));
+
+  if (await Sharing.isAvailableAsync()) {
+    await Sharing.shareAsync(file.uri, {
+      mimeType: 'application/pdf',
+      dialogTitle: 'Compartilhar cardapio',
+    });
+
+    return {
+      fileName,
+      shared: true,
+      savedUri: file.uri,
+    };
+  }
+
+  return {
+    fileName,
+    shared: false,
+    savedUri: file.uri,
+  };
+};
+// TODO(store-first): quando este arquivo for mexido, mover a leitura para stores e evitar chamadas HTTP diretas quando o store ja resolver isso.

package/src/react/utils/networkCameraDevices.js

@@ -0,0 +1,175 @@
+import {
+  normalizePrinterHost,
+  normalizePrinterPort,
+} from '@controleonline/ui-common/src/react/utils/printerDevices';
+import {normalizeDeviceId} from '@controleonline/ui-common/src/react/utils/paymentDevices';
+
+export const NETWORK_CAMERA_MANAGER_DEVICE_CONFIG_KEY =
+  'camera-network-manager-device';
+export const NETWORK_CAMERA_PORT_CONFIG_KEY = 'camera-network-port';
+export const NETWORK_CAMERA_PROTOCOL_CONFIG_KEY = 'camera-network-protocol';
+export const NETWORK_CAMERA_STREAM_PATH_CONFIG_KEY =
+  'camera-network-stream-path';
+export const NETWORK_CAMERA_USERNAME_CONFIG_KEY = 'camera-network-username';
+export const NETWORK_CAMERA_PASSWORD_CONFIG_KEY = 'camera-network-password';
+
+export const DEFAULT_NETWORK_CAMERA_PORT = '554';
+export const DEFAULT_NETWORK_CAMERA_PROTOCOL = 'rtsp';
+export const DEFAULT_NETWORK_CAMERA_MANUFACTURER = 'Hikvision';
+export const DEFAULT_NETWORK_CAMERA_MODEL = 'DS-2CD1123G0E-I';
+export const NETWORK_CAMERA_PROTOCOL_OPTIONS = [
+  {value: 'rtsp', label: 'RTSP'},
+  {value: 'onvif', label: 'ONVIF'},
+  {value: 'http', label: 'HTTP'},
+  {value: 'https', label: 'HTTPS'},
+];
+
+const safeTrim = value => String(value || '').trim();
+
+const parseMetadataObject = metadata => {
+  if (!metadata) {
+    return {};
+  }
+
+  if (typeof metadata === 'string') {
+    try {
+      const parsed = JSON.parse(metadata);
+      return parsed && typeof parsed === 'object' ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+
+  return typeof metadata === 'object' ? {...metadata} : {};
+};
+
+export const normalizeCameraProtocol = value =>
+  NETWORK_CAMERA_PROTOCOL_OPTIONS.find(
+    option => option.value === safeTrim(value).toLowerCase(),
+  )?.value || DEFAULT_NETWORK_CAMERA_PROTOCOL;
+
+export const normalizeCameraStreamPath = value => safeTrim(value);
+export const normalizeCameraCredential = value => safeTrim(value);
+
+export const getCameraMetadata = metadata => parseMetadataObject(metadata);
+
+export const getCameraMetadataField = (metadata, field) => {
+  const parsedMetadata = getCameraMetadata(metadata);
+  const cameraField = safeTrim(parsedMetadata?.camera?.[field]);
+  if (cameraField) {
+    return cameraField;
+  }
+
+  if (field === 'manufacturer') {
+    return safeTrim(parsedMetadata?.system?.manufacturer);
+  }
+
+  if (field === 'model') {
+    return safeTrim(parsedMetadata?.system?.model);
+  }
+
+  if (field === 'version') {
+    return safeTrim(parsedMetadata?.system?.version);
+  }
+
+  return '';
+};
+
+export const buildNetworkCameraMetadata = ({
+  existingMetadata = {},
+  host,
+  manufacturer,
+  model,
+  version,
+}) => {
+  const parsedMetadata = getCameraMetadata(existingMetadata);
+  const normalizedManufacturer =
+    safeTrim(manufacturer) ||
+    getCameraMetadataField(parsedMetadata, 'manufacturer') ||
+    null;
+  const normalizedModel =
+    safeTrim(model) || getCameraMetadataField(parsedMetadata, 'model') || null;
+  const normalizedVersion =
+    safeTrim(version) ||
+    getCameraMetadataField(parsedMetadata, 'version') ||
+    null;
+  const normalizedHost =
+    normalizePrinterHost(host) || safeTrim(parsedMetadata?.camera?.host) || null;
+
+  return {
+    ...parsedMetadata,
+    runtime: safeTrim(parsedMetadata?.runtime) || 'network',
+    camera: {
+      ...(parsedMetadata?.camera || {}),
+      host: normalizedHost,
+      manufacturer: normalizedManufacturer,
+      model: normalizedModel,
+      version: normalizedVersion,
+    },
+    system: {
+      ...(parsedMetadata?.system || {}),
+      name: safeTrim(parsedMetadata?.system?.name) || 'network-camera',
+      version: normalizedVersion,
+      manufacturer: normalizedManufacturer,
+      model: normalizedModel,
+      hardwareType: 'camera',
+    },
+  };
+};
+
+export const getNetworkCameraConfigValues = configs => ({
+  managerDeviceId: normalizeDeviceId(
+    configs?.[NETWORK_CAMERA_MANAGER_DEVICE_CONFIG_KEY],
+  ),
+  port: normalizePrinterPort(
+    configs?.[NETWORK_CAMERA_PORT_CONFIG_KEY] || DEFAULT_NETWORK_CAMERA_PORT,
+  ),
+  protocol: normalizeCameraProtocol(
+    configs?.[NETWORK_CAMERA_PROTOCOL_CONFIG_KEY] || DEFAULT_NETWORK_CAMERA_PROTOCOL,
+  ),
+  streamPath: normalizeCameraStreamPath(
+    configs?.[NETWORK_CAMERA_STREAM_PATH_CONFIG_KEY],
+  ),
+  username: normalizeCameraCredential(
+    configs?.[NETWORK_CAMERA_USERNAME_CONFIG_KEY],
+  ),
+  password: normalizeCameraCredential(
+    configs?.[NETWORK_CAMERA_PASSWORD_CONFIG_KEY],
+  ),
+});
+
+export const buildNetworkCameraConfigs = ({
+  managerDeviceId,
+  port,
+  protocol,
+  streamPath,
+  username,
+  password,
+}) => {
+  const normalizedManagerDeviceId = normalizeDeviceId(managerDeviceId);
+  const normalizedPort = normalizePrinterPort(port || DEFAULT_NETWORK_CAMERA_PORT);
+  const normalizedProtocol = normalizeCameraProtocol(protocol);
+  const normalizedStreamPath = normalizeCameraStreamPath(streamPath);
+  const normalizedUsername = normalizeCameraCredential(username);
+  const normalizedPassword = normalizeCameraCredential(password);
+
+  const nextConfigs = {
+    [NETWORK_CAMERA_MANAGER_DEVICE_CONFIG_KEY]: normalizedManagerDeviceId,
+    [NETWORK_CAMERA_PORT_CONFIG_KEY]: normalizedPort,
+    [NETWORK_CAMERA_PROTOCOL_CONFIG_KEY]: normalizedProtocol,
+  };
+
+  if (normalizedStreamPath) {
+    nextConfigs[NETWORK_CAMERA_STREAM_PATH_CONFIG_KEY] = normalizedStreamPath;
+  }
+
+  if (normalizedUsername) {
+    nextConfigs[NETWORK_CAMERA_USERNAME_CONFIG_KEY] = normalizedUsername;
+  }
+
+  if (normalizedPassword) {
+    nextConfigs[NETWORK_CAMERA_PASSWORD_CONFIG_KEY] = normalizedPassword;
+  }
+
+  return nextConfigs;
+};

package/src/react/utils/networkDeviceProfiles.js

@@ -0,0 +1,135 @@
+import {
+  IP_CAMERA_DEVICE_TYPE,
+  PRINT_DEVICE_TYPE,
+  PRINTER_DEVICE_TYPE,
+  normalizeDeviceType,
+} from '@controleonline/ui-common/src/react/utils/printerDevices';
+
+const printerProfile = {
+  filterKey: 'PRINTERS',
+  filterLabel: 'Impressoras',
+  itemLabel: 'Impressora',
+  icon: 'printer',
+  formRouteName: 'PrinterDeviceForm',
+  detailRouteName: 'PrinterDeviceDetail',
+  formHeaderTitle: 'Nova Impressora de Rede',
+  detailHeaderTitle: 'Impressora de Rede',
+  createActionLabel: 'Nova impressora de rede',
+  createHelperText:
+    'Cadastre impressoras por IP/hostname e vincule o device local que vai gerenciar a impressao na rede.',
+  emptyTitle: 'Nenhuma impressora encontrada',
+  emptyDescription:
+    'Cadastre uma impressora de rede para visualizar devices deste tipo.',
+  heroTitle: 'Nova impressora de rede',
+  heroText:
+    'Cadastre a impressora pelo IP/hostname e vincule qual device local vai executar a impressao na rede.',
+  aliasPlaceholder: 'Ex.: Impressora Caixa 1',
+  detailHeroFallback: 'Impressora de rede',
+  detailLoadingText: 'Atualizando dados da impressora...',
+  companyMissingMessage:
+    'Selecione uma empresa antes de cadastrar a impressora.',
+  hostAlertTitle: 'IP da impressora',
+  hostMissingMessage: 'Informe o IP ou hostname da impressora.',
+  managerMissingMessage:
+    'Selecione o PDV ou DISPLAY responsável por receber e encaminhar as impressões.',
+  registerErrorMessage: 'Não foi possível cadastrar a impressora.',
+  registerErrorTitle: 'Erro ao cadastrar impressora',
+  managerSectionDescription:
+    'Este PDV ou DISPLAY será o gateway local que acompanha as impressões desta impressora de rede.',
+  createButtonLabel: 'Cadastrar impressora',
+  statusSectionDescription:
+    'O app tenta abrir uma conexão TCP direta com a impressora IP para indicar se ela está acessível na rede deste device.',
+  registrationSectionTitle: 'Cadastro da impressora',
+  detailAliasPlaceholder: 'Nome da impressora',
+  registrationAlertTitle: 'Cadastro da impressora',
+  routingSectionTitle: 'Roteamento de impressão',
+  routingSectionDescription:
+    'O backend continua gerando a impressão para o device da impressora. Aqui você define qual PDV ou DISPLAY local fica responsável por consumir essa fila e falar com a impressora na rede.',
+  routingAlertTitle: 'Configuração da impressora',
+  hostMissingBeforeSaveMessage:
+    'Informe o IP ou hostname da impressora antes de salvar.',
+  managerRoutingMessage:
+    'Selecione qual PDV ou DISPLAY executa a impressão desta impressora.',
+  saveBeforeRoutingMessage:
+    'Salve primeiro o cadastro da impressora para aplicar o novo IP antes do roteamento.',
+  footerDebugDescription:
+    'Controla se esta impressora mostra apenas a bolinha discreta do socket no rodape global ou se abre as linhas detalhadas de debug.',
+  removeSectionTitle: 'Remover cadastro de rede',
+  removeSectionDescription:
+    'Use esta acao para excluir apenas o cadastro desta impressora na rede. O equipamento responsavel pela comunicacao continua salvo no sistema.',
+  removeButtonLabel: 'Remover cadastro de rede',
+  removeConfirmTitle: 'Remover impressora da rede',
+  removeConfirmMessage:
+    'Deseja remover o cadastro desta impressora na rede? O equipamento responsavel continuara salvo no sistema.',
+  removeSuccessMessage: 'Cadastro da impressora na rede removido com sucesso.',
+  removeErrorMessage: 'Nao foi possivel remover o cadastro da impressora na rede.',
+};
+
+const ipCameraProfile = {
+  filterKey: IP_CAMERA_DEVICE_TYPE,
+  filterLabel: 'Cameras IP',
+  itemLabel: 'Camera IP',
+  icon: 'camera',
+  formRouteName: 'IpCameraForm',
+  detailRouteName: 'IpCameraDetail',
+  formHeaderTitle: 'Nova Camera IP',
+  detailHeaderTitle: 'Camera IP',
+  createActionLabel: 'Nova camera IP',
+  createHelperText:
+    'Cadastre cameras IP por IP/hostname e vincule o device local que vai acompanhar a comunicacao na rede.',
+  emptyTitle: 'Nenhuma camera IP encontrada',
+  emptyDescription:
+    'Cadastre uma camera IP para visualizar devices deste tipo.',
+  heroTitle: 'Nova camera IP',
+  heroText:
+    'Cadastre a camera pelo IP/hostname e vincule qual device local vai acompanhar a comunicacao na rede.',
+  aliasPlaceholder: 'Ex.: Camera Corredor 1',
+  detailHeroFallback: 'Camera IP',
+  detailLoadingText: 'Atualizando dados da camera IP...',
+  companyMissingMessage:
+    'Selecione uma empresa antes de cadastrar a camera IP.',
+  hostAlertTitle: 'IP da camera',
+  hostMissingMessage: 'Informe o IP ou hostname da camera IP.',
+  managerMissingMessage:
+    'Selecione o PDV ou DISPLAY responsavel por acompanhar esta camera IP.',
+  registerErrorMessage: 'Nao foi possivel cadastrar a camera IP.',
+  registerErrorTitle: 'Erro ao cadastrar camera IP',
+  managerSectionDescription:
+    'Este PDV ou DISPLAY sera o gateway local que acompanha esta camera IP na rede.',
+  createButtonLabel: 'Cadastrar camera IP',
+  statusSectionDescription:
+    'O app tenta abrir uma conexao TCP direta com a camera IP para indicar se ela esta acessivel na rede deste device.',
+  registrationSectionTitle: 'Cadastro da camera IP',
+  detailAliasPlaceholder: 'Nome da camera IP',
+  registrationAlertTitle: 'Cadastro da camera IP',
+  routingSectionTitle: 'Acesso da camera',
+  routingSectionDescription:
+    'Informe como acessar o stream da camera e qual PDV ou DISPLAY local fica responsavel por acompanhar essa conexao.',
+  routingAlertTitle: 'Acesso da camera IP',
+  hostMissingBeforeSaveMessage:
+    'Informe o IP ou hostname da camera IP antes de salvar.',
+  managerRoutingMessage:
+    'Selecione qual PDV ou DISPLAY acompanha esta camera IP.',
+  saveBeforeRoutingMessage:
+    'Salve primeiro o cadastro da camera IP antes de configurar o acesso.',
+  footerDebugDescription:
+    'Controla se esta camera IP mostra apenas a bolinha discreta do socket no rodape global ou se abre as linhas detalhadas de debug.',
+  removeSectionTitle: 'Remover cadastro de rede',
+  removeSectionDescription:
+    'Use esta acao para excluir apenas o cadastro desta camera na rede. O equipamento responsavel pela comunicacao continua salvo no sistema.',
+  removeButtonLabel: 'Remover cadastro de rede',
+  removeConfirmTitle: 'Remover camera da rede',
+  removeConfirmMessage:
+    'Deseja remover o cadastro desta camera na rede? O equipamento responsavel continuara salvo no sistema.',
+  removeSuccessMessage: 'Cadastro da camera na rede removido com sucesso.',
+  removeErrorMessage: 'Nao foi possivel remover o cadastro da camera na rede.',
+};
+
+const profileByType = {
+  [PRINT_DEVICE_TYPE]: printerProfile,
+  [PRINTER_DEVICE_TYPE]: printerProfile,
+  [IP_CAMERA_DEVICE_TYPE]: ipCameraProfile,
+};
+
+export const getNetworkDeviceProfile = type =>
+  profileByType[normalizeDeviceType(type)] || printerProfile;

package/src/react/utils/normalizedCatalogDownload.js

@@ -0,0 +1,157 @@
+import {Platform} from 'react-native';
+import {env} from '@env';
+import {File, Paths} from 'expo-file-system';
+import * as Sharing from 'expo-sharing';
+
+import {api} from '@controleonline/ui-common/src/api';
+import {resolveAppDomain} from '@controleonline/ui-common/src/utils/appDomain';
+
+const normalizeId = value => String(value || '').replace(/\D+/g, '').trim();
+
+const slugifyFileName = value => {
+  const normalized = String(value || '')
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+
+  return normalized || 'catalogo';
+};
+
+const extractFilenameFromDisposition = value => {
+  const utf8Match = String(value || '').match(/filename\*=UTF-8''([^;]+)/i);
+  if (utf8Match?.[1]) {
+    return decodeURIComponent(utf8Match[1]).trim();
+  }
+
+  const fallbackMatch = String(value || '').match(/filename="?([^";]+)"?/i);
+  return fallbackMatch?.[1]?.trim() || null;
+};
+
+const extractDownloadErrorMessage = async response => {
+  const fallback = 'Nao foi possivel baixar o CSV normalizado.';
+
+  try {
+    const payload = await response.text();
+    if (!payload) {
+      return fallback;
+    }
+
+    try {
+      const parsed = JSON.parse(payload);
+      return parsed?.error || parsed?.description || parsed?.message || fallback;
+    } catch (error) {
+      return payload;
+    }
+  } catch (error) {
+    return fallback;
+  }
+};
+
+export const buildNormalizedCatalogFileName = companyName =>
+  `catalogo-normalizado-${slugifyFileName(companyName)}.csv`;
+
+export const buildNormalizedCatalogDownloadUrl = ({
+  apiEntrypoint,
+  companyId,
+  context,
+}) => {
+  const searchParams = new URLSearchParams();
+  searchParams.set('company', String(companyId));
+  searchParams.set('context', String(context || 'products').trim() || 'products');
+
+  return `${apiEntrypoint}/products/catalog/download-normalized?${searchParams.toString()}`;
+};
+
+export const downloadNormalizedCatalog = async ({
+  companyId,
+  companyName,
+  context,
+} = {}) => {
+  const normalizedCompanyId = normalizeId(companyId);
+  if (!normalizedCompanyId) {
+    throw new Error('Empresa nao selecionada.');
+  }
+
+  const apiEntrypoint = String(env.API_ENTRYPOINT || '').replace(/\/$/, '');
+  if (!apiEntrypoint) {
+    throw new Error('API_ENTRYPOINT nao configurado.');
+  }
+
+  const baseFileName = buildNormalizedCatalogFileName(
+    companyName || normalizedCompanyId,
+  );
+
+  const headers = {
+    Accept: 'text/csv',
+    'App-Domain': resolveAppDomain(env.DOMAIN),
+  };
+
+  const token = await api.getToken();
+  if (token) {
+    headers['API-TOKEN'] = token;
+  }
+
+  const response = await fetch(
+    buildNormalizedCatalogDownloadUrl({
+      apiEntrypoint,
+      companyId: normalizedCompanyId,
+      context,
+    }),
+    {
+      method: 'GET',
+      headers,
+    },
+  );
+
+  if (!response.ok) {
+    throw new Error(await extractDownloadErrorMessage(response));
+  }
+
+  const fileName =
+    extractFilenameFromDisposition(response.headers.get('content-disposition')) ||
+    baseFileName;
+  const blob = await response.blob();
+
+  if (Platform.OS === 'web') {
+    const objectUrl = URL.createObjectURL(blob);
+    const anchor = document.createElement('a');
+    anchor.href = objectUrl;
+    anchor.download = fileName;
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    window.setTimeout(() => URL.revokeObjectURL(objectUrl), 1000);
+
+    return {
+      fileName,
+      shared: false,
+      savedUri: null,
+    };
+  }
+
+  const file = new File(Paths.cache, fileName);
+  file.create({intermediates: true, overwrite: true});
+  file.write(new Uint8Array(await blob.arrayBuffer()));
+
+  if (await Sharing.isAvailableAsync()) {
+    await Sharing.shareAsync(file.uri, {
+      mimeType: 'text/csv',
+      dialogTitle: 'Compartilhar catalogo normalizado',
+    });
+
+    return {
+      fileName,
+      shared: true,
+      savedUri: file.uri,
+    };
+  }
+
+  return {
+    fileName,
+    shared: false,
+    savedUri: file.uri,
+  };
+};
+// TODO(store-first): quando este arquivo for mexido, mover a leitura para stores e evitar chamadas HTTP diretas quando o store ja resolver isso.