@controleonline/ui-common 1.2.70 → 1.2.75

package/src/react/services/Cielo/Checkout.js

@@ -0,0 +1,39 @@
+import CieloService from './Cielo';
+
+export const formatCieloCheckoutProducts = orderProducts =>
+  (Array.isArray(orderProducts) ? orderProducts : []).map(orderProduct => ({
+    name: orderProduct?.product?.product,
+    quantity: orderProduct?.quantity,
+    sku:
+      orderProduct?.product?.sku ||
+      String(orderProduct?.product?.['@id'] || '').replace(/\D/g, ''),
+    unitOfMeasure: 'unidade',
+    unitPrice: Math.round(Number(orderProduct?.price || 0) * 100).toString(),
+  }));
+
+export const runCieloCheckoutPayment = async ({
+  orderProducts = [],
+  payment = null,
+  total = 0,
+}) => {
+  const resolvedTotal = Number(total || 0);
+
+  if (!payment?.paymentCode) {
+    throw new Error('Meio de pagamento sem codigo de gateway.');
+  }
+
+  if (resolvedTotal <= 0) {
+    throw new Error('Informe um valor de pagamento valido.');
+  }
+
+  const response = await new CieloService().payment(
+    payment.paymentCode,
+    formatCieloCheckoutProducts(orderProducts),
+    Math.round(resolvedTotal * 100).toString(),
+  );
+
+  return {
+    paidAmount: resolvedTotal,
+    response,
+  };
+};

package/src/react/services/Cielo/Cielo.js

