@controleonline/ui-common 1.2.80 → 1.2.81

package/src/react/utils/copyDeviceConfigs.js

@@ -0,0 +1,198 @@
+/**
+ * Copy device_config.configs from a source physical device to a destination
+ * physical device without changing destination identity (id/hash/hardware).
+ *
+ * Copyable keys = free-form keys present in the source `configs` JSON
+ * (discovered at runtime). Entity fields (id, device, people, type) are never
+ * copied.
+ *
+ * Known keys observed in the codebase (non-exhaustive; actual copy uses
+ * whatever keys exist on the source row):
+ * - pos-operation-mode, pos-gateway, printer-enabled, payment-type-ids
+ * - pos-product-showcase-id, pos-delivery-enabled, pos-auto-print-enabled
+ * - pos-cash-management-mode, check-order-type, check-order-management-mode
+ * - android-kiosk-enabled, android-launcher-enabled
+ * - order-payment-device, order-payment-devices, order-payment-device-change-allowed
+ * - display-id, printer, display-auto-print-product, display-allow-printer-change
+ * - display-size, display-side-break, print-mode
+ * - print-network-port, print-network-columns, print-network-code-page
+ * - camera-network-*, notification-sound-*, pos-order-visibility
+ * - device-runtime-debug-info-enabled, device-runtime-footer-text
+ */
+
+const normalizeDeviceId = value => String(value || '').trim();
+
+const normalizeEntityId = value =>
+  String(value?.id || value || '')
+    .replace(/\D/g, '')
+    .trim();
+
+const parseConfigsObject = configs => {
+  if (!configs) {
+    return {};
+  }
+  if (typeof configs === 'string') {
+    try {
+      const parsed = JSON.parse(configs);
+      return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+        ? parsed
+        : {};
+    } catch {
+      return {};
+    }
+  }
+  if (typeof configs === 'object' && !Array.isArray(configs)) {
+    return configs;
+  }
+  return {};
+};
+
+export const listCopyableConfigKeys = configs =>
+  Object.keys(parseConfigsObject(configs) || {}).sort();
+
+export const getDeviceConfigDeviceString = deviceConfig =>
+  normalizeDeviceId(
+    deviceConfig?.device?.device ||
+      deviceConfig?.device?.id ||
+      deviceConfig?.device ||
+      '',
+  );
+
+export const getDeviceConfigType = deviceConfig =>
+  String(deviceConfig?.type || deviceConfig?.device?.type || '')
+    .trim()
+    .toUpperCase();
+
+export const getDeviceConfigLabel = deviceConfig => {
+  const alias = String(
+    deviceConfig?.device?.alias ||
+      deviceConfig?.alias ||
+      getDeviceConfigDeviceString(deviceConfig) ||
+      '',
+  ).trim();
+  const type = getDeviceConfigType(deviceConfig);
+  if (alias && type) {
+    return `${alias} (${type})`;
+  }
+  return alias || type || 'Device';
+};
+
+const filterByCompany = (deviceConfigs, companyId) => {
+  const normalizedCompanyId = normalizeEntityId(companyId);
+  return (Array.isArray(deviceConfigs) ? deviceConfigs : []).filter(
+    deviceConfig =>
+      !normalizedCompanyId ||
+      normalizeEntityId(deviceConfig?.people?.id || deviceConfig?.people) ===
+        normalizedCompanyId,
+  );
+};
+
+/**
+ * Group company device_config rows by physical device string, excluding the
+ * destination device. Used to build the "Copiar de…" picker.
+ */
+export const buildSourceDeviceOptions = ({
+  companyDeviceConfigs = [],
+  companyId,
+  destinationDeviceString,
+} = {}) => {
+  const dest = normalizeDeviceId(destinationDeviceString);
+  const scoped = filterByCompany(companyDeviceConfigs, companyId);
+  const byDevice = new Map();
+
+  scoped.forEach(row => {
+    const deviceString = getDeviceConfigDeviceString(row);
+    if (!deviceString || (dest && deviceString === dest)) {
+      return;
+    }
+    if (!byDevice.has(deviceString)) {
+      byDevice.set(deviceString, {
+        deviceString,
+        alias: String(row?.device?.alias || deviceString).trim(),
+        configs: [],
+      });
+    }
+    byDevice.get(deviceString).configs.push(row);
+  });
+
+  return Array.from(byDevice.values()).sort((a, b) =>
+    String(a.alias).localeCompare(String(b.alias), 'pt-BR'),
+  );
+};
+
+/**
+ * Build POST payloads for addDeviceConfigs: one per type present on source.
+ */
+export const buildCopyPayloads = ({
+  sourceConfigs = [],
+  destinationDeviceString,
+  peopleIri,
+} = {}) => {
+  const dest = normalizeDeviceId(destinationDeviceString);
+  const people = String(peopleIri || '').trim();
+  if (!dest || !people) {
+    return [];
+  }
+
+  const byType = new Map();
+  (Array.isArray(sourceConfigs) ? sourceConfigs : []).forEach(row => {
+    const type = getDeviceConfigType(row);
+    if (!type) {
+      return;
+    }
+    const configs = parseConfigsObject(row?.configs);
+    byType.set(type, {
+      device: dest,
+      people,
+      type,
+      configs: JSON.stringify(configs || {}),
+      keys: listCopyableConfigKeys(configs),
+    });
+  });
+
+  return Array.from(byType.values());
+};
+
+/**
+ * Execute copy: for each payload, call addDeviceConfigs.
+ */
+export const executeCopyDeviceConfigs = async ({
+  addDeviceConfigs,
+  sourceConfigs = [],
+  destinationDeviceString,
+  peopleIri,
+} = {}) => {
+  if (typeof addDeviceConfigs !== 'function') {
+    throw new Error('addDeviceConfigs is required');
+  }
+
+  const payloads = buildCopyPayloads({
+    sourceConfigs,
+    destinationDeviceString,
+    peopleIri,
+  });
+
+  if (payloads.length === 0) {
+    return {types: [], keys: [], results: []};
+  }
+
+  const results = [];
+  const allKeys = new Set();
+
+  for (const payload of payloads) {
+    (payload.keys || []).forEach(key => allKeys.add(key));
+    const result = await addDeviceConfigs({
+      device: payload.device,
+      people: payload.people,
+      type: payload.type,
+      configs: payload.configs,
+    });
+    results.push({type: payload.type, keys: payload.keys, result});
+  }
+
+  return {
+    types: payloads.map(p => p.type),
+    keys: Array.from(allKeys).sort(),
+    results,
+  };
+};

