@controleonline/ui-common 1.2.70

package/src/react/utils/fileUrl.js

@@ -0,0 +1,102 @@
+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 normalizeText = value => String(value || '').trim();
+
+const unwrapFile = file => {
+  if (!file || typeof file !== 'object' || Array.isArray(file)) {
+    return file;
+  }
+
+  if (file.file) {
+    return unwrapFile(file.file);
+  }
+
+  return file;
+};
+
+const resolveDirectFileUrl = file => {
+  if (!file) {
+    return '';
+  }
+
+  if (typeof file === 'string') {
+    const normalizedFile = normalizeText(file);
+    if (
+      /^https?:\/\//i.test(normalizedFile) ||
+      /^\/\//.test(normalizedFile) ||
+      /\/download(?:\?|$)/i.test(normalizedFile) ||
+      IMAGE_PATH_PATTERN.test(normalizedFile)
+    ) {
+      return buildAssetUrl(normalizedFile) || normalizedFile;
+    }
+
+    return '';
+  }
+
+  if (typeof file === 'object' && !Array.isArray(file)) {
+    return buildAssetUrl(file) || '';
+  }
+
+  return '';
+};
+
+export const extractFileId = file => {
+  const normalizedFile = unwrapFile(file);
+
+  if (!normalizedFile) {
+    return null;
+  }
+
+  if (typeof normalizedFile === 'number') {
+    return normalizedFile;
+  }
+
+  if (typeof normalizedFile === 'string') {
+    const matches = normalizedFile.match(/\d+/g);
+    return matches ? Number(matches[matches.length - 1]) : null;
+  }
+
+  if (typeof normalizedFile === 'object') {
+    const rawValue =
+      normalizedFile?.id ||
+      normalizedFile?.['@id'] ||
+      normalizedFile?.fileId ||
+      normalizedFile?.file_id ||
+      '';
+
+    return extractFileId(rawValue);
+  }
+
+  return null;
+};
+
+// Centraliza a resolucao de imagem/arquivo do backend em uma unica regra.
+export const resolveFileImageUrl = (file, {company = null, appDomain = ''} = {}) => {
+  const normalizedFile = unwrapFile(file);
+  const directUrl = resolveDirectFileUrl(normalizedFile);
+  if (directUrl) {
+    return directUrl;
+  }
+
+  const fileId = extractFileId(normalizedFile);
+  if (!fileId) {
+    return '';
+  }
+
+  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(/\/$/, '');
+
+  return apiEntryPoint ? `${apiEntryPoint}${relativeUrl}` : relativeUrl;
+};
+
+export const resolveFileDownloadUrl = resolveFileImageUrl;

package/src/react/utils/frontendDebugLog.js

@@ -0,0 +1,45 @@
+import {api} from '@controleonline/ui-common/src/api'
+
+const normalizeContext = value =>
+  value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+
+export const sendFrontendDebugLog = async ({
+  channel = 'frontend-debug',
+  class: entityClass = '',
+  context = {},
+  entityRow = null,
+  level = 'info',
+  message = 'Frontend debug log',
+  row = null,
+} = {}) => {
+  if (typeof __DEV__ !== 'undefined' && !__DEV__) {
+    return null
+  }
+
+  const normalizedContext = {
+    ...normalizeContext(context),
+    href:
+      typeof window !== 'undefined' && window?.location?.href
+        ? window.location.href
+        : '',
+  }
+
+  try {
+    const response = await api.fetch('/logs/frontend-debug', {
+      method: 'POST',
+      body: {
+        channel,
+        level,
+        message,
+        context: normalizedContext,
+        entityClass,
+        entityRow: entityRow ?? row,
+      },
+    })
+
+    return response
+  } catch {
+    return null
+  }
+}
+// TODO(store-first): quando este arquivo for mexido, mover a leitura para stores, remover api.fetch e evitar repassar dados em objetos quando o store ja resolver isso.

package/src/react/utils/googleMapsConfig.js

