@controleonline/ui-common 1.2.70 → 1.2.71

package/src/react/utils/fileUrl.js

@@ -1,11 +1,12 @@
-import { env as APP_ENV } from '@env';
-import { buildAssetUrl } from '@controleonline/../../src/styles/branding';
+import {env as APP_ENV} from '@env';
+import {buildAssetUrl} from '@controleonline/../../src/styles/branding';
 import {
   resolveAppDomain,
   resolveCompanyDomain,
 } from '@controleonline/ui-common/src/utils/appDomain';
 
 const IMAGE_PATH_PATTERN = /\.(?:avif|bmp|gif|ico|jpe?g|png|svg|webp)(?:\?|$)/i;
+const FILE_DOWNLOAD_PATTERN = /(?:^|\/)files\/[^/?#]+\/download(?:[?#]|$)/i;
 
 const normalizeText = value => String(value || '').trim();
 
@@ -21,6 +22,84 @@ const unwrapFile = file => {
   return file;
 };
 
+const isDownloadLikeUrl = value =>
+  FILE_DOWNLOAD_PATTERN.test(normalizeText(value));
+
+const appendQueryParam = (url, key, value) => {
+  const normalizedUrl = normalizeText(url);
+  const normalizedKey = normalizeText(key);
+  const normalizedValue = normalizeText(value);
+
+  if (!normalizedUrl || !normalizedKey || !normalizedValue) {
+    return normalizedUrl;
+  }
+
+  const hashIndex = normalizedUrl.indexOf('#');
+  const hash = hashIndex >= 0 ? normalizedUrl.slice(hashIndex) : '';
+  const urlWithoutHash =
+    hashIndex >= 0 ? normalizedUrl.slice(0, hashIndex) : normalizedUrl;
+  const queryIndex = urlWithoutHash.indexOf('?');
+  const base =
+    queryIndex >= 0 ? urlWithoutHash.slice(0, queryIndex) : urlWithoutHash;
+  const query = queryIndex >= 0 ? urlWithoutHash.slice(queryIndex + 1) : '';
+  const params = query
+    ? query
+        .split('&')
+        .map(item => item.trim())
+        .filter(Boolean)
+        .filter(item => {
+          const [rawKey] = item.split('=');
+          return decodeURIComponent(rawKey || '') !== normalizedKey;
+        })
+    : [];
+
+  params.push(
+    `${encodeURIComponent(normalizedKey)}=${encodeURIComponent(normalizedValue)}`,
+  );
+
+  return `${base}?${params.join('&')}${hash}`;
+};
+
+const ensureAbsoluteUrl = url => {
+  const normalizedUrl = normalizeText(url);
+  if (!normalizedUrl) {
+    return '';
+  }
+
+  if (/^https?:\/\//i.test(normalizedUrl) || /^\/\//.test(normalizedUrl)) {
+    return buildAssetUrl(normalizedUrl) || normalizedUrl;
+  }
+
+  const apiEntryPoint = normalizeText(APP_ENV?.API_ENTRYPOINT).replace(
+    /\/$/,
+    '',
+  );
+  const normalizedPath = normalizedUrl.startsWith('/')
+    ? normalizedUrl
+    : `/${normalizedUrl}`;
+
+  return apiEntryPoint ? `${apiEntryPoint}${normalizedPath}` : normalizedPath;
+};
+
+const resolveDownloadHost = ({company = null, appDomain = ''} = {}) => {
+  const fallbackDomain =
+    normalizeText(appDomain) || resolveAppDomain(APP_ENV?.DOMAIN);
+  return resolveCompanyDomain(company, fallbackDomain);
+};
+
+const buildBackendDownloadUrl = (fileId, options = {}) => {
+  const normalizedId = String(fileId || '').trim();
+  if (!normalizedId) {
+    return '';
+  }
+
+  const host = resolveDownloadHost(options);
+  const relativeUrl = `/files/${normalizedId}/download`;
+  const absoluteUrl = ensureAbsoluteUrl(relativeUrl);
+
+  return host ? appendQueryParam(absoluteUrl, 'app-domain', host) : absoluteUrl;
+};
+
 const resolveDirectFileUrl = file => {
   if (!file) {
     return '';
@@ -77,26 +156,113 @@ export const extractFileId = file => {
   return null;
 };
 
-// Centraliza a resolucao de imagem/arquivo do backend em uma unica regra.
-export const resolveFileImageUrl = (file, {company = null, appDomain = ''} = {}) => {
+export const resolveDefaultFileSource = (
+  file,
+  {company = null, appDomain = '', headers = {}} = {},
+) => {
   const normalizedFile = unwrapFile(file);
-  const directUrl = resolveDirectFileUrl(normalizedFile);
-  if (directUrl) {
-    return directUrl;
+  const host = resolveDownloadHost({company, appDomain});
+
+  if (!normalizedFile) {
+    return null;
   }
 
-  const fileId = extractFileId(normalizedFile);
-  if (!fileId) {
-    return '';
+  if (typeof normalizedFile === 'number') {
+    const uri = buildBackendDownloadUrl(normalizedFile, {company, appDomain});
+
+    return uri
+      ? {
+          uri,
+          headers: host ? {...headers, 'app-domain': host} : {...headers},
+        }
+      : null;
+  }
+
+  if (typeof normalizedFile === 'string') {
+    const normalizedValue = normalizeText(normalizedFile);
+    if (!normalizedValue) {
+      return null;
+    }
+
+    if (isDownloadLikeUrl(normalizedValue)) {
+      const uri = appendQueryParam(
+        ensureAbsoluteUrl(normalizedValue),
+        'app-domain',
+        host,
+      );
+
+      return uri
+        ? {
+            uri,
+            headers: host ? {...headers, 'app-domain': host} : {...headers},
+          }
+        : null;
+    }
+
+    const numericId = extractFileId(normalizedValue);
+    if (numericId && !IMAGE_PATH_PATTERN.test(normalizedValue)) {
+      const uri = buildBackendDownloadUrl(numericId, {company, appDomain});
+
+      return uri
+        ? {
+            uri,
+            headers: host ? {...headers, 'app-domain': host} : {...headers},
+          }
+        : null;
+    }
+
+    const directUrl = resolveDirectFileUrl(normalizedValue);
+
+    return directUrl
+      ? {
+          uri: directUrl,
+          headers: {...headers},
+        }
+      : null;
   }
 
-  const fallbackDomain = normalizeText(appDomain) || resolveAppDomain(APP_ENV?.DOMAIN);
-  const host = resolveCompanyDomain(company, fallbackDomain);
-  const query = host ? `?app-domain=${encodeURIComponent(host)}` : '';
-  const relativeUrl = `/files/${fileId}/download${query}`;
-  const apiEntryPoint = normalizeText(APP_ENV?.API_ENTRYPOINT).replace(/\/$/, '');
+  if (typeof normalizedFile === 'object' && !Array.isArray(normalizedFile)) {
+    const sourceHeaders =
+      normalizedFile?.headers && typeof normalizedFile.headers === 'object'
+        ? normalizedFile.headers
+        : {};
+    const fileId = extractFileId(normalizedFile);
+    const directUrl = resolveDirectFileUrl(normalizedFile);
+    const isBackendDownload =
+      Boolean(fileId) ||
+      isDownloadLikeUrl(directUrl) ||
+      isDownloadLikeUrl(normalizedFile?.uri) ||
+      isDownloadLikeUrl(normalizedFile?.url) ||
+      isDownloadLikeUrl(normalizedFile?.path);
+    const uriBase =
+      directUrl ||
+      (fileId ? buildBackendDownloadUrl(fileId, {company, appDomain}) : '');
+
+    if (!uriBase) {
+      return null;
+    }
+
+    const uri = isBackendDownload
+      ? appendQueryParam(ensureAbsoluteUrl(uriBase), 'app-domain', host)
+      : uriBase;
 
-  return apiEntryPoint ? `${apiEntryPoint}${relativeUrl}` : relativeUrl;
+    return {
+      uri,
+      headers:
+        isBackendDownload && host
+          ? {...sourceHeaders, ...headers, 'app-domain': host}
+          : {...sourceHeaders, ...headers},
+    };
+  }
+
+  return null;
 };
 
+export const resolveDefaultFileUrl = (file, options = {}) =>
+  resolveDefaultFileSource(file, options)?.uri || '';
+
+// Centraliza a resolucao de imagem/arquivo do backend em uma unica regra.
+export const resolveFileImageUrl = (file, options = {}) =>
+  resolveDefaultFileUrl(file, options);
+
 export const resolveFileDownloadUrl = resolveFileImageUrl;

package/src/react/utils/menuNavigation.js

@@ -0,0 +1,31 @@
+const LEGACY_ROUTE_ALIASES = {
+  displayList: 'DisplayList',
+  displayDetails: 'DisplayDetails',
+};
+
+export const resolveMenuRouteName = routeName => {
+  const normalizedRouteName = String(routeName || '').trim();
+
+  if (!normalizedRouteName) {
+    return '';
+  }
+
+  return LEGACY_ROUTE_ALIASES[normalizedRouteName] || normalizedRouteName;
+};
+
+export const resolveMenuRouteParams = routeParams => {
+  if (
+    routeParams &&
+    typeof routeParams === 'object' &&
+    !Array.isArray(routeParams)
+  ) {
+    return routeParams;
+  }
+
+  return {};
+};
+
+export default {
+  resolveMenuRouteName,
+  resolveMenuRouteParams,
+};

package/src/react/utils/orderIdentity.js

@@ -0,0 +1,277 @@
+/*
+ * Regra de negocio: a identidade operacional nao pode inventar codigo de
+ * marketplace. O resolvedor usa apenas campos canonicos do pedido.
+ */
+
+const normalizeText = value => String(value ?? '').trim();
+
+const normalizeKey = value =>
+  normalizeText(value)
+    .normalize('NFD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase();
+
+const formatOrderCode = value => {
+  const normalized = normalizeText(value);
+  return normalized ? `#${normalized}` : '';
+};
+
+const isObject = value =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const parseJsonObject = value => {
+  if (isObject(value)) {
+    return value;
+  }
+
+  if (typeof value !== 'string') {
+    return {};
+  }
+
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === 'string') {
+      return parseJsonObject(parsed);
+    }
+
+    return isObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+
+const getExtraDataList = order => {
+  if (Array.isArray(order?.extraData)) {
+    return order.extraData;
+  }
+
+  if (Array.isArray(order?.extra_data)) {
+    return order.extra_data;
+  }
+
+  return [];
+};
+
+const getExtraDataMap = order =>
+  getExtraDataList(order).reduce((currentMap, extraData) => {
+    const context = normalizeKey(
+      extraData?.extra_fields?.context || extraData?.extraFields?.context,
+    );
+    const name = normalizeText(
+      extraData?.extra_fields?.name || extraData?.extraFields?.name,
+    );
+    const value = normalizeText(extraData?.value);
+
+    if (!context || !name || !value) {
+      return currentMap;
+    }
+
+    if (!currentMap[context]) {
+      currentMap[context] = {};
+    }
+
+    currentMap[context][name] = value;
+    return currentMap;
+  }, {});
+
+const decodeOrderOtherInformations = order =>
+  parseJsonObject(
+    order?.otherInformations ??
+      order?.other_information ??
+      order?.otherInformation ??
+      order?.otherInformationsJson ??
+      order?.other_information_json,
+  );
+
+const getContextFromOtherInformations = (order, context) => {
+  const otherInformations = decodeOrderOtherInformations(order);
+  const matchedKey = Object.keys(otherInformations).find(
+    key => normalizeKey(key) === normalizeKey(context),
+  );
+
+  if (!matchedKey) {
+    return {};
+  }
+
+  const matchedValue = otherInformations?.[matchedKey];
+  return isObject(matchedValue) ? matchedValue : parseJsonObject(matchedValue);
+};
+
+const findNestedFieldValue = (source, fieldName) => {
+  if (Array.isArray(source)) {
+    for (const entry of source) {
+      const nestedValue = findNestedFieldValue(entry, fieldName);
+      if (nestedValue) {
+        return nestedValue;
+      }
+    }
+
+    return '';
+  }
+
+  if (!isObject(source)) {
+    return '';
+  }
+
+  const normalizedFieldName = normalizeKey(fieldName);
+  const matchedKey = Object.keys(source).find(
+    key => normalizeKey(key) === normalizedFieldName,
+  );
+
+  if (matchedKey) {
+    const directValue = normalizeText(source?.[matchedKey]);
+    if (directValue) {
+      return directValue;
+    }
+  }
+
+  for (const value of Object.values(source)) {
+    const nestedValue = findNestedFieldValue(value, fieldName);
+    if (nestedValue) {
+      return nestedValue;
+    }
+  }
+
+  return '';
+};
+
+const getMarketplaceField = (order, contexts, fieldName) => {
+  const extraDataMap = getExtraDataMap(order);
+
+  for (const context of contexts) {
+    const value = normalizeText(extraDataMap?.[normalizeKey(context)]?.[fieldName]);
+    if (value) {
+      return value;
+    }
+  }
+
+  for (const context of contexts) {
+    const value = findNestedFieldValue(
+      getContextFromOtherInformations(order, context),
+      fieldName,
+    );
+    if (value) {
+      return value;
+    }
+  }
+
+  return '';
+};
+
+const resolveMarketplaceLabel = order => {
+  const normalizedApp = normalizeText(order?.app).toLowerCase();
+
+  if (normalizedApp.includes('99')) {
+    return '99';
+  }
+
+  if (normalizedApp.includes('ifood')) {
+    return 'IFOOD';
+  }
+
+  return normalizeText(order?.app).toUpperCase();
+};
+
+const resolveMarketplaceOrderCodeFromOrder = order => {
+  const normalizedApp = normalizeText(order?.app).toLowerCase();
+
+  if (normalizedApp.includes('99')) {
+    return getMarketplaceField(order, ['Food99', '99Food', '99food'], 'code');
+  }
+
+  if (normalizedApp.includes('ifood')) {
+    return getMarketplaceField(order, ['iFood', 'IFood', 'ifood'], 'code');
+  }
+
+  return '';
+};
+
+const resolveMarketplaceOrderCodeFromSummary = remoteOrderSummary => {
+  if (!remoteOrderSummary || typeof remoteOrderSummary !== 'object') {
+    return '';
+  }
+
+  return normalizeText(
+    remoteOrderSummary?.identifiers?.code ||
+      remoteOrderSummary?.identifiers?.externalId ||
+      remoteOrderSummary?.code ||
+      remoteOrderSummary?.externalId ||
+      remoteOrderSummary?.external_code,
+  );
+};
+
+const resolvePosExternalCode = order =>
+  normalizeText(
+    normalizeText(order?.app).toUpperCase() === 'POS'
+      ? order?.externalCode || order?.external_code || order?.externalId
+      : '',
+  );
+
+const resolvePosExternalLabel = () =>
+  global.t?.t('orders', 'title', 'table') || 'Table';
+
+export const resolveMarketplaceAppLabel = order => resolveMarketplaceLabel(order);
+
+export const resolveMarketplaceOrderCode = (
+  order,
+  remoteOrderSummary = null,
+) =>
+  resolveMarketplaceOrderCodeFromSummary(remoteOrderSummary) ||
+  resolveMarketplaceOrderCodeFromOrder(order);
+
+export const resolveOrderIdentityRemoteSummary = (
+  order,
+  remoteOrderSummary = null,
+) => remoteOrderSummary || null;
+
+export const resolveOrderIdentity = (order, remoteOrderSummary = null) => {
+  const effectiveRemoteOrderSummary = resolveOrderIdentityRemoteSummary(
+    order,
+    remoteOrderSummary,
+  );
+  const internalId = normalizeText(order?.id);
+  const marketplaceLabel = resolveMarketplaceAppLabel(order);
+  const marketplaceOrderCode = resolveMarketplaceOrderCode(
+    order,
+    effectiveRemoteOrderSummary,
+  );
+  const posExternalCode = resolvePosExternalCode(order);
+  const hasMarketplaceReference = !!marketplaceLabel && !!marketplaceOrderCode;
+
+  if (posExternalCode) {
+    return {
+      internalId,
+      externalId: posExternalCode,
+      externalLabel: '',
+      hasMarketplaceReference: false,
+      primaryText: [resolvePosExternalLabel(), formatOrderCode(posExternalCode)]
+        .filter(Boolean)
+        .join(' '),
+      secondaryText:
+        normalizeText(posExternalCode) === internalId
+          ? ''
+          : formatOrderCode(internalId),
+    };
+  }
+
+  if (hasMarketplaceReference) {
+    return {
+      internalId,
+      externalId: marketplaceOrderCode,
+      externalLabel: marketplaceLabel,
+      hasMarketplaceReference: true,
+      primaryText: formatOrderCode(marketplaceOrderCode),
+      secondaryText: formatOrderCode(internalId),
+    };
+  }
+
+  return {
+    internalId,
+    externalId: '',
+    externalLabel: '',
+    hasMarketplaceReference: false,
+    primaryText:
+      formatOrderCode(internalId) || global.t?.t('orders', 'title', 'order'),
+    secondaryText: '',
+  };
+};