@controleonline/ui-common 1.2.79 → 1.2.81

package/src/react/pages/IntegrationConfigPage.utils.js

@@ -0,0 +1,95 @@
+import { Linking, Platform } from 'react-native';
+
+export const ROUTE_PROVIDER_MAP = {
+  UberIntegrationPage: 'uber',
+  AsaasIntegrationPage: 'asaas',
+  ClickSignIntegrationPage: 'clicksign',
+  ReceitaFederalIntegrationPage: 'receita-federal',
+};
+
+export const routeNameToPath = routeName =>
+  String(routeName || '').replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+
+export const normalizeTextValue = value => {
+  let text = String(value ?? '').trim();
+  if (
+    (text.startsWith('"') && text.endsWith('"') && text.length >= 2) ||
+    (text.startsWith("'") && text.endsWith("'") && text.length >= 2)
+  ) {
+    text = text.slice(1, -1).trim();
+  }
+  return text;
+};
+
+export const formatApiError = error => {
+  if (!error) return 'Nao foi possivel carregar a configuracao da integracao.';
+  if (typeof error === 'string') return error;
+  return error?.message || error?.description || error?.errmsg || 'Nao foi possivel carregar a configuracao da integracao.';
+};
+
+export const getConfigFields = providerConfig => {
+  if (!providerConfig) return [];
+  if (Array.isArray(providerConfig.tabs) && providerConfig.tabs.length > 0) {
+    return providerConfig.tabs.flatMap(tab => tab.fields || []);
+  }
+  return providerConfig.fields || [];
+};
+
+export const buildFieldValues = (providerConfig, source) => {
+  const sourceMap = Array.isArray(source)
+    ? source.reduce((acc, item) => {
+        const key = String(item?.configKey || '').trim();
+        if (key) acc[key] = item?.configValue;
+        return acc;
+      }, {})
+    : source && typeof source === 'object' ? source : {};
+
+  return getConfigFields(providerConfig).reduce((acc, field) => {
+    acc[field.key] = normalizeTextValue(sourceMap[field.key]);
+    return acc;
+  }, {});
+};
+
+export const resolveProviderId = ({ route, currentCompany }) => {
+  const routeCompanyId = String(route?.params?.companyId || '').replace(/\D/g, '');
+  if (routeCompanyId) return Number(routeCompanyId);
+
+  const currentCompanyId = String(currentCompany?.id || '').replace(/\D/g, '');
+  return currentCompanyId ? Number(currentCompanyId) : null;
+};
+
+export const resolveFallbackConfigs = ({ providerId, currentCompany }) =>
+  Number(providerId) === Number(currentCompany?.id) ? currentCompany?.configs || {} : {};
+
+export const isConnectedValue = value =>
+  value === true || value === 1 || value === '1' || String(value).trim().toLowerCase() === 'true';
+
+export const toConfigRequestValue = value => {
+  if (value === undefined || value === null) return '';
+  if (typeof value === 'string') return normalizeTextValue(value);
+  if (typeof value === 'object') return JSON.stringify(value);
+  return String(value);
+};
+
+export const extractAuthorizationUrl = response => normalizeTextValue(
+  response?.member?.[0]?.authorization_url || response?.member?.[0]?.auth_url ||
+  response?.member?.[0]?.url || response?.authorization_url || response?.auth_url ||
+  response?.url || response?.data?.authorization_url || response?.data?.auth_url || response?.data?.url,
+);
+
+export const formatUberOAuthError = error => {
+  const normalized = normalizeTextValue(error).toLowerCase();
+  if (normalized === 'invalid_scope') {
+    return 'O Uber nao liberou o scope pos_provisioning para este app. Esse app precisa estar aprovado/whitelisted no dashboard do Uber.';
+  }
+  if (normalized === 'access_denied') return 'O login do Uber foi cancelado.';
+  return normalizeTextValue(error) || 'Nao foi possivel concluir a conexao com o Uber.';
+};
+
+export const openAuthorizationUrl = async authUrl => {
+  if (Platform.OS === 'web' && typeof window !== 'undefined' && typeof window.location?.assign === 'function') {
+    window.location.assign(authUrl);
+    return;
+  }
+  await Linking.openURL(authUrl);
+};

package/src/react/print/usePrintButtonController.js