@@ -0,0 +1,193 @@
+import Cielo from '@controleonline-rn/react-native-cielo-payment';
+import {env} from '@env';
+import {api} from '@controleonline/ui-common/src/api';
+import {getAllStores} from '@store';
+import {
+  DEFAULT_CIELO_CONFIG,
+  resolveCieloConfig,
+} from '@controleonline/ui-common/src/utils/integrationConfigs';
+
+const isConfigMap = value =>
+  value && typeof value === 'object' && !Array.isArray(value);
+
+const normalizeEntityId = value =>
+  String(value?.id || value?.['@id'] || value || '')
+    .replace(/\D+/g, '')
+    .trim();
+
+const extractCollectionItems = response => {
+  if (Array.isArray(response)) return response;
+  if (Array.isArray(response?.member)) return response.member;
+  if (Array.isArray(response?.['hydra:member'])) return response['hydra:member'];
+  return [];
+};
+
+const hasRequiredCieloConfig = config =>
+  Boolean(
+    String(config?.ACCESS_TOKEN || '').trim() &&
+      String(config?.CLIENT_ID || '').trim() &&
+      String(config?.EMAIL || '').trim(),
+  );
+
+const hasExpectedMerchantCode = (result, expectedMerchantCode) => {
+  if (!expectedMerchantCode) return true;
+
+  const payments = Array.isArray(result?.payments) ? result.payments : [];
+
+  return (
+    payments.length > 0 &&
+    payments.every(
+      payment => String(payment?.merchantCode || '').trim() === expectedMerchantCode,
+    )
+  );
+};
+
+let technicalCieloConfigCache = DEFAULT_CIELO_CONFIG;
+let technicalCieloConfigCompanyId = '';
+let technicalCieloConfigPromise = null;
+
+const resolveRuntimeCompanyConfigs = () => {
+  const stores = getAllStores();
+  const peopleStore = stores?.people?.getters || {};
+  const configsStore = stores?.configs?.getters || {};
+
+  if (isConfigMap(configsStore.items)) {
+    return configsStore.items;
+  }
+
+  if (isConfigMap(peopleStore.currentCompany?.configs)) {
+    return peopleStore.currentCompany.configs;
+  }
+
+  if (isConfigMap(peopleStore.defaultCompany?.configs)) {
+    return peopleStore.defaultCompany.configs;
+  }
+
+  return {};
+};
+
+const resolveDefaultCompanyId = () => {
+  const stores = getAllStores();
+  const peopleStore = stores?.people?.getters || {};
+
+  return normalizeEntityId(
+    peopleStore.defaultCompany?.id || peopleStore.defaultCompany?.['@id'],
+  );
+};
+
+const loadTechnicalCieloConfig = async () => {
+  const defaultCompanyId = resolveDefaultCompanyId();
+
+  if (!defaultCompanyId) {
+    return DEFAULT_CIELO_CONFIG;
+  }
+
+  if (
+    technicalCieloConfigCompanyId === defaultCompanyId &&
+    hasRequiredCieloConfig(technicalCieloConfigCache)
+  ) {
+    return technicalCieloConfigCache;
+  }
+
+  if (technicalCieloConfigPromise) {
+    return technicalCieloConfigPromise;
+  }
+
+  technicalCieloConfigPromise = api
+    .fetch('/configs', {
+      params: {
+        configKey: 'CIELO',
+        people: '/people/' + defaultCompanyId,
+        visibility: 'private',
+      },
+    })
+    .then(response => {
+      const item = extractCollectionItems(response)[0];
+      technicalCieloConfigCompanyId = defaultCompanyId;
+      technicalCieloConfigCache = resolveCieloConfig(
+        item?.configKey ? {[item.configKey]: item?.configValue} : {},
+      );
+
+      return technicalCieloConfigCache;
+    })
+    .catch(() => DEFAULT_CIELO_CONFIG)
+    .finally(() => {
+      technicalCieloConfigPromise = null;
+    });
+
+  return technicalCieloConfigPromise;
+};
+
+const resolveRuntimeCieloConfig = async () => {
+  const runtimeConfig = resolveCieloConfig(resolveRuntimeCompanyConfigs());
+  const technicalConfig = hasRequiredCieloConfig(runtimeConfig)
+    ? DEFAULT_CIELO_CONFIG
+    : await loadTechnicalCieloConfig();
+
+  return {
+    ACCESS_TOKEN:
+      runtimeConfig.ACCESS_TOKEN ||
+      technicalConfig.ACCESS_TOKEN ||
+      env?.CIELO?.ACCESS_TOKEN ||
+      '',
+    CLIENT_ID:
+      runtimeConfig.CLIENT_ID ||
+      technicalConfig.CLIENT_ID ||
+      env?.CIELO?.CLIENT_ID ||
+      '',
+    EMAIL: runtimeConfig.EMAIL || technicalConfig.EMAIL || env?.CIELO?.EMAIL || '',
+    MERCHANT_CODE:
+      runtimeConfig.MERCHANT_CODE ||
+      technicalConfig.MERCHANT_CODE ||
+      env?.CIELO?.MERCHANT_CODE ||
+      '',
+  };
+};
+
+class CieloService {
+  async payment(paymentCode, items, orderPrice) {
+    const cieloConfig = await resolveRuntimeCieloConfig();
+
+    if (
+      !cieloConfig.ACCESS_TOKEN ||
+      !cieloConfig.CLIENT_ID ||
+      !cieloConfig.EMAIL
+    ) {
+      throw new Error('Configuracao da Cielo incompleta.');
+    }
+
+    const json = {
+      accessToken: cieloConfig.ACCESS_TOKEN,
+      clientID: cieloConfig.CLIENT_ID,
+      email: cieloConfig.EMAIL,
+      installments: 0,
+      items: items,
+      paymentCode: paymentCode,
+      value: orderPrice,
+    };
+
+    if (cieloConfig.MERCHANT_CODE) {
+      json.merchantCode = cieloConfig.MERCHANT_CODE;
+    }
+
+    const response = await Cielo.payment(JSON.stringify(json));
+
+    const result = response.success
+      ? JSON.parse(response.result)
+      : response.result;
+    const hasValidMerchantCode = hasExpectedMerchantCode(
+      result,
+      cieloConfig.MERCHANT_CODE,
+    );
+
+    return {
+      success: response.success && hasValidMerchantCode,
+      code: response.code,
+      result: hasValidMerchantCode
+        ? result
+        : 'Pagamento processado em estabelecimento Cielo diferente do configurado.',
+    };
+  }
+}
+
+export default CieloService;