@@ -0,0 +1,49 @@
+const parseJsonValue = (value, fallback) => {
+  if (value === null || value === undefined || value === '') {
+    return fallback;
+  }
+
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value;
+    }
+  }
+
+  return value;
+};
+
+const normalizeTextConfig = (value, fallback = '') => {
+  const parsed = parseJsonValue(value, fallback);
+
+  if (parsed === null || parsed === undefined) {
+    return fallback;
+  }
+
+  return String(parsed).trim();
+};
+
+export const GOOGLE_MAPS_WEB_API_KEY_CONFIG_KEY = 'web-google-maps-api-key';
+export const GOOGLE_MAPS_ANDROID_API_KEY_CONFIG_KEY =
+  'android-google-maps-api-key';
+
+export const resolveGoogleMapsSettings = configs => {
+  const configMap =
+    configs && typeof configs === 'object' && !Array.isArray(configs)
+      ? configs
+      : {};
+
+  const webGoogleMapsApiKey = normalizeTextConfig(
+    configMap[GOOGLE_MAPS_WEB_API_KEY_CONFIG_KEY],
+  );
+
+  const androidGoogleMapsApiKey = normalizeTextConfig(
+    configMap[GOOGLE_MAPS_ANDROID_API_KEY_CONFIG_KEY],
+  );
+
+  return {
+    webGoogleMapsApiKey,
+    androidGoogleMapsApiKey,
+  };
+};

package/src/react/utils/importStatus.js

@@ -0,0 +1,100 @@
+const PROCESSING_IMPORT_STATUSES = ['pending', 'processing', 'queued', 'uploading', 'uploaded']
+const ERROR_IMPORT_STATUSES = ['error', 'failed', 'failure', 'invalid']
+const SUCCESS_IMPORT_STATUSES = ['done', 'success', 'completed', 'processed', 'finished']
+
+function normalizeImportStatus(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+}
+
+function getImportStatusMeta(item) {
+  const rawStatus =
+    item?.status?.realStatus ||
+    item?.status?.status ||
+    item?.status?.name ||
+    ''
+  const normalizedStatus = normalizeImportStatus(rawStatus)
+
+  if (PROCESSING_IMPORT_STATUSES.includes(normalizedStatus)) {
+    return {
+      isProcessing: true,
+      isError: false,
+      labelKey: 'processing',
+      rawStatus,
+      backgroundColor: '#FEF3C7',
+      textColor: '#B45309',
+    }
+  }
+
+  if (ERROR_IMPORT_STATUSES.includes(normalizedStatus)) {
+    return {
+      isProcessing: false,
+      isError: true,
+      labelKey: 'error',
+      rawStatus,
+      backgroundColor: '#FEE2E2',
+      textColor: '#B91C1C',
+    }
+  }
+
+  if (SUCCESS_IMPORT_STATUSES.includes(normalizedStatus)) {
+    return {
+      isProcessing: false,
+      isError: false,
+      labelKey: 'done',
+      rawStatus,
+      backgroundColor: '#DCFCE7',
+      textColor: '#15803D',
+    }
+  }
+
+  return {
+    isProcessing: false,
+    isError: false,
+    labelKey: 'fallback',
+    rawStatus,
+    backgroundColor: '#E2E8F0',
+    textColor: '#475569',
+  }
+}
+
+function getImportErrorDetail(item) {
+  const candidates = [
+    item?.error,
+    item?.errorMessage,
+    item?.status?.message,
+    item?.status?.description,
+    item?.status?.detail,
+    item?.detail,
+    item?.message,
+  ]
+
+  return candidates.find(candidate => String(candidate || '').trim()) || ''
+}
+
+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 = {}) {
+  if (statusMeta?.labelKey === 'processing') return labels.processingLabel
+  if (statusMeta?.labelKey === 'error') return labels.errorLabel
+  if (statusMeta?.labelKey === 'done') return labels.doneLabel
+  return statusMeta?.rawStatus || labels.noStatusLabel
+}
+
+module.exports = {
+  getImportErrorDetail,
+  getImportStatusMeta,
+  normalizeImportStatus,
+  resolveImportLabels,
+  resolveImportStatusLabel,
+}