@@ -28,6 +28,7 @@ import {
   resolvePrinterSelectionValue,
   resolveSelectedPrinter,
 } from '@controleonline/ui-common/src/react/print/selection';
+import {resolvePrintRoutingError} from '@controleonline/ui-common/src/react/utils/printRouting';
 
 const resolveCurrentItemId = storeGetters =>
   storeGetters?.item?.['@id']
@@ -396,7 +397,14 @@ export const usePrintButtonController = ({
         return;
       }
 
-      setError(global.t?.t('orders', 'title', 'selectPrinter') || 'Selecione a impressora.');
+      setError(
+        resolvePrintRoutingError({
+          targetDeviceId: selectedPrinter?.device,
+          selectedPrinter,
+        }) ||
+          global.t?.t('orders', 'title', 'selectPrinter') ||
+          'Selecione a impressora.',
+      );
       return;
     }
 

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

@@ -0,0 +1,81 @@
+import GetnetService from './Getnet';
+
+/**
+ * Map wallet paymentCode / paymentType label to Getnet deeplink paymentType.
+ */
+export const resolveGetnetPaymentType = payment => {
+  const raw = String(
+    payment?.paymentCode ||
+      payment?.paymentType?.paymentType ||
+      payment?.paymentType?.name ||
+      payment?.type ||
+      '',
+  )
+    .trim()
+    .toLowerCase();
+
+  if (!raw) return 'credit';
+
+  if (raw.includes('pix')) return 'pix';
+  if (raw.includes('debit') || raw.includes('debito') || raw.includes('débito')) {
+    return 'debit';
+  }
+  if (raw.includes('voucher') || raw.includes('vr') || raw.includes('va')) {
+    return 'voucher';
+  }
+  if (raw.includes('credit') || raw.includes('credito') || raw.includes('crédito')) {
+    return 'credit';
+  }
+
+  return 'credit';
+};
+
+export const runGetnetCheckoutPayment = async ({
+  installments = null,
+  order = null,
+  payment = null,
+  total = 0,
+}) => {
+  const resolvedTotal = Number(total || 0);
+
+  if (resolvedTotal <= 0) {
+    throw new Error('Informe um valor de pagamento valido.');
+  }
+
+  const orderId =
+    order?.id ||
+    String(order?.['@id'] || '')
+      .split('/')
+      .pop() ||
+    '';
+
+  const callerId = `getnet-${orderId || 'order'}-${Date.now()}`;
+  const paymentType = resolveGetnetPaymentType(payment);
+  const resolvedInstallments =
+    Number(installments || payment?.installments || 1) || 1;
+
+  const response = await new GetnetService().payment({
+    amount: resolvedTotal,
+    paymentType,
+    callerId,
+    installments: resolvedInstallments,
+    orderId: orderId ? String(orderId) : undefined,
+    allowPrintCurrentTransaction: true,
+  });
+
+  if (!response?.success) {
+    const detail =
+      response?.result?.resultDetails ||
+      response?.result?.result ||
+      response?.code ||
+      'Pagamento Getnet nao aprovado.';
+    throw new Error(
+      typeof detail === 'string' ? detail : JSON.stringify(detail),
+    );
+  }
+
+  return {
+    paidAmount: resolvedTotal,
+    response,
+  };
+};

package/src/react/services/Getnet/Getnet.js

@@ -0,0 +1,77 @@
+import Getnet from '@controleonline/react-native-getnet-payment';
+
+/**
+ * Thin adapter over the native Getnet POS deeplink module.
+ * paymentType: credit | debit | voucher | pix
+ */
+class GetnetService {
+  async payment({
+    amount,
+    paymentType = 'credit',
+    callerId,
+    installments = 1,
+    creditType,
+    allowPrintCurrentTransaction = true,
+    orderId,
+  }) {
+    if (!callerId) {
+      throw new Error('callerId is required for Getnet payment.');
+    }
+
+    const resolvedAmount = Number(amount || 0);
+    if (resolvedAmount <= 0) {
+      throw new Error('Informe um valor de pagamento valido.');
+    }
+
+    const params = {
+      amount: resolvedAmount,
+      paymentType: String(paymentType || 'credit').toLowerCase(),
+      callerId: String(callerId),
+      installments: Number(installments) > 0 ? Number(installments) : 1,
+      allowPrintCurrentTransaction: Boolean(allowPrintCurrentTransaction),
+    };
+
+    if (params.installments > 1 && creditType) {
+      params.creditType = creditType;
+    }
+
+    if (orderId) {
+      params.orderId = String(orderId);
+    }
+
+    const response = await Getnet.payment(params);
+
+    return {
+      success: Boolean(response?.success),
+      code: response?.result ?? response?.code ?? '',
+      result: response,
+      authorizationCode: response?.authorizationCode,
+      nsu: response?.nsu,
+      cvNumber: response?.cvNumber,
+    };
+  }
+
+  async refund({amount, cvNumber, transactionDate, originTerminal}) {
+    const response = await Getnet.refund({
+      amount: Number(amount || 0),
+      cvNumber,
+      transactionDate,
+      originTerminal,
+    });
+
+    return {
+      success: Boolean(response?.success),
+      result: response,
+    };
+  }
+
+  async reprint() {
+    return Getnet.reprint();
+  }
+
+  async checkStatus(callerId) {
+    return Getnet.checkStatus(callerId);
+  }
+}
+
+export default GetnetService;

