@controleonline/ui-default 1.0.269 → 1.0.272

package/src/react/services/addressGeo.js

@@ -0,0 +1,227 @@
+import {api} from '@controleonline/ui-common/src/api';
+
+const onlyDigits = value => String(value || '').replace(/\D+/g, '');
+
+const hasText = value => String(value || '').trim().length > 0;
+
+export function isValidCoord(value) {
+  if (value === null || value === undefined || value === '') {
+    return false;
+  }
+  const n = Number(value);
+  return Number.isFinite(n) && Math.abs(n) > 0.000001;
+}
+
+export function isPostalLookupIncomplete(data) {
+  if (!data || typeof data !== 'object') {
+    return true;
+  }
+  const missingText = !hasText(data.street) || !hasText(data.city);
+  const missingCoords =
+    !isValidCoord(data.latitude ?? data?.map?.latitude) ||
+    !isValidCoord(data.longitude ?? data?.map?.longitude);
+  return missingText || missingCoords;
+}
+
+export function mergePostalLookupPayload(base, extra, providerSuffix) {
+  const src = extra && typeof extra === 'object' ? extra : {};
+  const next = {...(base && typeof base === 'object' ? base : {})};
+  const fill = (key, value) => {
+    if (!hasText(next[key]) && hasText(value)) {
+      next[key] = value;
+    }
+  };
+  fill('street', src.street);
+  fill('district', src.district);
+  fill('city', src.city);
+  fill('state', src.state || src.uf);
+  fill('uf', src.uf || src.state);
+  fill('country', src.country);
+  if (!isValidCoord(next.latitude) && isValidCoord(src.latitude)) {
+    next.latitude = Number(src.latitude);
+  }
+  if (!isValidCoord(next.longitude) && isValidCoord(src.longitude)) {
+    next.longitude = Number(src.longitude);
+  }
+  if (providerSuffix) {
+    const current = String(next.provider || '').trim();
+    next.provider = current
+      ? `${current}+${providerSuffix}`
+      : providerSuffix;
+  }
+  return next;
+}
+
+function mapViaCepPayload(json, digits) {
+  if (!json || json.erro) {
+    return null;
+  }
+  return {
+    cep: digits,
+    street: json.logradouro || '',
+    district: json.bairro || '',
+    city: json.localidade || '',
+    state: json.uf || '',
+    uf: json.uf || '',
+    country: 'Brasil',
+    provider: 'viacep-client',
+  };
+}
+
+export async function lookupViaCep(cep) {
+  const digits = onlyDigits(cep);
+  if (digits.length !== 8) {
+    throw new Error('CEP deve ter 8 dígitos');
+  }
+  const response = await fetch(`https://viacep.com.br/ws/${digits}/json/`);
+  if (!response.ok) {
+    throw new Error(`ViaCEP HTTP ${response.status}`);
+  }
+  const json = await response.json();
+  const mapped = mapViaCepPayload(json, digits);
+  if (!mapped) {
+    throw new Error('CEP não encontrado');
+  }
+  return mapped;
+}
+
+function buildNominatimQuery(data, digits) {
+  const cepFormatted =
+    digits.length === 8 ? `${digits.slice(0, 5)}-${digits.slice(5)}` : digits;
+  return [
+    data?.street,
+    data?.district,
+    data?.city,
+    data?.uf || data?.state,
+    cepFormatted,
+    'Brasil',
+  ]
+    .map(part => String(part || '').trim())
+    .filter(Boolean)
+    .join(', ');
+}
+
+export async function lookupNominatimCoords(data, digits) {
+  const q = buildNominatimQuery(data, digits);
+  if (!q) {
+    return null;
+  }
+  const url = `https://nominatim.openstreetmap.org/search?format=json&limit=1&q=${encodeURIComponent(q)}`;
+  const response = await fetch(url, {
+    headers: {
+      Accept: 'application/json',
+      'User-Agent': 'ControleOnline-ui-default/task-637',
+    },
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const rows = await response.json();
+  if (!Array.isArray(rows) || !rows[0]?.lat || !rows[0]?.lon) {
+    return null;
+  }
+  return {
+    latitude: Number(rows[0].lat),
+    longitude: Number(rows[0].lon),
+    formatted: rows[0].display_name || null,
+    provider: 'nominatim-client',
+  };
+}
+
+export async function lookupPostalCode(cep) {
+  const digits = onlyDigits(cep);
+  if (digits.length !== 8) {
+    throw new Error('CEP deve ter 8 dígitos');
+  }
+
+  let payload = {cep: digits};
+  let apiError = null;
+
+  try {
+    const apiData = await api.fetch(`postal-codes/${digits}`, {method: 'GET'});
+    if (apiData && typeof apiData === 'object') {
+      payload = {...payload, ...apiData, cep: digits};
+    }
+  } catch (e) {
+    apiError = e;
+  }
+
+  if (!hasText(payload.street) || !hasText(payload.city)) {
+    try {
+      const viaCep = await lookupViaCep(digits);
+      payload = mergePostalLookupPayload(payload, viaCep, viaCep.provider);
+    } catch (e) {
+      if (apiError && isPostalLookupIncomplete(payload)) {
+        throw new Error(
+          e?.message ||
+            apiError?.message ||
+            apiError?.response?.data?.detail ||
+            'CEP inválido ou serviço indisponível',
+        );
+      }
+    }
+  }
+
+  if (
+    !isValidCoord(payload.latitude ?? payload?.map?.latitude) ||
+    !isValidCoord(payload.longitude ?? payload?.map?.longitude)
+  ) {
+    try {
+      const geo = await lookupNominatimCoords(payload, digits);
+      if (geo) {
+        payload = mergePostalLookupPayload(payload, geo, geo.provider);
+      }
+    } catch {
+      // coords optional if text fields already filled
+    }
+  }
+
+  if (isPostalLookupIncomplete(payload) && apiError && !hasText(payload.street)) {
+    throw new Error(
+      apiError?.message ||
+        apiError?.response?.data?.detail ||
+        'CEP inválido ou serviço indisponível',
+    );
+  }
+
+  return payload;
+}
+
+export async function listCountries(q = '') {
+  const params = q ? {q} : {};
+  const data = await api.fetch('address-geo/countries', {method: 'GET', params});
+  return Array.isArray(data?.member) ? data.member : [];
+}
+
+export async function listStates(country = 'BR') {
+  const data = await api.fetch('address-geo/states', {
+    method: 'GET',
+    params: {country},
+  });
+  return Array.isArray(data?.member) ? data.member : [];
+}
+
+export function buildAddressSavePayload(form, peopleIri) {
+  const payload = {
+    street: form.street || '',
+    city: form.city || '',
+    district: form.district || '',
+    state: form.uf || form.state || '',
+    country: form.countryCode || form.country || 'BR',
+    people: peopleIri,
+    number: form.number ?? '',
+    complement: form.complement || '',
+    nickname: form.nickname || '',
+    cep: onlyDigits(form.cep),
+    latitude: form.latitude ?? 0,
+    longitude: form.longitude ?? 0,
+  };
+
+  if (Array.isArray(form.categories)) {
+    payload.categories = form.categories;
+  } else if (Array.isArray(form.category)) {
+    payload.category = form.category;
+  }
+
+  return payload;
+}

package/src/react/utils/tableVisibleColumnsPreferences.js

@@ -18,6 +18,7 @@ const normalizePreferenceSegment = value =>
     .replace(/-+/g, '-');
 
 export const resolveDefaultTablePreferenceScope = ({
+  companyId = '',
   preferenceKey = '',
   route = null,
   storeName = '',
@@ -30,11 +31,13 @@ export const resolveDefaultTablePreferenceScope = ({
     'unknown-route';
 
   /*
-   * @agents DefaultTable preferences are saved as [store][route].
-   * The same store can back different screens, so filters, sort, view mode,
-   * and column visibility must never be keyed only by store or only by route.
+   * @agents DefaultTable preferences are saved as [company][store][route].
+   * The same store can back different screens, and the same user can switch
+   * companies, so filters, sort, view mode, and column visibility must be
+   * keyed by company, store and route together.
    */
   return {
+    companyKey: normalizePreferenceSegment(companyId),
     routeKey: routeName,
     storeKey: normalizePreferenceSegment(storeName) || 'unknown-store',
   };
@@ -45,10 +48,13 @@ const normalizePreferenceScope = scope => {
     return null;
   }
 
+  const companyKey = normalizePreferenceSegment(scope.companyKey);
   const storeKey = normalizePreferenceSegment(scope.storeKey);
   const routeKey = normalizePreferenceSegment(scope.routeKey);
 
-  return storeKey && routeKey ? {storeKey, routeKey} : null;
+  return companyKey && storeKey && routeKey
+    ? {companyKey, storeKey, routeKey}
+    : null;
 };
 
 const readStoredPreferences = () => {
@@ -86,7 +92,10 @@ const readScopedPreference = scope => {
   }
 
   const storedPreferences = readStoredPreferences();
-  const storePreferences = storedPreferences[resolvedScope.storeKey];
+  const companyPreferences = storedPreferences[resolvedScope.companyKey];
+  const storePreferences = isPlainObject(companyPreferences)
+    ? companyPreferences[resolvedScope.storeKey]
+    : null;
   const routePreferences = isPlainObject(storePreferences)
     ? storePreferences[resolvedScope.routeKey]
     : null;
@@ -101,8 +110,13 @@ const writeScopedPreference = (scope, nextValues = {}) => {
   }
 
   const storedPreferences = readStoredPreferences();
-  const storePreferences = isPlainObject(storedPreferences[resolvedScope.storeKey])
-    ? storedPreferences[resolvedScope.storeKey]
+  const companyPreferences = isPlainObject(
+    storedPreferences[resolvedScope.companyKey],
+  )
+    ? storedPreferences[resolvedScope.companyKey]
+    : {};
+  const storePreferences = isPlainObject(companyPreferences[resolvedScope.storeKey])
+    ? companyPreferences[resolvedScope.storeKey]
     : {};
   const routePreferences = isPlainObject(storePreferences[resolvedScope.routeKey])
     ? storePreferences[resolvedScope.routeKey]
@@ -110,11 +124,14 @@ const writeScopedPreference = (scope, nextValues = {}) => {
 
   writeStoredPreferences({
     ...storedPreferences,
-    [resolvedScope.storeKey]: {
-      ...storePreferences,
-      [resolvedScope.routeKey]: {
-        ...routePreferences,
-        ...nextValues,
+    [resolvedScope.companyKey]: {
+      ...companyPreferences,
+      [resolvedScope.storeKey]: {
+        ...storePreferences,
+        [resolvedScope.routeKey]: {
+          ...routePreferences,
+          ...nextValues,
+        },
       },
     },
   });

package/src/tests/react/components/address/defaultAddressHelpers.test.js

@@ -0,0 +1,104 @@
+/**
+ * Unit tests for defaultAddressHelpers (app-community#283).
+ */
+import {
+  emptyForm,
+  hasCoordinates,
+  hydrateFromRow,
+  mergePostalCodeData,
+  onlyDigits,
+  parseOptionalCoordinate,
+  buildMapMarkerPayload,
+} from '../../../../react/components/address/defaultAddressHelpers';
+
+describe('defaultAddressHelpers', () => {
+  test('onlyDigits strips non-digits', () => {
+    expect(onlyDigits('12.345-678')).toBe('12345678');
+    expect(onlyDigits(null)).toBe('');
+  });
+
+  test('parseOptionalCoordinate accepts number and comma decimal', () => {
+    expect(parseOptionalCoordinate('-23.5505')).toBe(-23.5505);
+    expect(parseOptionalCoordinate('-46,6333')).toBeCloseTo(-46.6333);
+    expect(parseOptionalCoordinate('')).toBeNull();
+    expect(parseOptionalCoordinate('abc')).toBeNull();
+  });
+
+  test('hasCoordinates requires both finite values', () => {
+    expect(hasCoordinates({latitude: -23.5, longitude: -46.6})).toBe(true);
+    expect(hasCoordinates({latitude: null, longitude: -46.6})).toBe(false);
+    expect(hasCoordinates(emptyForm)).toBe(false);
+  });
+
+  test('hydrateFromRow maps nested street/district/city/state', () => {
+    const row = {
+      nickname: 'Matriz',
+      number: 100,
+      latitude: -23.5,
+      longitude: -46.6,
+      street: {
+        street: 'Av Paulista',
+        cep: {cep: '01310100'},
+        district: {
+          district: 'Bela Vista',
+          city: {
+            city: 'São Paulo',
+            state: {
+              uf: 'SP',
+              state: 'São Paulo',
+              country: {countrycode: 'BR', countryname: 'Brazil'},
+            },
+          },
+        },
+      },
+    };
+    const form = hydrateFromRow(row);
+    expect(form.street).toBe('Av Paulista');
+    expect(form.district).toBe('Bela Vista');
+    expect(form.city).toBe('São Paulo');
+    expect(form.uf).toBe('SP');
+    expect(form.cep).toBe('01310100');
+    expect(form.latitude).toBe(-23.5);
+    expect(form.longitude).toBe(-46.6);
+  });
+
+  test('mergePostalCodeData fills lat/long from provider payload', () => {
+    const prev = {...emptyForm, street: 'Rua A'};
+    const data = {
+      cep: '01310100',
+      street: 'Av Paulista',
+      city: 'São Paulo',
+      uf: 'SP',
+      country: 'Brasil',
+      latitude: -23.561,
+      longitude: -46.656,
+      map: {staticUrl: 'https://example.com/map'},
+      provider: 'googlemaps',
+    };
+    const next = mergePostalCodeData(prev, data);
+    expect(next.latitude).toBe(-23.561);
+    expect(next.longitude).toBe(-46.656);
+    expect(next.provider).toBe('googlemaps');
+    expect(next.mapStaticUrl).toBe('https://example.com/map');
+    expect(next.countryCode).toBe('BR');
+  });
+
+  test('buildMapMarkerPayload returns null without address or coords', () => {
+    expect(buildMapMarkerPayload(emptyForm)).toBeNull();
+  });
+
+  test('buildMapMarkerPayload includes coords when present', () => {
+    const payload = buildMapMarkerPayload({
+      ...emptyForm,
+      street: 'Av Paulista',
+      number: '1000',
+      city: 'São Paulo',
+      uf: 'SP',
+      latitude: -23.5,
+      longitude: -46.6,
+    });
+    expect(payload).not.toBeNull();
+    expect(payload.latitude).toBe(-23.5);
+    expect(payload.longitude).toBe(-46.6);
+  });
+});

package/src/tests/react/components/files/DefaultFile.test.js

@@ -35,7 +35,7 @@ describe('DefaultFile', () => {
     jest.clearAllTimers();
   });
 
-  it('renders backend download files with app-domain query and headers', () => {
+  it('renders backend download files with path app-domain and headers', () => {
     let tree;
 
     renderer.act(() => {
@@ -58,11 +58,11 @@ describe('DefaultFile', () => {
 
     const image = tree.root.findByType('image');
 
-    expect(image.props.source).toEqual({
-      uri: 'https://api.controleonline.com/files/3/download?app-domain=maincompany.controleonline.com',
-      headers: {
-        Authorization: 'Bearer token',
-        'app-domain': 'maincompany.controleonline.com',
+    expect(image.props.source).toEqual({
+      uri: 'https://api.controleonline.com/maincompany.controleonline.com/files/3/download',
+      headers: {
+        Authorization: 'Bearer token',
+        'app-domain': 'maincompany.controleonline.com',
       },
     });
     expect(image.props.resizeMode).toBe('contain');

package/src/tests/react/components/form/DefaultForm.test.js

@@ -78,4 +78,127 @@ describe('DefaultForm', () => {
     const inputAfterTyping = capturedInputs[capturedInputs.length - 1];
     expect(inputAfterTyping.value).toBe('Cliente desistiu');
   });
+
+  it('saves hidden create payload columns with row and default values', async () => {
+    const save = jest.fn(() => Promise.resolve({id: 10}));
+    const columns = [
+      {
+        name: 'price',
+        label: 'value',
+      },
+      {
+        name: 'receiver',
+        createPayload: true,
+        visibleForm: false,
+        saveFormat: value => `/people/${value}`,
+      },
+      {
+        name: 'invoiceType',
+        createPayload: true,
+        defaultValue: 'invoice',
+        visibleForm: false,
+      },
+    ];
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        React.createElement(DefaultForm, {
+          actions: {save},
+          columns,
+          mode: 'create',
+          row: {receiver: 21},
+          storeName: 'invoice',
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      capturedInputs[capturedInputs.length - 1].onChangeValue('123.45');
+    });
+
+    const saveButton = tree.root.findAllByType('TouchableOpacity')[1];
+
+    await renderer.act(async () => {
+      await saveButton.props.onPress();
+    });
+
+    expect(save).toHaveBeenCalledWith({
+      price: 123.45,
+      receiver: '/people/21',
+      invoiceType: 'invoice',
+    });
+  });
+
+  it('preserves primitive ids for hidden create payload list columns', async () => {
+    const save = jest.fn(() => Promise.resolve({id: 11}));
+    const columns = [
+      {
+        name: 'price',
+      },
+      {
+        name: 'receiver',
+        createPayload: true,
+        list: 'people/getItems',
+        visibleForm: false,
+        formatList: value => {
+          if (!value || typeof value !== 'object') {
+            return {value, label: String(value || '')};
+          }
+
+          return {value: value.id, label: value.name};
+        },
+        saveFormat: value => `/people/${value?.value || value}`,
+      },
+    ];
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        React.createElement(DefaultForm, {
+          actions: {save},
+          columns,
+          mode: 'create',
+          row: {receiver: 21},
+          storeName: 'invoice',
+        }),
+      );
+    });
+
+    await renderer.act(async () => {
+      capturedInputs[capturedInputs.length - 1].onChangeValue('1.23');
+    });
+
+    await renderer.act(async () => {
+      await tree.root.findAllByType('TouchableOpacity')[1].props.onPress();
+    });
+
+    expect(save).toHaveBeenCalledWith({
+      price: 1.23,
+      receiver: '/people/21',
+    });
+  });
+
+  it('uses explicit form labels before translated column fallbacks', async () => {
+    const columns = [
+      {
+        name: 'paymentType',
+        label: 'paymentType.paymentType',
+        formLabel: 'Tipo de pagamento',
+      },
+    ];
+
+    await renderer.act(async () => {
+      renderer.create(
+        React.createElement(DefaultForm, {
+          actions: {save: jest.fn()},
+          columns,
+          mode: 'create',
+          storeName: 'invoice',
+        }),
+      );
+    });
+
+    expect(capturedInputs[capturedInputs.length - 1].label).toBe('Tipo de pagamento');
+  });
 });