package/src/react/utils/invoiceDueDateMessages.js

@@ -0,0 +1,14 @@
+export const resolveInvoiceInvalidDateFormatMessage = () =>
+  global.t?.t('invoice', 'validation', 'Use o formato DD/MM/YYYY ou YYYY-MM-DD')
+
+export const resolveInvoiceSingleDatePlaceholder = () =>
+  global.t?.t('invoice', 'placeholder', 'DD/MM/YYYY')
+
+export const resolveInvoiceRangeLabel = () =>
+  global.t?.t('invoice', 'label', 'Vencimento (início/fim)')
+
+export const resolveInvoiceRangeStartPlaceholder = () =>
+  global.t?.t('invoice', 'placeholder', 'Início: DD/MM/YYYY')
+
+export const resolveInvoiceRangeEndPlaceholder = () =>
+  global.t?.t('invoice', 'placeholder', 'Fim: DD/MM/YYYY')

package/src/react/utils/invoicePresentation.js

@@ -0,0 +1,46 @@
+const normalizeText = value => String(value ?? '').trim()
+
+const normalizeInvoiceType = value => {
+  const normalizedValue = normalizeText(value).toLowerCase()
+  return normalizedValue || 'invoice'
+}
+
+const formatInvoiceTypeLabel = value => {
+  const normalizedInvoiceType = normalizeInvoiceType(value)
+
+  const labels = {
+    invoice: 'Invoice',
+    payment: 'Payment',
+    discount: 'Discount',
+    tax: 'Tax',
+  }
+
+  if (labels[normalizedInvoiceType]) {
+    return labels[normalizedInvoiceType]
+  }
+
+  return normalizedInvoiceType
+    .split(/[_\s-]+/)
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ')
+}
+
+const getInvoicePaymentTypeLabel = invoice =>
+  normalizeText(invoice?.paymentType?.paymentType || invoice?.paymentType?.name)
+
+const getInvoicePartyLabel = entity =>
+  normalizeText(
+    entity?.alias ||
+      entity?.name ||
+      entity?.fantasy_name ||
+      entity?.company ||
+      entity?.document,
+  )
+
+module.exports = {
+  normalizeInvoiceType,
+  formatInvoiceTypeLabel,
+  getInvoicePaymentTypeLabel,
+  getInvoicePartyLabel,
+}

package/src/react/utils/logSettings.js