package/src/react/services/paymentGatewayExecution.js

@@ -1,9 +1,11 @@
 import {runCieloCheckoutPayment} from './Cielo/Checkout';
 import {runInfinitePayCheckoutPayment} from './InfinitePay/Checkout';
+import {runGetnetCheckoutPayment} from './Getnet/Checkout';
 
 import {
   PAYMENT_GATEWAY_CIELO,
   PAYMENT_GATEWAY_INFINITE_PAY,
+  PAYMENT_GATEWAY_GETNET,
 } from '../utils/paymentDevices';
 
 export const normalizeGatewayPaymentError = (
@@ -87,5 +89,23 @@ export const runConfiguredGatewayPayment = async ({
     };
   }
 
+  if (gateway === PAYMENT_GATEWAY_GETNET) {
+    const {response, paidAmount} = await runGetnetCheckoutPayment({
+      installments,
+      order,
+      payment,
+      total: resolvedTotal,
+    });
+
+    if (!response?.success) {
+      throw new Error(normalizeGatewayPaymentError(response?.result));
+    }
+
+    return {
+      paidAmount,
+      response,
+    };
+  }
+
   throw new Error('Gateway de pagamento indisponível neste equipamento.');
 };

package/src/react/utils/bottomNavigationToolbar.js

@@ -0,0 +1,161 @@
+/**
+ * Toolbar bottom-nav helpers: role-aware menus + safe fallback.
+ * Preset is never a permission bypass — only Home/Profile on empty/failed API.
+ * CommonJS so unit tests can run with node --test like runtimeLanguage.
+ */
+
+/** Routes allowed in the controlled fallback (never business routes). */
+const SAFE_TOOLBAR_FALLBACK_ROUTES = Object.freeze([
+  'HomePage',
+  'ProfilePage',
+]);
+
+const SAFE_ROUTE_SET = new Set(SAFE_TOOLBAR_FALLBACK_ROUTES);
+
+const normalizeMenuType = (value, fallback = 'home') => {
+  const normalized = String(value == null ? '' : value)
+    .trim()
+    .toLowerCase();
+  return normalized || fallback;
+};
+
+const filterMenusByType = (menus, menuType) => {
+  const normalizedMenuType =
+    menuType === null || menuType === undefined || String(menuType).trim() === ''
+      ? null
+      : normalizeMenuType(menuType, '');
+
+  const modules = Array.isArray(menus)
+    ? menus.map(module => ({
+        ...module,
+        menus: Array.isArray(module?.menus)
+          ? module.menus.map(menu => ({...menu}))
+          : [],
+      }))
+    : [];
+
+  if (!normalizedMenuType) {
+    return modules;
+  }
+
+  return modules
+    .map(module => ({
+      ...module,
+      menus: module.menus.filter(
+        menu => normalizeMenuType(menu?.menuType, '') === normalizedMenuType,
+      ),
+    }))
+    .filter(module => module.menus.length > 0);
+};
+
+const resolvePresetLabel = (translate, descriptor) => {
+  if (!descriptor || typeof descriptor === 'string') {
+    return descriptor || '';
+  }
+
+  const translated = translate?.(
+    descriptor.store,
+    descriptor.type,
+    descriptor.key,
+  );
+
+  return translated || descriptor.fallback || descriptor.key || '';
+};
+
+/**
+ * Build a minimal safe toolbar module list from a navigation preset.
+ * Only HomePage + ProfilePage are kept so fallback cannot expose unauthorized
+ * business routes (Clientes, Oportunidades, etc.).
+ */
+const buildSafeToolbarFallbackMenus = (
+  preset,
+  menuType = 'toolbar',
+  translate,
+  presetKey = 'safe-toolbar-fallback',
+) => {
+  const items = Array.isArray(preset?.items) ? preset.items : [];
+  const safeItems = items.filter(item => SAFE_ROUTE_SET.has(item?.route));
+
+  if (safeItems.length === 0) {
+    return [];
+  }
+
+  const menus = safeItems.map((item, index) => ({
+    ...item,
+    menuType,
+    sortOrder: Number(item?.sortOrder || (index + 1) * 10),
+    label: resolvePresetLabel(translate, item?.label),
+  }));
+
+  return [
+    {
+      id: presetKey || 'safe-toolbar-fallback',
+      label: preset?.label || '',
+      icon: preset?.icon || '',
+      menus,
+    },
+  ];
+};
+
+/**
+ * Prefer API toolbar menus when present; otherwise safe preset fallback.
+ * Does not use the full business preset as a permission bypass.
+ */
+const resolveToolbarRuntimeMenus = ({
+  apiMenus,
+  preset,
+  presetKey,
+  menuType = 'toolbar',
+  translate,
+} = {}) => {
+  const filtered = filterMenusByType(apiMenus || [], menuType);
+  const hasAuthorizedItems = filtered.some(
+    module => Array.isArray(module?.menus) && module.menus.length > 0,
+  );
+
+  if (hasAuthorizedItems) {
+    return filtered;
+  }
+
+  if (preset) {
+    return buildSafeToolbarFallbackMenus(
+      preset,
+      menuType,
+      translate,
+      presetKey || 'safe-toolbar-fallback',
+    );
+  }
+
+  return [];
+};
+
+/**
+ * Flatten toolbar menus into bottom-nav item shape (route/icon/label/...).
+ */
+const mapRuntimeMenusToNavItems = (runtimeMenus, menuType) =>
+  filterMenusByType(runtimeMenus || [], menuType)
+    .flatMap(module => (Array.isArray(module?.menus) ? module.menus : []))
+    .map(item => ({
+      route: item.route,
+      icon: item.icon || 'circle',
+      label: item.label,
+      menuKey: item.menuKey,
+      routeParams: item.routeParams,
+      menuType: item.menuType || menuType,
+      sortOrder: Number(item?.sortOrder || 0),
+    }))
+    .filter(item => Boolean(item.route))
+    .sort((left, right) => {
+      const orderDiff = left.sortOrder - right.sortOrder;
+      if (orderDiff !== 0) return orderDiff;
+      return String(left.label || left.menuKey || '').localeCompare(
+        String(right.label || right.menuKey || ''),
+      );
+    });
+
+module.exports = {
+  SAFE_TOOLBAR_FALLBACK_ROUTES,
+  buildSafeToolbarFallbackMenus,
+  mapRuntimeMenusToNavItems,
+  resolveToolbarRuntimeMenus,
+};

package/src/react/utils/commercialDocumentOrders.js

@@ -121,21 +121,33 @@ export const fetchOrderProducts = async orderRef => {
   return extractCollectionItems(response);
 };
 
-export const searchCompanyProducts = async ({ companyId, query = '' }) => {
+export const searchCompanyProducts = async ({
+  companyId,
+  query = '',
+  categoryId = null,
+}) => {
   if (!companyId) {
     return [];
   }
 
-  const params = {
-    company: toEntityIri(companyId, 'people'),
-    active: 1,
-    'order[product]': 'ASC',
-  };
+  const params = {
+    company: toEntityIri(companyId, 'people'),
+    active: 1,
+    'order[product]': 'ASC',
+  };
 
   if (String(query || '').trim()) {
     params.product = String(query).trim();
   }
 
+  // ProductCategoryTreeFilter — includes the category and its descendants.
+  // Prefer server-side filter: product payloads do not always embed productCategory
+  // under the product:read serialization group.
+  const normalizedCategoryId = normalizeEntityId(categoryId);
+  if (normalizedCategoryId) {
+    params['productCategory.category'] = normalizedCategoryId;
+  }
+
   const response = await api.fetch('products', { params });
   return extractCollectionItems(response);
 };