@controleonline/ui-customers 1.0.81 → 1.0.83

package/src/tests/react/components/tabs/documentsTabHelpers.test.mjs

@@ -0,0 +1,93 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import {
+  applyDocumentMask,
+  extractId,
+  isImageFile,
+  isPdfFile,
+  normalizeDocumentFiles,
+  removeMask,
+  toDocumentIri,
+  toFileIri,
+  toDocumentItem,
+  unwrapUploadFile,
+} from '../../../../react/components/tabs/documentsTabHelpers.js';
+
+test('extractId resolves numeric, string and IRI values', () => {
+  assert.equal(extractId(12), '12');
+  assert.equal(extractId('/documents/45'), '45');
+  assert.equal(extractId({ '@id': '/files/9', id: 9 }), '9');
+  assert.equal(extractId(null), '');
+});
+
+test('applyDocumentMask formats CPF and CNPJ', () => {
+  assert.equal(applyDocumentMask('12345678901', 'CPF'), '123.456.789-01');
+  assert.equal(applyDocumentMask('12345678000199', 'CNPJ'), '12.345.678/0001-99');
+});
+
+test('removeMask strips non-digits', () => {
+  assert.equal(removeMask('12.345.678/0001-99'), '12345678000199');
+});
+
+test('file type helpers detect image and pdf urls', () => {
+  assert.equal(isImageFile('https://cdn.example/file.PNG'), true);
+  assert.equal(isPdfFile('https://cdn.example/doc.pdf'), true);
+  assert.equal(isPdfFile('https://cdn.example/doc.png'), false);
+});
+
+test('IRI helpers build resource paths', () => {
+  assert.equal(toDocumentIri(15), '/documents/15');
+  assert.equal(toFileIri({ id: 3 }), '/files/3');
+  assert.equal(toFileIri('/files/8'), '/files/8');
+});
+
+test('normalizeDocumentFiles prefers documentFiles collection over legacy file', () => {
+  const resolveUrl = file => file?.url || '';
+  const document = {
+    id: 1,
+    document: '123',
+    documentType: { '@id': '/document_types/1', documentType: 'CNPJ' },
+    file: { id: 99, url: 'https://cdn.example/legacy.pdf' },
+    documentFiles: [
+      {
+        id: 10,
+        file: { id: 20, name: 'cartao-cnpj.png', url: 'https://cdn.example/cartao.png' },
+      },
+      {
+        id: 11,
+        file: { id: 21, name: 'contrato.pdf', url: 'https://cdn.example/contrato.pdf' },
+      },
+    ],
+  };
+
+  const files = normalizeDocumentFiles(document, resolveUrl);
+  assert.equal(files.length, 2);
+  assert.equal(files[0].name, 'cartao-cnpj.png');
+  assert.equal(files[1].name, 'contrato.pdf');
+  assert.equal(files[0].legacy, false);
+
+  const legacyOnly = normalizeDocumentFiles(
+    { file: { id: 5, name: 'rg.jpg', url: 'https://cdn.example/rg.jpg' } },
+    resolveUrl,
+  );
+  assert.equal(legacyOnly.length, 1);
+  assert.equal(legacyOnly[0].legacy, true);
+});
+
+test('toDocumentItem maps API payload', () => {
+  const item = toDocumentItem({
+    '@id': '/documents/7',
+    id: 7,
+    document: '999',
+    documentType: { '@id': '/document_types/2' },
+  });
+  assert.equal(item.id, '7');
+  assert.equal(item.value, '999');
+  assert.equal(item.type, '/document_types/2');
+});
+
+test('unwrapUploadFile accepts hydra and nested shapes', () => {
+  assert.deepEqual(unwrapUploadFile({ file: { id: 1 } }), { id: 1 });
+  assert.deepEqual(unwrapUploadFile({ 'hydra:member': [{ id: 2 }] }), { id: 2 });
+  assert.deepEqual(unwrapUploadFile({ member: [{ id: 3 }] }), { id: 3 });
+});

package/src/tests/react/components/tabs/employeeContacts.test.js