package/src/react/services/Cielo/Print.js

@@ -0,0 +1,7 @@
+import Cielo from '@controleonline-rn/react-native-cielo-payment';
+
+export class CieloPrint {
+  async print(printRequest) {
+    return await Cielo.print(printRequest);
+  }
+}

package/src/react/services/InfinitePay/Checkout.js

@@ -0,0 +1,33 @@
+import InfinitePayService from './InfinitePay';
+
+export const runInfinitePayCheckoutPayment = async ({
+  installments = null,
+  order = null,
+  payment = null,
+  total = 0,
+}) => {
+  const resolvedTotal = Number(total || 0);
+
+  if (!payment?.paymentCode) {
+    throw new Error('Meio de pagamento sem codigo de gateway.');
+  }
+
+  if (resolvedTotal <= 0) {
+    throw new Error('Informe um valor de pagamento valido.');
+  }
+
+  const response = await new InfinitePayService().payment(
+    payment.paymentCode,
+    installments || payment.installments || 1,
+    order?.['@id'] || order?.id || '',
+    Math.round(resolvedTotal * 100).toString(),
+  );
+
+  return {
+    paidAmount:
+      Number(response?.result?.paidAmount || 0) > 0
+        ? Number(response.result.paidAmount) / 100
+        : resolvedTotal,
+    response,
+  };
+};

package/src/react/services/InfinitePay/InfinitePay.js

@@ -0,0 +1,24 @@
+import InfinitePay from '@controleonline-rn/react-native-infinitepay-payment';
+
+class InfinitePayService {
+  async payment(paymentMethod, installments, orderId, amount) {
+    const json = {
+      amount: amount,
+      payment_method: paymentMethod,
+      installments: installments,
+      order_id: orderId,
+      app_client_referrer: 'ControleOnline',
+      af_force_deeplink: 'true',
+    };
+
+    const response = await InfinitePay.payment(JSON.stringify(json));
+
+    return {
+      success: response.success,
+      code: response.code,
+      result: response.success ? JSON.parse(response.result) : response.result,
+    };
+  }
+}
+
+export default InfinitePayService;

package/src/react/{utils → services}/paymentGatewayExecution.js