package/src/react/utils/fileUrl.js

@@ -81,6 +81,44 @@ const resolveDownloadHost = ({company = null, appDomain = ''} = {}) => {
   return resolveCompanyDomain(company, fallbackDomain);
 };
 
+/**
+ * Environment / platform hosts (staging, dev, localhost) are not tenant domains.
+ * Injecting them into /{host}/files/{id}/download produces URLs like
+ * https://s.controleonline.com/staging.controleonline.com/files/... → 403.
+ * Keep app-domain header only; do not path-inject environment hosts.
+ * app-community#432
+ */
+const isEnvironmentLikeHost = host => {
+  const normalized = normalizeText(host).toLowerCase();
+  if (!normalized) return false;
+  if (
+    normalized === 'localhost' ||
+    normalized.startsWith('localhost:') ||
+    normalized === '127.0.0.1' ||
+    normalized.startsWith('127.0.0.1:')
+  ) {
+    return true;
+  }
+  // staging.*, dev.*, *.staging.*, etc.
+  if (
+    /^(staging|dev|local|test|qa)([.-]|$)/i.test(normalized) ||
+    /\.(staging|dev|local|test)\./i.test(normalized) ||
+    normalized.endsWith('.local')
+  ) {
+    return true;
+  }
+  // Explicit known platform hosts used as ENV DOMAIN, not company domains
+  if (
+    normalized === 'staging.controleonline.com' ||
+    normalized === 'dev.controleonline.com' ||
+    normalized === 'manager.controleonline.com' ||
+    normalized === 'pos.controleonline.com'
+  ) {
+    return true;
+  }
+  return false;
+};
+
 const buildBackendDownloadUrl = (fileId, options = {}) => {
   const normalizedId = String(fileId || '').trim();
   if (!normalizedId) {
@@ -100,6 +138,11 @@ const buildTenantDownloadUrl = (url, host) => {
     return absoluteUrl;
   }
 
+  // Do not inject environment hosts into the path (app-community#432).
+  if (isEnvironmentLikeHost(normalizedHost)) {
+    return absoluteUrl;
+  }
+
   if (/^https?:\/\//i.test(absoluteUrl)) {
     const match = stripDomainQueryParams(absoluteUrl).match(
       /^(https?:\/\/[^/?#]+)\/(?:[^/]+\/)?files\/([^/?#]+)\/download([^#]*)(#.*)?$/i,

package/src/react/utils/importStatus.js

@@ -73,18 +73,26 @@ function getImportErrorDetail(item) {
   return candidates.find(candidate => String(candidate || '').trim()) || ''
 }
 
-function resolveImportLabels(translate) {
-  return {
+function resolveImportLabels(translate) {
+  return {
     refreshLabel: translate?.('imports', 'button', 'refresh'),
     processingLabel: translate?.('imports', 'status', 'processing'),
     errorLabel: translate?.('imports', 'status', 'error'),
     doneLabel: translate?.('imports', 'status', 'done'),
     noStatusLabel: translate?.('imports', 'status', 'no_status'),
     processingHelpLabel: translate?.('imports', 'message', 'processing_after_upload'),
-  }
-}
-
-function resolveImportStatusLabel(statusMeta, labels = {}) {
+  }
+}
+
+function resolveImportTranslator(translator = globalThis?.t) {
+  if (typeof translator?.t !== 'function') {
+    return undefined
+  }
+
+  return translator.t.bind(translator)
+}
+
+function resolveImportStatusLabel(statusMeta, labels = {}) {
   if (statusMeta?.labelKey === 'processing') return labels.processingLabel
   if (statusMeta?.labelKey === 'error') return labels.errorLabel
   if (statusMeta?.labelKey === 'done') return labels.doneLabel
@@ -94,7 +102,8 @@ function resolveImportStatusLabel(statusMeta, labels = {}) {
 module.exports = {
   getImportErrorDetail,
   getImportStatusMeta,
-  normalizeImportStatus,
-  resolveImportLabels,
-  resolveImportStatusLabel,
-}
+  normalizeImportStatus,
+  resolveImportLabels,
+  resolveImportTranslator,
+  resolveImportStatusLabel,
+}

package/src/react/utils/logSettings.js

@@ -7,25 +7,25 @@ export const LOG_POLICY_ITEMS = [
     key: 'backend_error',
     title: 'Erros do backend',
     description:
-      'Registra excecoes e falhas HTTP do backend. E o grupo principal para erros 500.',
+      'Registra exceções e falhas HTTP do backend. É o grupo principal para erros 500.',
   },
   {
     key: 'entity',
-    title: 'Historico de entidades',
+    title: 'Histórico de entidades',
     description:
-      'Mantem os diffs de criacao, alteracao e remocao das entidades do sistema.',
+      'Mantém os diffs de criação, alteração e remoção das entidades do sistema.',
   },
   {
     key: 'generic',
-    title: 'Logs genericos',
+    title: 'Logs genéricos',
     description:
-      'Agrupa logs tecnicos de integracao, workers e eventos que nao sao timeline de entidade.',
+      'Agrupa logs técnicos de integração, workers e eventos que não são timeline de entidade.',
   },
   {
     key: 'operation_patterns',
-    title: 'Padroes operacionais',
+    title: 'Padrões operacionais',
     description:
-      'Mantem registros tecnicos ligados a padroes e diagnosticos operacionais do sistema.',
+      'Mantém registros técnicos ligados a padrões e diagnósticos operacionais do sistema.',
   },
   {
     key: 'frontend_debug',

package/src/react/utils/maintenanceSettings.js

@@ -9,6 +9,22 @@ export const MAINTENANCE_ROUTINE_ITEMS = [
     defaultEnabled: true,
     defaultCronExpression: '* * * * *',
   },
+  {
+    key: 'cleanup_ephemeral_integrations',
+    title: 'Limpeza de integracoes efemeras',
+    description:
+      'Remove Websocket e PushNotification abertos ha mais de 24 horas.',
+    defaultEnabled: false,
+    defaultCronExpression: '0 * * * *',
+  },
+  {
+    key: 'open_overdue_opportunities',
+    title: 'Oportunidades vencidas para aberto',
+    description:
+      'Move oportunidades de CRM de pendente para aberto quando a data de retorno ja passou.',
+    defaultEnabled: true,
+    defaultCronExpression: '* * * * *',
+  },
 ];
 
 export const normalizeMaintenanceRoutines = value => {

package/src/react/utils/paymentDevices.js

@@ -2,9 +2,11 @@ import {Platform} from 'react-native';
 
 export const PAYMENT_GATEWAY_CIELO = 'cielo';
 export const PAYMENT_GATEWAY_INFINITE_PAY = 'infinite-pay';
+export const PAYMENT_GATEWAY_GETNET = 'getnet';
 export const PAYMENT_GATEWAYS = [
   PAYMENT_GATEWAY_CIELO,
   PAYMENT_GATEWAY_INFINITE_PAY,
+  PAYMENT_GATEWAY_GETNET,
 ];
 export const POS_GATEWAY_CONFIG_KEY = 'pos-gateway';
 export const PDV_PRINTER_ENABLED_CONFIG_KEY = 'printer-enabled';
@@ -152,6 +154,9 @@ export const normalizePaymentGateway = value => {
   if (compactGateway === PAYMENT_GATEWAY_CIELO) {
     return PAYMENT_GATEWAY_CIELO;
   }
+  if (compactGateway === 'getnet' || compactGateway === PAYMENT_GATEWAY_GETNET) {
+    return PAYMENT_GATEWAY_GETNET;
+  }
 
   return compactGateway;
 };
@@ -309,6 +314,7 @@ export const getPaymentDeviceLabel = deviceConfig =>
 export const getPaymentGatewayLabel = gateway => {
   if (gateway === PAYMENT_GATEWAY_CIELO) return 'Cielo';
   if (gateway === PAYMENT_GATEWAY_INFINITE_PAY) return 'Infinite Pay';
+  if (gateway === PAYMENT_GATEWAY_GETNET) return 'Getnet';
   return 'Gateway nao configurado';
 };
 

package/src/react/utils/printManagedPrinter.js

@@ -0,0 +1,45 @@
+import {
+  DEFAULT_NETWORK_PRINTER_PORT,
+  DEFAULT_NETWORK_PRINTER_CODE_PAGE,
+  getPrinterHost,
+  NETWORK_PRINTER_CODE_PAGE_CONFIG_KEY,
+  NETWORK_PRINTER_PORT_CONFIG_KEY,
+  normalizePrinterPort,
+} from '@controleonline/ui-common/src/react/utils/printerDevices';
+import {
+  decodeNetworkPrinterPayload,
+  printOnNetworkPrinter,
+} from '@controleonline/ui-common/src/react/services/NetworkPrinterService';
+
+/**
+ * Print spool content on a managed network printer when available.
+ * @returns {Promise<boolean>} true if managed printer handled the job
+ */
+export const printOnManagedNetworkPrinter = async ({
+  managedPrinter,
+  content,
+}) => {
+  if (!managedPrinter) {
+    return false;
+  }
+
+  const printerHost = getPrinterHost(managedPrinter);
+  const printerPort = normalizePrinterPort(
+    managedPrinter?.configs?.[NETWORK_PRINTER_PORT_CONFIG_KEY] ||
+      DEFAULT_NETWORK_PRINTER_PORT,
+  );
+  const printerCodePage =
+    managedPrinter?.configs?.[NETWORK_PRINTER_CODE_PAGE_CONFIG_KEY] ||
+    DEFAULT_NETWORK_PRINTER_CODE_PAGE;
+
+  await printOnNetworkPrinter({
+    host: printerHost,
+    port: printerPort,
+    codePage: printerCodePage,
+    payload: decodeNetworkPrinterPayload(content, {
+      codePage: printerCodePage,
+    }),
+  });
+
+  return true;
+};

package/src/react/utils/printRouting.js

@@ -0,0 +1,63 @@
+export const COMPANY_DEVICE_CONFIGS_CACHE_TTL_MS = 30 * 1000;
+
+export const PRINT_ROUTE_MISSING_DESTINATION =
+  'Não foi possível rotear a impressão: nenhum device de impressão configurado.';
+
+const normalizeDeviceId = value => String(value || '').trim();
+const normalizeDeviceType = value => String(value || '').trim().toUpperCase();
+
+export const PDV_RUNTIME_TYPE = 'PDV';
+export const DISPLAY_RUNTIME_TYPE = 'DISPLAY';
+
+export const resolvePrinterDeviceId = printer =>
+  normalizeDeviceId(printer?.device || printer?.deviceId);
+
+/**
+ * Device ids whose open spools this runtime should poll/print.
+ * Managed network printers expose `device` (not only `deviceId`).
+ */
+export const resolveSpoolDeviceIdsForRuntime = ({
+  runtimeDeviceId = '',
+  runtimeDeviceType = '',
+  isWebRuntime = false,
+  managedPrinters = [],
+  includeLocalDevice = true,
+} = {}) => {
+  const normalizedRuntimeId = normalizeDeviceId(runtimeDeviceId);
+  if (!normalizedRuntimeId || isWebRuntime) {
+    return [];
+  }
+
+  const managedIds = (Array.isArray(managedPrinters) ? managedPrinters : [])
+    .map(resolvePrinterDeviceId)
+    .filter(Boolean);
+
+  const type = normalizeDeviceType(runtimeDeviceType);
+
+  if (type === PDV_RUNTIME_TYPE) {
+    return Array.from(
+      new Set(
+        [
+          ...(includeLocalDevice ? [normalizedRuntimeId] : []),
+          ...managedIds,
+        ].filter(Boolean),
+      ),
+    );
+  }
+
+  if (type === DISPLAY_RUNTIME_TYPE) {
+    return Array.from(new Set(managedIds));
+  }
+
+  return [];
+};
+
+export const resolvePrintRoutingError = ({
+  targetDeviceId = '',
+  selectedPrinter = null,
+} = {}) => {
+  const resolvedTarget = normalizeDeviceId(
+    targetDeviceId || selectedPrinter?.device || selectedPrinter?.deviceId,
+  );
+  return resolvedTarget ? '' : PRINT_ROUTE_MISSING_DESTINATION;
+};

package/src/react/utils/printSpoolUtils.js

@@ -0,0 +1,119 @@
+/**
+ * Pure helpers for print spool routing / queue handling.
+ * Kept small so PrintService stays under the 500-line absolute limit.
+ */
+
+export const SOCKET_PRINT_POLL_INTERVAL_DISCONNECTED = 10000;
+export const SOCKET_PRINT_POLL_DELAY_CONNECTED = 60000;
+export const SPOOL_ACK_RETRY_DELAY_MS = 10000;
+
+export const normalizeDeviceType = value =>
+  String(value || '').trim().toUpperCase();
+
+export const extractCollectionMembers = data => {
+  if (Array.isArray(data)) {
+    return data;
+  }
+
+  if (Array.isArray(data?.member)) {
+    return data.member;
+  }
+
+  if (Array.isArray(data?.['hydra:member'])) {
+    return data['hydra:member'];
+  }
+
+  return [];
+};
+
+export const resolveSpoolId = value => {
+  if (!value) return null;
+  if (typeof value === 'number') return value;
+  if (typeof value === 'string') {
+    const numericValue = value.replace(/\D/g, '');
+    return numericValue ? Number(numericValue) : null;
+  }
+
+  return (
+    resolveSpoolId(value?.id) ||
+    resolveSpoolId(value?.spoolId) ||
+    resolveSpoolId(value?.spool) ||
+    resolveSpoolId(value?.['@id'])
+  );
+};
+
+/**
+ * Merge open-spool collections from multiple devices, dedupe by id, sort ascending.
+ */
+export const mergeOpenSpoolCollections = spoolCollections => {
+  const mergedSpools = [];
+  const spoolIds = new Set();
+
+  (Array.isArray(spoolCollections) ? spoolCollections : [])
+    .flat()
+    .forEach(item => {
+      const spoolId = resolveSpoolId(item);
+      const spoolKey = spoolId ? String(spoolId) : JSON.stringify(item);
+
+      if (!spoolIds.has(spoolKey)) {
+        spoolIds.add(spoolKey);
+        mergedSpools.push(item);
+      }
+    });
+
+  mergedSpools.sort((left, right) => {
+    const leftId = resolveSpoolId(left) || 0;
+    const rightId = resolveSpoolId(right) || 0;
+    return leftId - rightId;
+  });
+
+  return mergedSpools;
+};
+
+/**
+ * Fetch open spools for a list of device ids (parallel).
+ * Returns merged, deduped, sorted list. Caller handles store updates / errors.
+ */
+export const fetchOpenSpoolsForDevices = async (api, deviceIds) => {
+  const ids = Array.from(
+    new Set((Array.isArray(deviceIds) ? deviceIds : []).filter(Boolean)),
+  );
+
+  if (ids.length === 0) {
+    return [];
+  }
+
+  const spoolCollections = await Promise.all(
+    ids.map(deviceId =>
+      api
+        .fetch('spools', {
+          params: {
+            'device.device': deviceId,
+            'status.realStatus': 'open',
+          },
+        })
+        .then(extractCollectionMembers)
+        .catch(() => []),
+    ),
+  );
+
+  return mergeOpenSpoolCollections(spoolCollections);
+};
+
+export const resolveRequestedTargetDeviceId = (printJob, fallbackDeviceId) => {
+  const raw =
+    printJob?.targetDeviceId ||
+    printJob?.deviceId ||
+    printJob?.device?.device ||
+    printJob?.device ||
+    fallbackDeviceId;
+  return String(raw || '').trim();
+};
+
+export const resolveRequestedTargetDeviceTypeValue = printJob =>
+  normalizeDeviceType(
+    printJob?.targetDeviceType ||
+      printJob?.deviceType ||
+      printJob?.device?.type ||
+      '',
+  );