@@ -7,6 +7,7 @@ const {
   extractPeopleLinkItems,
   filterPeopleLinksByScope,
   normalizeEmployeeLinkType,
+  EMPLOYEE_CONTACT_LINK_TYPES,
 } = require('../../../../react/components/tabs/employeeContacts')
 
 describe('employeeContacts', () => {
@@ -21,9 +22,23 @@ describe('employeeContacts', () => {
   it('normalizes supported link types and falls back to employee', () => {
     expect(normalizeEmployeeLinkType('OWNER')).toBe('owner')
     expect(normalizeEmployeeLinkType('courier')).toBe('courier')
+    expect(normalizeEmployeeLinkType('salesman')).toBe('salesman')
+    expect(normalizeEmployeeLinkType('after-sales')).toBe('after-sales')
     expect(normalizeEmployeeLinkType('unknown')).toBe('employee')
   })
 
+  it('exports the same catalog used by create and edit pickers', () => {
+    expect(EMPLOYEE_CONTACT_LINK_TYPES).toEqual([
+      'employee',
+      'owner',
+      'director',
+      'manager',
+      'salesman',
+      'after-sales',
+      'courier',
+    ])
+  })
+
   it('builds numeric relationship filters for collection reads', () => {
     expect(
       buildPeopleLinkReadParams({
@@ -38,16 +53,16 @@ describe('employeeContacts', () => {
     })
   })
 
-  it('accepts linkTypes allowlist and itemsPerPage for contact reads (#636)', () => {
+  it('accepts linkTypes allowlist and itemsPerPage for contact reads (#636/#649)', () => {
     expect(
       buildPeopleLinkReadParams({
         companyId: 3,
-        linkTypes: ['employee', 'owner', 'director', 'manager', 'courier'],
+        linkTypes: EMPLOYEE_CONTACT_LINK_TYPES,
         itemsPerPage: 100,
       }),
     ).toEqual({
       company: '3',
-      linkType: ['employee', 'owner', 'director', 'manager', 'courier'],
+      linkType: EMPLOYEE_CONTACT_LINK_TYPES,
       itemsPerPage: 100,
     })
   })
@@ -84,13 +99,40 @@ describe('employeeContacts', () => {
         peopleLink: expect.objectContaining({id: 3229}),
       }),
       expect.objectContaining({
-        id: '7',
+        id: 7,
         linkType: 'owner',
         name: 'Owner',
       }),
     ])
   })
 
+  it('keeps salesman and after-sales contacts in the company list (#649)', () => {
+    expect(
+      buildEmployeeContactsFromPeopleLinks(
+        {
+          member: [
+            {
+              id: 80,
+              linkType: 'salesman',
+              company: {id: 3},
+              people: {id: 81, name: 'Vendedor', peopleType: 'F'},
+            },
+            {
+              id: 82,
+              linkType: 'after-sales',
+              company: {id: 3},
+              people: {id: 83, name: 'Pos Venda', peopleType: 'F'},
+            },
+          ],
+        },
+        {parentPeopleId: '3'},
+      ),
+    ).toEqual([
+      expect.objectContaining({id: 81, linkType: 'salesman'}),
+      expect.objectContaining({id: 83, linkType: 'after-sales'}),
+    ])
+  })
+
   it('rejects links returned outside the requested relationship scope', () => {
     const requestedLink = {
       id: 11,

package/src/tests/react/components/tabs/employeeLinkTypes.contract.test.mjs

@@ -0,0 +1,52 @@
+/**
+ * Contract: Contatos create/edit share the same human company link-type catalog.
+ * Refs: app-community#446 #648 #649
+ */
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const root = join(dirname(fileURLToPath(import.meta.url)), '../../../../..');
+
+const read = relativePath => readFileSync(join(root, relativePath), 'utf8');
+
+const EXPECTED = [
+  'employee',
+  'owner',
+  'director',
+  'manager',
+  'salesman',
+  'after-sales',
+  'courier',
+];
+
+test('canonical catalog includes every human company link type', () => {
+  const src = read('src/react/utils/humanCompanyLinkTypes.js');
+  for (const type of EXPECTED) {
+    assert.match(src, new RegExp(`['"]${type}['"]`), `missing ${type}`);
+  }
+});
+
+test('create and edit helpers reuse the same catalog module', () => {
+  const createSrc = read('src/react/components/tabs/employeesTabHelpers.js');
+  const editSrc = read('src/react/components/tabs/generalTabHelpers.js');
+  const contactsSrc = read('src/react/components/tabs/employeeContacts.js');
+
+  assert.match(createSrc, /humanCompanyLinkTypes/);
+  assert.match(editSrc, /humanCompanyLinkTypes/);
+  assert.match(contactsSrc, /humanCompanyLinkTypes/);
+  assert.match(createSrc, /LINK_TYPE_OPTIONS/);
+  assert.match(editSrc, /LINK_TYPE_OPTIONS/);
+});
+
+test('employees page default context covers all human company roles', () => {
+  const src = read('src/react/pages/employees.js');
+  assert.match(src, /HUMAN_COMPANY_LINK_TYPES/);
+  assert.match(src, /DEFAULT_EMPLOYEE_CONTEXT_TYPES/);
+  assert.match(src, /salesman/);
+  assert.match(src, /after-sales/);
+  assert.match(src, /Cadastro de Vendedor/);
+  assert.match(src, /Cadastro de Pos-venda/);
+});

package/src/tests/react/components/tabs/employeeUnlink.test.js

@@ -16,9 +16,9 @@ describe('employeeUnlink', () => {
     ).toEqual({peopleId: '80', linkId: '201'});
   });
 
-  it('prefers people.remove and falls back to people_link.remove', async () => {
-    const removePeople = jest.fn().mockResolvedValue(null);
-    const removePeopleLink = jest.fn();
+  it('prefers people_link.remove and falls back to people.remove', async () => {
+    const removePeople = jest.fn();
+    const removePeopleLink = jest.fn().mockResolvedValue(null);
     await expect(
       removeEmployeeFromCompany({
         peopleId: '80',
@@ -26,18 +26,18 @@ describe('employeeUnlink', () => {
         removePeople,
         removePeopleLink,
       }),
-    ).resolves.toEqual({mode: 'people', peopleId: '80', linkId: '201'});
-    expect(removePeople).toHaveBeenCalledWith('80');
-    expect(removePeopleLink).not.toHaveBeenCalled();
+    ).resolves.toEqual({mode: 'link', peopleId: '80', linkId: '201'});
+    expect(removePeopleLink).toHaveBeenCalledWith('201');
+    expect(removePeople).not.toHaveBeenCalled();
 
     await expect(
       removeEmployeeFromCompany({
-        peopleId: '',
-        linkId: '201',
-        removePeople: undefined,
-        removePeopleLink: jest.fn().mockResolvedValue(null),
+        peopleId: '80',
+        linkId: '',
+        removePeople: jest.fn().mockResolvedValue(null),
+        removePeopleLink: undefined,
       }),
-    ).resolves.toMatchObject({mode: 'link', linkId: '201'});
+    ).resolves.toMatchObject({mode: 'people', peopleId: '80'});
   });
 
   it('filters the local list after unlink', () => {

package/src/tests/react/components/tabs/employeesTabHelpers.media.test.js

@@ -8,7 +8,7 @@ jest.mock('@controleonline/ui-common/src/react/utils/fileUrl', () => ({
 }), { virtual: true });
 
 jest.mock('@controleonline/ui-common/src/react/utils/entityDisplay', () => ({
-  formatDisplayUppercase: value => String(value || '').toUpperCase(),
+  normalizeText: value => String(value || '').trim(),
 }), { virtual: true });
 
 describe('fetchPeopleMediaUrls batch', () => {
@@ -36,24 +36,8 @@ describe('fetchPeopleMediaUrls batch', () => {
     });
   });
 
-  it('falls back to per-id calls when batch rejects', async () => {
-    const getPeopleMedia = jest
-      .fn()
-      .mockRejectedValueOnce(new Error('batch unsupported'))
-      .mockResolvedValueOnce([{ people: { id: 1 }, file: { url: 'https://cdn/1.png' } }])
-      .mockResolvedValueOnce([{ people: { id: 2 }, file: { url: 'https://cdn/2.png' } }]);
-
-    const result = await fetchPeopleMediaUrls({
-      peopleActions: { getPeopleMedia },
-      mediaType: 'avatar',
-      peopleIds: [1, 2],
-    });
-
     expect(getPeopleMedia).toHaveBeenCalledTimes(3);
-    expect(result).toEqual({
-      '1': 'https://cdn/1.png',
-      '2': 'https://cdn/2.png',
-    });
+    expect(result).toEqual({ '1': 'https://cdn/1.png' });
   });
 });
 
@@ -70,9 +54,4 @@ describe('extractPeopleMediaUrl from people_links payload', () => {
     });
     expect(url).toBe('https://cdn/avatar.png');
   });
-
-  it('returns empty string when peopleMedia is missing', () => {
-    expect(extractPeopleMediaUrl({ id: 10 })).toBe('');
-    expect(extractPeopleMediaUrl(null)).toBe('');
-  });
 });

package/src/tests/react/components/tabs/employeesTabHelpers.test.js

@@ -8,6 +8,10 @@ import {
   buildEmployeeCreatePayload,
   extractId,
   LINK_TYPE_OPTIONS,
+  PEOPLE_TYPE_OPTIONS,
+  normalizePeopleType,
+  formatPeopleTypeLabel,
+  formatEmployeeContactMeta,
   buildEmployeeDetailNavParams,
 } from '../../../../react/components/tabs/employeesTabHelpers';
 
@@ -37,9 +41,64 @@ describe('employeesTabHelpers', () => {
     expect(payload.peopleType).toBe('F');
   });
 
+  it('buildEmployeeCreatePayload accepts salesman and after-sales (#649)', () => {
+    expect(
+      buildEmployeeCreatePayload({
+        name: 'VEN',
+        alias: 'V',
+        linkType: 'salesman',
+        parentPeopleId: '15',
+      }).linkType,
+    ).toBe('salesman');
+    expect(
+      buildEmployeeCreatePayload({
+        name: 'POS',
+        alias: 'P',
+        linkType: 'after-sales',
+        parentPeopleId: '15',
+      }).linkType,
+    ).toBe('after-sales');
+  });
+
+  it('buildEmployeeCreatePayload accepts peopleType J (PJ)', () => {
+    const payload = buildEmployeeCreatePayload({
+      name: 'EMPRESA X',
+      alias: 'X',
+      linkType: 'employee',
+      parentPeopleId: '15',
+      peopleType: 'J',
+    });
+    expect(payload.peopleType).toBe('J');
+  });
+
+  it('normalizePeopleType only allows F|J', () => {
+    expect(normalizePeopleType('F')).toBe('F');
+    expect(normalizePeopleType('j')).toBe('J');
+    expect(normalizePeopleType('pj')).toBe('J');
+    expect(normalizePeopleType('contrato')).toBe('F');
+    expect(normalizePeopleType('')).toBe('F');
+    expect(PEOPLE_TYPE_OPTIONS.map(o => o.value)).toEqual(['F', 'J']);
+    expect(formatPeopleTypeLabel('J')).toBe('Pessoa Jurídica');
+  });
+
+  it('formatEmployeeContactMeta includes peopleType', () => {
+    expect(
+      formatEmployeeContactMeta({ id: 9, peopleType: 'J', linkType: 'employee' }),
+    ).toContain('Pessoa Jurídica');
+  });
+
   it('extractId and LINK_TYPE_OPTIONS', () => {
     expect(extractId('/people/3')).toBe('3');
     expect(LINK_TYPE_OPTIONS.some(o => o.value === 'employee')).toBe(true);
+    expect(LINK_TYPE_OPTIONS.map(o => o.value)).toEqual([
+      'employee',
+      'owner',
+      'director',
+      'manager',
+      'salesman',
+      'after-sales',
+      'courier',
+    ]);
   });
 
   it('buildEmployeeDetailNavParams opens employee detail on general tab', () => {

package/src/tests/react/components/tabs/generalTabHelpers.test.js

@@ -3,7 +3,11 @@
  */
 import {
   normalizeEnable,
+  normalizeIdentityValue,
   normalizeLinkType,
+  resolveSeededLinkType,
+  normalizePeopleType,
+  PEOPLE_TYPE_OPTIONS,
   formatYmdToBr,
   parseBrDateToYmd,
   formatDateInput,
@@ -13,6 +17,16 @@ import {
 } from '../../../components/tabs/generalTabHelpers';
 
 describe('generalTabHelpers', () => {
+  describe('normalizeIdentityValue', () => {
+    it('preserves mixed case typed by the user', () => {
+      expect(normalizeIdentityValue('Cláudia Silva')).toBe('Cláudia Silva');
+      expect(normalizeIdentityValue('  ACME Ltda  ')).toBe('ACME Ltda');
+      expect(normalizeIdentityValue('kibelicia comida árabe')).toBe('kibelicia comida árabe');
+    });
+    it('collapses internal whitespace without changing case', () => {
+      expect(normalizeIdentityValue('Ana   Maria')).toBe('Ana Maria');
+    });
+  });
   describe('normalizeEnable', () => {
     it('accepts boolean true/false', () => {
       expect(normalizeEnable(true)).toBe(true);
@@ -49,6 +63,8 @@ describe('generalTabHelpers', () => {
     it('is case-insensitive', () => {
       expect(normalizeLinkType('OWNER')).toBe('owner');
       expect(normalizeLinkType(' Manager ')).toBe('manager');
+      expect(normalizeLinkType('SALESMAN')).toBe('salesman');
+      expect(normalizeLinkType(' After-Sales ')).toBe('after-sales');
     });
   });
 
@@ -127,4 +143,23 @@ describe('generalTabHelpers', () => {
       ).toBe(false);
     });
   });
+
+
+  describe('resolveSeededLinkType', () => {
+    it('prefers client.linkType over route seed after save', () => {
+      expect(resolveSeededLinkType('courier', 'owner')).toBe('courier');
+      expect(resolveSeededLinkType('', 'owner')).toBe('owner');
+      expect(resolveSeededLinkType(undefined, 'manager')).toBe('manager');
+    });
+  });
+
+  describe('normalizePeopleType', () => {
+    it('maps only F and J from API enum', () => {
+      expect(normalizePeopleType('F')).toBe('F');
+      expect(normalizePeopleType('J')).toBe('J');
+      expect(normalizePeopleType('juridica')).toBe('J');
+      expect(normalizePeopleType('contrato')).toBe('F');
+      expect(PEOPLE_TYPE_OPTIONS.map(o => o.value)).toEqual(['F', 'J']);
+    });
+  });
 });