@controleonline/ui-customers 1.0.81

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

@@ -0,0 +1,266 @@
+const {describe, expect, it} = global
+
+const {
+  buildEmployeeContactsFromPeopleLinks,
+  buildPeopleLinkReadParams,
+  buildSalesmanLinksFromPeopleLinks,
+  extractPeopleLinkItems,
+  filterPeopleLinksByScope,
+  normalizeEmployeeLinkType,
+} = require('../../../../react/components/tabs/employeeContacts')
+
+describe('employeeContacts', () => {
+  it('reads collection members from hydra payloads', () => {
+    expect(
+      extractPeopleLinkItems({
+        'hydra:member': [{id: 1}],
+      }),
+    ).toEqual([{id: 1}])
+  })
+
+  it('normalizes supported link types and falls back to employee', () => {
+    expect(normalizeEmployeeLinkType('OWNER')).toBe('owner')
+    expect(normalizeEmployeeLinkType('courier')).toBe('courier')
+    expect(normalizeEmployeeLinkType('unknown')).toBe('employee')
+  })
+
+  it('builds numeric relationship filters for collection reads', () => {
+    expect(
+      buildPeopleLinkReadParams({
+        companyId: '/people/29',
+        peopleId: '/people/31',
+        linkType: 'sellers-client',
+      }),
+    ).toEqual({
+      company: '29',
+      people: '31',
+      linkType: ['sellers-client'],
+    })
+  })
+
+  it('accepts linkTypes allowlist and itemsPerPage for contact reads (#636)', () => {
+    expect(
+      buildPeopleLinkReadParams({
+        companyId: 3,
+        linkTypes: ['employee', 'owner', 'director', 'manager', 'courier'],
+        itemsPerPage: 100,
+      }),
+    ).toEqual({
+      company: '3',
+      linkType: ['employee', 'owner', 'director', 'manager', 'courier'],
+      itemsPerPage: 100,
+    })
+  })
+
+  it('maps employee contacts when people is a plain IRI string (#636)', () => {
+    expect(
+      buildEmployeeContactsFromPeopleLinks(
+        {
+          member: [
+            {
+              id: 3229,
+              linkType: 'employee',
+              company: '/people/3',
+              people: '/people/105789',
+            },
+            {
+              id: 7,
+              linkType: 'owner',
+              company: {id: 3},
+              people: {
+                id: 7,
+                name: 'Owner',
+                peopleType: 'F',
+              },
+            },
+          ],
+        },
+        {parentPeopleId: '3'},
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        id: '105789',
+        linkType: 'employee',
+        peopleLink: expect.objectContaining({id: 3229}),
+      }),
+      expect.objectContaining({
+        id: '7',
+        linkType: 'owner',
+        name: 'Owner',
+      }),
+    ])
+  })
+
+  it('rejects links returned outside the requested relationship scope', () => {
+    const requestedLink = {
+      id: 11,
+      company: {id: 29},
+      people: {id: 31},
+      linkType: 'employee',
+    }
+    const unrelatedLink = {
+      id: 12,
+      company: {id: 2},
+      people: {id: 31},
+      linkType: 'employee',
+    }
+
+    expect(
+      filterPeopleLinksByScope([requestedLink, unrelatedLink], {
+        companyId: 29,
+        peopleId: 31,
+        linkTypes: ['employee'],
+      }),
+    ).toEqual([requestedLink])
+  })
+
+  it('keeps only salesman links whose client matches the open details page', () => {
+    const requestedLink = {
+      id: 21,
+      company: {id: 6, name: 'Alexandre'},
+      people: {id: 29},
+      linkType: 'sellers-client',
+    }
+    const unrelatedLink = {
+      id: 22,
+      company: {id: 6, name: 'Alexandre'},
+      people: {id: 11},
+      linkType: 'sellers-client',
+    }
+
+    expect(
+      buildSalesmanLinksFromPeopleLinks([requestedLink, unrelatedLink], {
+        clientId: 29,
+      }),
+    ).toEqual([requestedLink])
+  })
+
+  it('maps people links to physical contacts for the customer details tab', () => {
+    expect(
+      buildEmployeeContactsFromPeopleLinks(
+        {
+          member: [
+            {
+              id: 31,
+              linkType: 'owner',
+              company: {'@id': '/people/31'},
+              people: {
+                id: 30,
+                '@id': '/people/30',
+                name: 'Claudia',
+                alias: 'Claudia',
+                peopleType: 'F',
+              },
+            },
+          {
+            id: 32,
+            linkType: 'employee',
+            company: {'@id': '/people/31'},
+            people: {
+              id: 33,
+              '@id': '/people/33',
+              name: 'Filial',
+              alias: 'Filial',
+              peopleType: 'J',
+            },
+          },
+          {
+            id: 34,
+            linkType: 'courier',
+            company: {'@id': '/people/31'},
+            people: {
+              id: 35,
+              '@id': '/people/35',
+              name: 'Rafael',
+              alias: 'Rafa',
+              peopleType: 'F',
+            },
+          },
+          {
+            id: 36,
+            linkType: 'employee',
+            company: {'@id': '/people/99'},
+            people: {
+              id: 37,
+              '@id': '/people/37',
+              name: 'Contato de outra empresa',
+              alias: 'Outra',
+              peopleType: 'F',
+            },
+          },
+        ],
+      },
+      {parentPeopleId: '31'},
+    ),
+    ).toEqual([
+      expect.objectContaining({
+        id: 30,
+        '@id': '/people/30',
+        name: 'Claudia',
+        alias: 'Claudia',
+        peopleType: 'F',
+        linkType: 'owner',
+        peopleLink: expect.objectContaining({
+          id: 31,
+          linkType: 'owner',
+        }),
+      }),
+      expect.objectContaining({
+        id: 35,
+        '@id': '/people/35',
+        name: 'Rafael',
+        alias: 'Rafa',
+        peopleType: 'F',
+        linkType: 'courier',
+        peopleLink: expect.objectContaining({
+          id: 34,
+          linkType: 'courier',
+        }),
+      }),
+    ])
+  })
+
+  it('filters unsupported link types when an allowlist is provided', () => {
+    expect(
+      buildEmployeeContactsFromPeopleLinks(
+        {
+          member: [
+            {
+              id: 40,
+              linkType: 'employee',
+              company: {'@id': '/people/31'},
+              people: {
+                id: 41,
+                '@id': '/people/41',
+                name: 'Marina',
+                alias: 'Mari',
+                peopleType: 'F',
+              },
+            },
+            {
+              id: 42,
+              linkType: 'client',
+              company: {'@id': '/people/31'},
+              people: {
+                id: 43,
+                '@id': '/people/43',
+                name: 'Visitante',
+                alias: 'Visit',
+                peopleType: 'F',
+              },
+            },
+          ],
+        },
+        {
+          parentPeopleId: '31',
+          allowedLinkTypes: ['employee', 'owner'],
+        },
+      ),
+    ).toEqual([
+      expect.objectContaining({
+        id: 41,
+        linkType: 'employee',
+      }),
+    ])
+  })
+})

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