@@ -0,0 +1,143 @@
+export const LOG_ERROR_EMAIL_ENABLED_KEY = 'log-error-email-enabled';
+export const LOG_ERROR_EMAIL_RECIPIENTS_KEY = 'log-error-email-recipients';
+export const LOG_POLICY_CONFIG_KEY = 'log-policy';
+
+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.',
+  },
+  {
+    key: 'entity',
+    title: 'Historico de entidades',
+    description:
+      'Mantem os diffs de criacao, alteracao e remocao das entidades do sistema.',
+  },
+  {
+    key: 'generic',
+    title: 'Logs genericos',
+    description:
+      'Agrupa logs tecnicos de integracao, workers e eventos que nao sao timeline de entidade.',
+  },
+  {
+    key: 'operation_patterns',
+    title: 'Padroes operacionais',
+    description:
+      'Mantem registros tecnicos ligados a padroes e diagnosticos operacionais do sistema.',
+  },
+  {
+    key: 'frontend_debug',
+    title: 'Debug do front-end',
+    description:
+      'Recebe logs enviados pelo React para apoio de debug e investigacao remota.',
+  },
+];
+
+export const DEFAULT_LOG_POLICY = LOG_POLICY_ITEMS.reduce((accumulator, item) => {
+  accumulator[item.key] = {
+    enabled: true,
+    retentionDays: null,
+  };
+
+  return accumulator;
+}, {});
+
+const parseJsonValue = (value, fallback) => {
+  if (value === null || value === undefined || value === '') {
+    return fallback;
+  }
+
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return fallback;
+    }
+  }
+
+  return value;
+};
+
+const normalizeBoolean = value => {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'number') {
+    return value === 1;
+  }
+
+  return ['1', 'true', 'yes', 'on'].includes(
+    String(value || '').trim().toLowerCase(),
+  );
+};
+
+const normalizeRetentionDays = value => {
+  const normalizedValue = String(value || '').replace(/\D+/g, '').trim();
+  if (!normalizedValue) {
+    return null;
+  }
+
+  const parsedValue = Number(normalizedValue);
+
+  return Number.isFinite(parsedValue) && parsedValue > 0 ? parsedValue : null;
+};
+
+export const normalizeLogAlertRecipients = value => {
+  const parsedValue = parseJsonValue(value, value);
+  const source = Array.isArray(parsedValue)
+    ? parsedValue
+    : String(parsedValue || '').split(/[\n,;]+/);
+
+  return Array.from(
+    new Set(
+      source
+        .map(item => String(item || '').trim().toLowerCase())
+        .filter(Boolean)
+        .filter(item => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(item)),
+    ),
+  );
+};
+
+export const findInvalidLogAlertRecipients = value => {
+  const parsedValue = parseJsonValue(value, value);
+  const source = Array.isArray(parsedValue)
+    ? parsedValue
+    : String(parsedValue || '').split(/[\n,;]+/);
+
+  return Array.from(
+    new Set(
+      source
+        .map(item => String(item || '').trim().toLowerCase())
+        .filter(Boolean)
+        .filter(item => !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(item)),
+    ),
+  );
+};
+
+export const normalizeLogPolicy = value => {
+  const parsedValue = parseJsonValue(value, {});
+  const safeValue =
+    parsedValue && typeof parsedValue === 'object' && !Array.isArray(parsedValue)
+      ? parsedValue
+      : {};
+
+  return LOG_POLICY_ITEMS.reduce((accumulator, item) => {
+    const config = safeValue[item.key] || {};
+
+    accumulator[item.key] = {
+      enabled:
+        config.enabled === undefined
+          ? DEFAULT_LOG_POLICY[item.key].enabled
+          : normalizeBoolean(config.enabled),
+      retentionDays: normalizeRetentionDays(config.retentionDays),
+    };
+
+    return accumulator;
+  }, {});
+};
+
+export const formatRecipientsForInput = value =>
+  normalizeLogAlertRecipients(value).join('\n');

package/src/react/utils/maintenanceSettings.js

@@ -0,0 +1,53 @@
+export const MAINTENANCE_ROUTINES_CONFIG_KEY = 'maintenance-routines';
+
+export const MAINTENANCE_ROUTINE_ITEMS = [
+  {
+    key: 'cleanup_logs',
+    title: 'Limpeza de logs',
+    description:
+      'Executa a politica de retencao dos logs e remove registros expirados.',
+    defaultEnabled: true,
+    defaultCronExpression: '* * * * *',
+  },
+];
+
+export const normalizeMaintenanceRoutines = value => {
+  let parsed = value;
+
+  if (typeof parsed === 'string') {
+    try {
+      parsed = JSON.parse(parsed);
+    } catch {
+      parsed = {};
+    }
+  }
+
+  const source = parsed && typeof parsed === 'object' ? parsed : {};
+
+  return MAINTENANCE_ROUTINE_ITEMS.reduce((accumulator, item) => {
+    const routine =
+      source[item.key] && typeof source[item.key] === 'object'
+        ? source[item.key]
+        : {};
+
+    const cronExpression = String(
+      routine.cronExpression || item.defaultCronExpression,
+    ).trim();
+
+    accumulator[item.key] = {
+      enabled:
+        routine.enabled === undefined
+          ? item.defaultEnabled
+          : Boolean(routine.enabled),
+      cronExpression: cronExpression || item.defaultCronExpression,
+    };
+
+    return accumulator;
+  }, {});
+};
+
+export const isLikelyCronExpression = value =>
+  String(value || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean).length === 5;