@@ -1,91 +1,91 @@
-import {runCieloCheckoutPayment} from '@controleonline/ui-orders/src/react/services/Cielo/Checkout';
-import {runInfinitePayCheckoutPayment} from '@controleonline/ui-orders/src/react/services/InfinitePay/Checkout';
-
-import {
-  PAYMENT_GATEWAY_CIELO,
-  PAYMENT_GATEWAY_INFINITE_PAY,
-} from './paymentDevices';
-
-export const normalizeGatewayPaymentError = (
-  error,
-  fallback = 'Nao foi possivel concluir o pagamento.',
-) => {
-  if (typeof error === 'string' && error.trim()) {
-    return error;
-  }
-
-  if (typeof error?.message === 'string' && error.message.trim()) {
-    return error.message;
-  }
-
-  if (typeof error?.result === 'string' && error.result.trim()) {
-    return error.result;
-  }
-
-  if (typeof error?.error === 'string' && error.error.trim()) {
-    return error.error;
-  }
-
-  try {
-    const serialized = JSON.stringify(error);
-    return serialized && serialized !== '{}' ? serialized : fallback;
-  } catch {
-    return fallback;
-  }
-};
-
-export const runConfiguredGatewayPayment = async ({
-  gateway = '',
-  installments = null,
-  order = null,
-  orderProducts = [],
-  payment = null,
-  total = 0,
-}) => {
-  const resolvedTotal = Number(total || 0);
-
-  if (!payment?.paymentCode) {
-    throw new Error('Meio de pagamento sem codigo de gateway.');
-  }
-
-  if (resolvedTotal <= 0) {
-    throw new Error('Informe um valor de pagamento valido.');
-  }
-
-  if (gateway === PAYMENT_GATEWAY_CIELO) {
-    const {response, paidAmount} = await runCieloCheckoutPayment({
-      orderProducts,
-      payment,
-      total: resolvedTotal,
-    });
-
-    if (!response?.success) {
-      throw new Error(normalizeGatewayPaymentError(response?.result));
-    }
-
-    return {
-      paidAmount,
-      response,
-    };
-  }
-
-  if (gateway === PAYMENT_GATEWAY_INFINITE_PAY) {
-    const {response, paidAmount} = await runInfinitePayCheckoutPayment({
-      installments,
-      order,
-      payment,
-      total: resolvedTotal,
-    });
-
-    if (!response?.success || response?.code === 1 || response?.code === 2) {
-      throw response;
-    }
-
-    return {
-      paidAmount,
-      response,
-    };
-  }
-
-  throw new Error('Gateway de pagamento indisponível neste equipamento.');
-};
+import {runCieloCheckoutPayment} from './Cielo/Checkout';
+import {runInfinitePayCheckoutPayment} from './InfinitePay/Checkout';
+
+import {
+  PAYMENT_GATEWAY_CIELO,
+  PAYMENT_GATEWAY_INFINITE_PAY,
+} from '../utils/paymentDevices';
+
+export const normalizeGatewayPaymentError = (
+  error,
+  fallback = 'Nao foi possivel concluir o pagamento.',
+) => {
+  if (typeof error === 'string' && error.trim()) {
+    return error;
+  }
+
+  if (typeof error?.message === 'string' && error.message.trim()) {
+    return error.message;
+  }
+
+  if (typeof error?.result === 'string' && error.result.trim()) {
+    return error.result;
+  }
+
+  if (typeof error?.error === 'string' && error.error.trim()) {
+    return error.error;
+  }
+
+  try {
+    const serialized = JSON.stringify(error);
+    return serialized && serialized !== '{}' ? serialized : fallback;
+  } catch {
+    return fallback;
+  }
+};
+
+export const runConfiguredGatewayPayment = async ({
+  gateway = '',
+  installments = null,
+  order = null,
+  orderProducts = [],
+  payment = null,
+  total = 0,
+}) => {
+  const resolvedTotal = Number(total || 0);
+
+  if (!payment?.paymentCode) {
+    throw new Error('Meio de pagamento sem codigo de gateway.');
+  }
+
+  if (resolvedTotal <= 0) {
+    throw new Error('Informe um valor de pagamento valido.');
+  }
+
+  if (gateway === PAYMENT_GATEWAY_CIELO) {
+    const {response, paidAmount} = await runCieloCheckoutPayment({
+      orderProducts,
+      payment,
+      total: resolvedTotal,
+    });
+
+    if (!response?.success) {
+      throw new Error(normalizeGatewayPaymentError(response?.result));
+    }
+
+    return {
+      paidAmount,
+      response,
+    };
+  }
+
+  if (gateway === PAYMENT_GATEWAY_INFINITE_PAY) {
+    const {response, paidAmount} = await runInfinitePayCheckoutPayment({
+      installments,
+      order,
+      payment,
+      total: resolvedTotal,
+    });
+
+    if (!response?.success || response?.code === 1 || response?.code === 2) {
+      throw response;
+    }
+
+    return {
+      paidAmount,
+      response,
+    };
+  }
+
+  throw new Error('Gateway de pagamento indisponível neste equipamento.');
+};

package/src/react/styles/global.js