@@ -0,0 +1,67 @@
+import {
+  extractEmployeeUnlinkIds,
+  filterEmployeesAfterUnlink,
+  removeEmployeeFromCompany,
+  confirmEmployeeRemoval,
+  EMPLOYEE_UNLINK_MESSAGE,
+} from '../../../../react/components/tabs/employeeUnlink';
+
+describe('employeeUnlink', () => {
+  it('extracts people and people_link ids', () => {
+    expect(
+      extractEmployeeUnlinkIds({
+        id: '/people/80',
+        peopleLinkId: '/people_links/201',
+      }),
+    ).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();
+    await expect(
+      removeEmployeeFromCompany({
+        peopleId: '80',
+        linkId: '201',
+        removePeople,
+        removePeopleLink,
+      }),
+    ).resolves.toEqual({mode: 'people', peopleId: '80', linkId: '201'});
+    expect(removePeople).toHaveBeenCalledWith('80');
+    expect(removePeopleLink).not.toHaveBeenCalled();
+
+    await expect(
+      removeEmployeeFromCompany({
+        peopleId: '',
+        linkId: '201',
+        removePeople: undefined,
+        removePeopleLink: jest.fn().mockResolvedValue(null),
+      }),
+    ).resolves.toMatchObject({mode: 'link', linkId: '201'});
+  });
+
+  it('filters the local list after unlink', () => {
+    const next = filterEmployeesAfterUnlink(
+      [
+        {id: 80, peopleLink: {id: 201}},
+        {id: 81, peopleLink: {id: 202}},
+      ],
+      {peopleId: '80', linkId: '201'},
+    );
+    expect(next.map(item => item.id)).toEqual([81]);
+  });
+
+  it('uses MessageService dialog when available', () => {
+    const showDialog = jest.fn();
+    const onConfirm = jest.fn();
+    confirmEmployeeRemoval({showDialog, onConfirm});
+    expect(showDialog).toHaveBeenCalledWith(
+      expect.objectContaining({
+        title: 'Remover colaborador',
+        message: EMPLOYEE_UNLINK_MESSAGE,
+        confirmLabel: 'Remover',
+        onConfirm,
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,78 @@
+import {
+  extractPeopleMediaUrl,
+  fetchPeopleMediaUrls,
+} from '../../../../react/components/tabs/employeesTabHelpers';
+
+jest.mock('@controleonline/ui-common/src/react/utils/fileUrl', () => ({
+  resolveFileImageUrl: file => (file?.url ? file.url : file?.['@id'] || ''),
+}), { virtual: true });
+
+jest.mock('@controleonline/ui-common/src/react/utils/entityDisplay', () => ({
+  formatDisplayUppercase: value => String(value || '').toUpperCase(),
+}), { virtual: true });
+
+describe('fetchPeopleMediaUrls batch', () => {
+  it('issues a single getPeopleMedia call for multiple people ids', async () => {
+    const getPeopleMedia = jest.fn().mockResolvedValue([
+      { people: { '@id': '/people/10' }, file: { url: 'https://cdn/a.png' } },
+      { people: { id: 20 }, file: { url: 'https://cdn/b.png' } },
+    ]);
+
+    const result = await fetchPeopleMediaUrls({
+      peopleActions: { getPeopleMedia },
+      mediaType: 'avatar',
+      peopleIds: [10, '20', '/people/10'],
+    });
+
+    expect(getPeopleMedia).toHaveBeenCalledTimes(1);
+    expect(getPeopleMedia).toHaveBeenCalledWith({
+      people: ['/people/10', '/people/20'],
+      'mediaType.type': 'avatar',
+      itemsPerPage: 2,
+    });
+    expect(result).toEqual({
+      '10': 'https://cdn/a.png',
+      '20': 'https://cdn/b.png',
+    });
+  });
+
+  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',
+    });
+  });
+});
+
+describe('extractPeopleMediaUrl from people_links payload', () => {
+  it('reads avatar file from embedded peopleMedia', () => {
+    const url = extractPeopleMediaUrl({
+      id: 10,
+      peopleMedia: [
+        {
+          mediaType: { type: 'avatar' },
+          file: { id: 99, url: 'https://cdn/avatar.png' },
+        },
+      ],
+    });
+    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

@@ -0,0 +1,64 @@
+/**
+ * Unit tests for EmployeesTab pure helpers (app-community#297 modularization).
+ * Includes navigation contract for employee detail (app-community#9).
+ */
+import {
+  formatDateInput,
+  parseBrDateToYmd,
+  buildEmployeeCreatePayload,
+  extractId,
+  LINK_TYPE_OPTIONS,
+  buildEmployeeDetailNavParams,
+} from '../../../../react/components/tabs/employeesTabHelpers';
+
+describe('employeesTabHelpers', () => {
+  it('formatDateInput masks BR date', () => {
+    expect(formatDateInput('01022020')).toBe('01/02/2020');
+    expect(formatDateInput('01')).toBe('01');
+  });
+
+  it('parseBrDateToYmd validates and converts', () => {
+    expect(parseBrDateToYmd('01/02/2020')).toBe('2020-02-01');
+    expect(parseBrDateToYmd('31/02/2020')).toBeNull();
+    expect(parseBrDateToYmd('1/2/20')).toBeNull();
+  });
+
+  it('buildEmployeeCreatePayload sets company and optional foundationDate', () => {
+    const payload = buildEmployeeCreatePayload({
+      name: 'ANA',
+      alias: 'A',
+      foundationDate: '2020-02-01',
+      linkType: 'manager',
+      parentPeopleId: '15',
+    });
+    expect(payload.company).toBe('/people/15');
+    expect(payload.foundationDate).toBe('2020-02-01');
+    expect(payload.linkType).toBe('manager');
+    expect(payload.peopleType).toBe('F');
+  });
+
+  it('extractId and LINK_TYPE_OPTIONS', () => {
+    expect(extractId('/people/3')).toBe('3');
+    expect(LINK_TYPE_OPTIONS.some(o => o.value === 'employee')).toBe(true);
+  });
+
+  it('buildEmployeeDetailNavParams opens employee detail on general tab', () => {
+    const params = buildEmployeeDetailNavParams({
+      employee: { id: '/people/42', linkType: 'employee' },
+      parentPeopleId: '15',
+    });
+    expect(params).toEqual({
+      clientId: '42',
+      contextKey: 'contacts',
+      initialTab: 'general',
+      parentCompanyId: '15',
+      linkType: 'employee',
+    });
+  });
+
+  it('buildEmployeeDetailNavParams returns null without employee id', () => {
+    expect(
+      buildEmployeeDetailNavParams({ employee: {}, parentPeopleId: '15' }),
+    ).toBeNull();
+  });
+});

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

@@ -0,0 +1,29 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import test from 'node:test';
+
+const fiscalTab = fs.readFileSync(
+  new URL('../../../../react/components/tabs/FiscalTab.js', import.meta.url),
+  'utf8',
+);
+const details = fs.readFileSync(
+  new URL('../../../../react/pages/details.js', import.meta.url),
+  'utf8',
+);
+const helpers = fs.readFileSync(
+  new URL('../../../../react/pages/clientDetailsHelpers.js', import.meta.url),
+  'utf8',
+);
+
+test('company details exposes the fiscal tab for legal entities', () => {
+  assert.match(helpers, /\{ key: 'fiscal', label: label\('fiscal', 'Configurações Fiscais'\) \}/);
+  assert.match(details, /activeTabKey === 'fiscal'/);
+  assert.match(details, /<FiscalTab \{\.\.\.tabProps\} navigation=\{navigation\} \/>/);
+});
+
+test('company fiscal tab delegates the complete fiscal settings to ui-accounting', () => {
+  assert.match(fiscalTab, /@controleonline\/ui-accounting\/src\/react\/components\/fiscal\/FiscalCompanyConfig/);
+  assert.match(fiscalTab, /<FiscalCompanyConfig company=\{client\} navigation=\{navigation\} \/>/);
+  assert.doesNotMatch(fiscalTab, /IntegrationConfigPage/);
+  assert.doesNotMatch(fiscalTab, /providerKey: 'receita-federal'/);
+});

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

@@ -0,0 +1,128 @@
+/**
+ * Unit tests for franchise commission helpers (ui-customers#10).
+ */
+import {
+  isFranchiseeLink,
+  pickFranchiseeLink,
+  canEditFranchiseCommission,
+  buildFranchiseeLinkParams,
+  normalizeCommissionFields,
+  validateCommissionFields,
+  formatPercent,
+  formatMinimum,
+} from '../../../../react/components/tabs/franchiseCommissionHelpers';
+
+describe('franchiseCommissionHelpers', () => {
+  describe('isFranchiseeLink', () => {
+    it('accepts franchisee link matching people and company', () => {
+      const link = {
+        linkType: 'franchisee',
+        people: {id: 11},
+        company: {'@id': '/people/3'},
+      };
+      expect(isFranchiseeLink(link, {peopleId: '11', companyId: '3'})).toBe(true);
+    });
+
+    it('rejects non-franchisee link types', () => {
+      expect(
+        isFranchiseeLink(
+          {linkType: 'client', people: {id: 11}, company: {id: 3}},
+          {peopleId: '11', companyId: '3'},
+        ),
+      ).toBe(false);
+    });
+
+    it('rejects mismatched people id', () => {
+      expect(
+        isFranchiseeLink(
+          {linkType: 'franchisee', people: {id: 99}, company: {id: 3}},
+          {peopleId: '11', companyId: '3'},
+        ),
+      ).toBe(false);
+    });
+  });
+
+  describe('pickFranchiseeLink', () => {
+    it('picks from hydra member payload', () => {
+      const payload = {
+        'hydra:member': [
+          {id: 1, linkType: 'client', people: {id: 11}, company: {id: 3}},
+          {
+            id: 2,
+            linkType: 'franchisee',
+            people: {id: 11},
+            company: {id: 3},
+            comission: 12.5,
+          },
+        ],
+      };
+      const link = pickFranchiseeLink(payload, {peopleId: 11, companyId: 3});
+      expect(link?.id).toBe(2);
+      expect(link?.comission).toBe(12.5);
+    });
+
+    it('returns null when no franchisee link', () => {
+      expect(pickFranchiseeLink([{linkType: 'employee'}], {})).toBe(null);
+    });
+  });
+
+  describe('canEditFranchiseCommission', () => {
+    it('allows ROLE_SUPER', () => {
+      expect(
+        canEditFranchiseCommission({
+          user: {roles: ['ROLE_SUPER']},
+          currentCompany: {user: {owner_enabled: false}},
+        }),
+      ).toBe(true);
+    });
+
+    it('allows franchisor owner', () => {
+      expect(
+        canEditFranchiseCommission({
+          user: {roles: ['ROLE_MANAGER']},
+          currentCompany: {user: {owner_enabled: true}},
+        }),
+      ).toBe(true);
+    });
+
+    it('denies other profiles', () => {
+      expect(
+        canEditFranchiseCommission({
+          user: {roles: ['ROLE_MANAGER']},
+          currentCompany: {user: {owner_enabled: false}},
+        }),
+      ).toBe(false);
+    });
+  });
+
+  describe('buildFranchiseeLinkParams', () => {
+    it('includes linkType franchisee and ids', () => {
+      expect(buildFranchiseeLinkParams({peopleId: '/people/11', companyId: 3})).toEqual({
+        linkType: ['franchisee'],
+        people: '11',
+        company: '3',
+      });
+    });
+  });
+
+  describe('normalizeCommissionFields / validate / format', () => {
+    it('normalizes numeric fields', () => {
+      expect(normalizeCommissionFields({comission: '10', minimum_comission: 2000})).toEqual({
+        comission: 10,
+        minimum_comission: 2000,
+      });
+    });
+
+    it('validates percentage range and minimum >= 0', () => {
+      expect(validateCommissionFields({comission: 10, minimum_comission: 0}).ok).toBe(true);
+      expect(validateCommissionFields({comission: 101, minimum_comission: 0}).ok).toBe(false);
+      expect(validateCommissionFields({comission: 10, minimum_comission: -1}).ok).toBe(false);
+    });
+
+    it('formats display values', () => {
+      expect(formatPercent(12.5)).toBe('12.5%');
+      expect(formatMinimum(2000)).toBe('2000');
+      expect(formatPercent(null)).toBe('—');
+    });
+  });
+});