@@ -0,0 +1,115 @@
+import {StyleSheet} from 'react-native';
+import {useStore} from '@store';
+
+const css = () => {
+  const themeStore = useStore('theme');
+  const getters = themeStore.getters;
+  const {colors} = getters;
+
+  return StyleSheet.create({
+    container: {
+      flex: 1,
+      backgroundColor: '#f4f4f4',
+      paddingTop: 20,
+      paddingHorizontal: 20,
+    },
+    loadingContainer: {
+      flex: 1,
+      justifyContent: 'center',
+      alignItems: 'center',
+    },
+    button: {
+      padding: 11,
+      justifyContent: 'center',
+      alignItems: 'center',
+      marginHorizontal: 5,
+      flex: 1,
+      color: '#fff',
+      backgroundColor: colors['primary'],
+      flexDirection: 'row',
+    },
+    btnText: {
+      color: '#fff',
+      fontSize: 16,
+      fontWeight: 'bold',
+    },
+    primary: {
+      backgroundColor: colors['primary'],
+      color: '#000000',
+    },
+    state: {
+      container: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        padding: 20,
+      },
+      displayContainer: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        paddingVertical: 24,
+        paddingHorizontal: 20,
+      },
+      compactContainer: {
+        width: '100%',
+        justifyContent: 'center',
+        alignItems: 'center',
+        paddingVertical: 12,
+        paddingHorizontal: 16,
+      },
+      content: {
+        width: '100%',
+        maxWidth: 520,
+        gap: 8,
+        padding: 20,
+        backgroundColor: '#fff',
+        borderRadius: 10,
+        elevation: 5,
+      },
+      displayContent: {
+        width: '100%',
+        maxWidth: 640,
+        gap: 10,
+        paddingVertical: 24,
+        paddingHorizontal: 22,
+        backgroundColor: '#fff',
+        borderRadius: 16,
+        borderWidth: 1,
+        borderColor: '#E2E8F0',
+        elevation: 8,
+      },
+      compactContent: {
+        width: '100%',
+        gap: 8,
+        paddingVertical: 12,
+        paddingHorizontal: 16,
+        alignItems: 'center',
+        justifyContent: 'center',
+      },
+      loadingContainer: {
+        alignItems: 'center',
+        justifyContent: 'center',
+      },
+      errorContainer: {
+        justifyContent: 'center',
+        alignItems: 'center',
+        padding: 20,
+        backgroundColor: '#fff',
+        borderRadius: 10,
+        elevation: 5,
+      },
+      messageText: {
+        color: '#475569',
+        textAlign: 'center',
+      },
+      errorText: {
+        color: '#000',
+        textAlign: 'center',
+        fontWeight: '700',
+      },
+    },
+  });
+};
+
+export default css;

package/src/react/utils/categoryContexts.js

@@ -0,0 +1,46 @@
+const DOCUMENT_CATEGORY_CONTEXTS = {
+  proposal: 'proposal-category',
+  contract: 'contract-category',
+  email: 'email-category',
+  menu: 'menu-category',
+};
+
+export const normalizeCategoryContext = value => String(value || '').trim();
+
+export const getCategoryContextForDocument = documentContext => {
+  const normalizedContext = normalizeCategoryContext(documentContext);
+  if (!normalizedContext) {
+    return '';
+  }
+
+  return DOCUMENT_CATEGORY_CONTEXTS[normalizedContext] || `${normalizedContext}-category`;
+};
+
+export const getCategoryContextCandidates = documentContext => {
+  const normalizedContext = normalizeCategoryContext(documentContext);
+  if (!normalizedContext) {
+    return [];
+  }
+
+  const preferredContext = getCategoryContextForDocument(normalizedContext);
+  const legacyContext = `${normalizedContext}-model`;
+
+  if (preferredContext === legacyContext) {
+    return [preferredContext];
+  }
+
+  return [preferredContext, legacyContext];
+};
+
+export const humanizeCategoryContext = value => {
+  const normalizedContext = normalizeCategoryContext(value);
+  if (!normalizedContext) {
+    return 'Sem contexto';
+  }
+
+  return normalizedContext
+    .split(/[-_]+/)
+    .filter(Boolean)
+    .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+};