@controleonline/ui-customers 1.0.81

package/src/tests/react/components/tabs/franchiseLinksTab.helpers.test.mjs

@@ -0,0 +1,166 @@
+import assert from 'node:assert/strict';
+import {
+  buildAvailableFranchiseOptions,
+  buildFranchiseLinkReadParams,
+  extractEntityId,
+  buildFranchiseLinksFromPeopleLinks,
+  buildFranchiseSavePayload,
+  canManageFranchiseLinks,
+  franchiseLinkTypeLabel,
+  normalizeFranchiseCandidate,
+  normalizeFranchiseLink,
+  normalizeFranchiseLinkType,
+} from '../../../../react/components/tabs/franchiseLinksTab.helpers.js';
+
+assert.deepEqual(buildFranchiseLinkReadParams('/people/11'), {
+  company: '11',
+  linkType: ['franchisee'],
+  itemsPerPage: 100,
+});
+assert.equal('enable' in buildFranchiseLinkReadParams(5), false);
+assert.equal(extractEntityId({id: {'@id': '/people/5'}}), '5');
+assert.equal(extractEntityId('[object Object]'), '');
+
+assert.equal(canManageFranchiseLinks('MANAGER'), true);
+assert.equal(canManageFranchiseLinks('manager'), true);
+assert.equal(canManageFranchiseLinks('SHOP'), false);
+
+assert.equal(normalizeFranchiseLinkType('franchisee'), 'franchisee');
+assert.equal(normalizeFranchiseLinkType('FILIAL'), 'filial');
+assert.equal(normalizeFranchiseLinkType('other'), '');
+
+assert.equal(franchiseLinkTypeLabel('franchisee'), 'Franquia');
+assert.equal(franchiseLinkTypeLabel('filial'), 'Filial');
+
+assert.equal(
+  normalizeFranchiseCandidate({ id: 1, name: 'ACME', peopleType: 'F' }),
+  null,
+);
+assert.deepEqual(
+  normalizeFranchiseCandidate({
+    id: 10,
+    name: 'ACME LTDA',
+    alias: 'acme',
+    peopleType: 'J',
+  }),
+  {
+    id: '10',
+    iri: '/people/10',
+    name: 'ACME LTDA',
+    alias: 'acme',
+    peopleType: 'J',
+  },
+);
+
+const link = normalizeFranchiseLink({
+  id: 5,
+  linkType: 'franchisee',
+  people: { id: 20, name: 'Franquia X', peopleType: 'J' },
+  company: { id: 1 },
+});
+assert.equal(link.linkedId, '20');
+assert.equal(link.linkType, 'franchisee');
+assert.equal(link.linkedName, 'Franquia X');
+
+const payload = buildFranchiseSavePayload({
+  editingLink: null,
+  formData: {
+    linkedIri: '/people/20',
+    linkType: 'filial',
+    comission: '12,5',
+    minimumComission: '250',
+  },
+  companyIri: '/people/1',
+});
+assert.deepEqual(payload, {
+  company: '/people/1',
+  people: '/people/20',
+  linkType: 'filial',
+  comission: 12.5,
+  minimum_comission: 250,
+  enable: true,
+});
+
+assert.equal(
+  buildFranchiseSavePayload({
+    formData: { linkedIri: '', linkType: 'franchisee' },
+    companyIri: '/people/1',
+  }),
+  null,
+);
+
+const fromApi = buildFranchiseLinksFromPeopleLinks(
+  {
+    'hydra:member': [
+      {
+        id: 1,
+        linkType: 'franchisee',
+        company: { id: 100 },
+        people: { id: 200, name: 'F1', peopleType: 'J' },
+      },
+      {
+        id: 2,
+        linkType: 'employee',
+        company: { id: 100 },
+        people: { id: 201, name: 'PF', peopleType: 'F' },
+      },
+      {
+        id: 3,
+        linkType: 'filial',
+        company: { id: 999 },
+        people: { id: 300, name: 'Other', peopleType: 'J' },
+      },
+    ],
+  },
+  { companyId: 100 },
+);
+assert.equal(fromApi.length, 1);
+assert.equal(fromApi[0].id, 1);
+
+const options = buildAvailableFranchiseOptions({
+  candidates: [
+    { id: 1, name: 'A', peopleType: 'J' },
+    { id: 2, name: 'B', peopleType: 'J' },
+  ],
+  linkedItems: [{ linkedId: '1' }],
+  editingLink: null,
+});
+assert.equal(options.length, 1);
+assert.equal(options[0].id, '2');
+
+console.log('franchiseLinksTab.helpers.test.mjs OK');
+
+
+// task-521 regression: API rows with company_id=5 + link_type franchisee must survive
+// build when people is only an id/IRI (staging payload shape).
+const stagingLike = buildFranchiseLinksFromPeopleLinks(
+  {
+    member: [
+      {
+        id: 51,
+        linkType: 'franchisee',
+        company: 5,
+        people: 51,
+        enable: true,
+      },
+      {
+        id: 52,
+        linkType: 'franchisee',
+        company: '/people/5',
+        people: '/people/52',
+        enable: true,
+      },
+      {
+        id: 99,
+        linkType: 'employee',
+        company: 5,
+        people: 7,
+        enable: true,
+      },
+    ],
+  },
+  { companyId: 5 },
+);
+assert.equal(stagingLike.length, 2);
+assert.equal(extractEntityId(stagingLike[0].people), '51');
+assert.equal(extractEntityId(stagingLike[1].people), '52');

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

@@ -0,0 +1,130 @@
+/**
+ * Unit tests for GeneralTab pure helpers and people_link persistence condition.
+ */
+import {
+  normalizeEnable,
+  normalizeLinkType,
+  formatYmdToBr,
+  parseBrDateToYmd,
+  formatDateInput,
+  toPeopleIri,
+  extractId,
+  LINK_TYPE_OPTIONS,
+} from '../../../components/tabs/generalTabHelpers';
+
+describe('generalTabHelpers', () => {
+  describe('normalizeEnable', () => {
+    it('accepts boolean true/false', () => {
+      expect(normalizeEnable(true)).toBe(true);
+      expect(normalizeEnable(false)).toBe(false);
+    });
+    it('accepts numeric 1/0', () => {
+      expect(normalizeEnable(1)).toBe(true);
+      expect(normalizeEnable(0)).toBe(false);
+    });
+    it('accepts string "1"/"true"', () => {
+      expect(normalizeEnable('1')).toBe(true);
+      expect(normalizeEnable('true')).toBe(true);
+      expect(normalizeEnable('0')).toBe(false);
+      expect(normalizeEnable('false')).toBe(false);
+    });
+    it('defaults unknown to false', () => {
+      expect(normalizeEnable(null)).toBe(false);
+      expect(normalizeEnable(undefined)).toBe(false);
+      expect(normalizeEnable('')).toBe(false);
+    });
+  });
+
+  describe('normalizeLinkType', () => {
+    it('keeps known link types', () => {
+      for (const opt of LINK_TYPE_OPTIONS) {
+        expect(normalizeLinkType(opt.value)).toBe(opt.value);
+      }
+    });
+    it('defaults unknown to employee', () => {
+      expect(normalizeLinkType('')).toBe('employee');
+      expect(normalizeLinkType('unknown')).toBe('employee');
+      expect(normalizeLinkType(null)).toBe('employee');
+    });
+    it('is case-insensitive', () => {
+      expect(normalizeLinkType('OWNER')).toBe('owner');
+      expect(normalizeLinkType(' Manager ')).toBe('manager');
+    });
+  });
+
+  describe('date helpers', () => {
+    it('formatYmdToBr converts ISO date', () => {
+      expect(formatYmdToBr('2024-03-15')).toBe('15/03/2024');
+      expect(formatYmdToBr('2024-03-15T10:00:00Z')).toBe('15/03/2024');
+    });
+    it('formatDateInput masks progressive input', () => {
+      expect(formatDateInput('15')).toBe('15');
+      expect(formatDateInput('1503')).toBe('15/03');
+      expect(formatDateInput('15032024')).toBe('15/03/2024');
+    });
+    it('parseBrDateToYmd round-trips valid date', () => {
+      expect(parseBrDateToYmd('15/03/2024')).toBe('2024-03-15');
+    });
+    it('parseBrDateToYmd rejects invalid date', () => {
+      expect(parseBrDateToYmd('32/13/2024')).toBeNull();
+      expect(parseBrDateToYmd('incomplete')).toBeNull();
+    });
+  });
+
+  describe('toPeopleIri / extractId', () => {
+    it('builds IRI from id', () => {
+      expect(toPeopleIri({ id: 42 })).toBe('/people/42');
+    });
+    it('keeps existing @id IRI', () => {
+      expect(toPeopleIri({ '@id': '/people/7' })).toBe('/people/7');
+    });
+    it('extractId strips non-digits', () => {
+      expect(extractId('/people/99')).toBe('99');
+      expect(extractId(null)).toBe('');
+    });
+  });
+
+  describe('people_link persistence condition (task-330)', () => {
+    /**
+     * Mirrors the condition used in GeneralTab handleSaveRegistration:
+     * only call people_link.save when canEditLinkType AND linkType actually changed.
+     * This avoids Method Not Allowed on the GetCollection-only PeopleLink API
+     * when the user only toggles enable/status.
+     */
+    const shouldPersistPeopleLink = ({ canEditLinkType, currentLinkType, originalLinkType }) =>
+      Boolean(
+        canEditLinkType &&
+          normalizeLinkType(currentLinkType) !== normalizeLinkType(originalLinkType),
+      );
+
+    it('does NOT persist when only enable changes (linkType same)', () => {
+      expect(
+        shouldPersistPeopleLink({
+          canEditLinkType: true,
+          currentLinkType: 'employee',
+          originalLinkType: 'employee',
+        }),
+      ).toBe(false);
+    });
+
+    it('persists when linkType actually changes', () => {
+      expect(
+        shouldPersistPeopleLink({
+          canEditLinkType: true,
+          currentLinkType: 'manager',
+          originalLinkType: 'employee',
+        }),
+      ).toBe(true);
+    });
+
+    it('does NOT persist when canEditLinkType is false', () => {
+      expect(
+        shouldPersistPeopleLink({
+          canEditLinkType: false,
+          currentLinkType: 'owner',
+          originalLinkType: 'employee',
+        }),
+      ).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,322 @@
+const React = require('react');
+const renderer = require('react-test-renderer');
+const {jest} = require('@jest/globals');
+
+const {describe, expect, it, beforeEach} = global;
+
+global.IS_REACT_ACT_ENVIRONMENT = true;
+
+const peopleActions = {
+  getMediaTypes: jest.fn(),
+  getPeopleMedia: jest.fn(),
+  savePeopleMedia: jest.fn(),
+  uploadPeopleMedia: jest.fn(),
+  deletePeopleMedia: jest.fn(),
+  setItem: jest.fn(),
+};
+
+const peopleLinkActions = {
+  getItems: jest.fn(),
+};
+
+const messageActions = {
+  showError: jest.fn(),
+  showSuccess: jest.fn(),
+};
+
+jest.mock('@store', () => ({
+  useStore: jest.fn(name => {
+    if (name === 'people') {
+      return {
+        actions: peopleActions,
+        getters: {
+          currentCompany: {id: 12},
+        },
+      };
+    }
+
+    if (name === 'people_link') {
+      return {
+        actions: peopleLinkActions,
+        getters: {},
+      };
+    }
+
+    if (name === 'theme') {
+      return {
+        getters: {
+          colors: {},
+        },
+      };
+    }
+
+    return {actions: {}, getters: {}};
+  }),
+  useStores: jest.fn(() => ({
+    actions: peopleActions,
+    getters: {
+      currentCompany: {id: 12},
+    },
+  })),
+}));
+
+jest.mock('@react-navigation/native', () => ({
+  useNavigation: () => ({
+    push: jest.fn(),
+  }),
+}));
+
+jest.mock('react-native', () => ({
+  ActivityIndicator: props => React.createElement('activityindicator', props, props.children),
+  Alert: {
+    alert: jest.fn(),
+  },
+  Keyboard: {
+    dismiss: jest.fn(),
+  },
+  Platform: {OS: 'web'},
+  ScrollView: props => React.createElement('scrollview', props, props.children),
+  StyleSheet: {
+    create: styles => styles,
+  },
+  Text: props => React.createElement('text', props, props.children),
+  TextInput: props => React.createElement('textinput', props, props.children),
+  TouchableOpacity: props => React.createElement('touchableopacity', props, props.children),
+  View: props => React.createElement('view', props, props.children),
+}));
+
+jest.mock('react-native-vector-icons/Feather', () => props =>
+  React.createElement('icon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('react-native-vector-icons/FontAwesome', () => props =>
+  React.createElement('icon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('react-native-vector-icons/MaterialIcons', () => props =>
+  React.createElement('icon', props, props.children),
+  {virtual: true},
+);
+
+jest.mock('@react-native-picker/picker', () => ({
+  Picker: props => React.createElement('picker', props, props.children),
+}), {virtual: true});
+
+jest.mock('@controleonline/ui-common/src/react/components/AnimatedModal', () => props =>
+  (props.visible ? React.createElement('modal', props, props.children) : null),
+);
+
+jest.mock('@controleonline/ui-common/src/react/components/MessageService', () => ({
+  useMessage: () => messageActions,
+}));
+
+jest.mock('@controleonline/ui-common/src/react/components/UserAvatar', () => props =>
+  React.createElement('avatar', props, props.children),
+);
+
+jest.mock('@controleonline/ui-default/src/react/components/upload/DefaultUpload', () => props =>
+  React.createElement('defaultupload', props, props.children),
+);
+
+jest.mock('@controleonline/ui-default/src/react/components/upload/fileUpload', () => ({
+  extractFileId: value => {
+    if (!value && value !== 0) return null;
+    const raw = typeof value === 'string' ? value : value?.id || value?.['@id'];
+    const match = String(raw || '').match(/(\d+)$/);
+    return match ? parseInt(match[1], 10) : null;
+  },
+}));
+
+jest.mock('@controleonline/ui-common/src/react/utils/fileUrl', () => ({
+  resolveFileImageUrl: () => 'https://example.test/file.png',
+}));
+
+const SalesmanTab =
+  require('@controleonline/ui-customers/src/react/components/tabs/SalesmanTab').default;
+const MediaTab =
+  require('@controleonline/ui-customers/src/react/components/tabs/MediaTab').default;
+const employeesTabModule =
+  require('@controleonline/ui-customers/src/react/components/tabs/EmployeesTab');
+const EmployeesTab = employeesTabModule.default;
+const {
+  formatEmployeeContactMeta,
+  formatEmployeeContactTitle,
+} = employeesTabModule;
+
+const flush = () => new Promise(resolve => setImmediate(resolve));
+
+describe('people media tabs', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('loads company icons through the people store on SalesmanTab', async () => {
+    peopleLinkActions.getItems.mockResolvedValue([
+      {
+        id: 1,
+        linkType: 'sellers-client',
+        people: {id: '/people/12'},
+        company: {id: '/people/55', name: 'Companhia 55'},
+      },
+    ]);
+    peopleActions.getPeopleMedia.mockResolvedValue([
+      {
+        id: 9,
+        file: {id: 91, fileName: 'icon.png'},
+      },
+    ]);
+
+    await renderer.act(async () => {
+      renderer.create(
+        React.createElement(SalesmanTab, {
+          client: {id: 12},
+          customStyles: {
+            tabContent: {},
+            section: {},
+            loadingIndicator: {color: '#000'},
+            emptyText: {},
+            listItem: {},
+            listItemWithEndAction: {},
+            itemContent: {},
+            listAvatarBrand: {backgroundColor: '#fff', borderColor: '#ddd'},
+            listAvatarText: {color: '#000'},
+            listAvatar: {},
+            itemText: {},
+            itemSubtext: {},
+            iconButtonGhost: {},
+            iconButtonGhostIcon: {color: '#000'},
+          },
+          linkType: 'sellers-client',
+          emptyText: 'empty',
+          errorText: 'error',
+        }),
+      );
+      await flush();
+    });
+
+    expect(peopleActions.getPeopleMedia).toHaveBeenCalledWith({
+      people: '/people/55',
+      'mediaType.type': 'icon',
+      itemsPerPage: 1,
+    });
+  });
+
+  it('loads avatars through the people store on EmployeesTab', async () => {
+    peopleLinkActions.getItems.mockResolvedValue([
+      {
+        id: 2,
+        linkType: 'employee',
+        people: {id: '/people/77', peopleType: 'F'},
+        company: {id: '/people/12'},
+      },
+    ]);
+    peopleActions.getPeopleMedia.mockResolvedValue([
+      {
+        id: 10,
+        file: {id: 101, fileName: 'avatar.png'},
+      },
+    ]);
+
+    await renderer.act(async () => {
+      renderer.create(
+        React.createElement(EmployeesTab, {
+          client: {id: 12},
+          customStyles: {
+            tabContent: {},
+            section: {},
+            sectionHeader: {},
+            sectionTitle: {},
+            iconButtonPrimary: {},
+            iconButtonPrimaryIcon: {color: '#000'},
+            loadingIndicator: {color: '#000'},
+            emptyText: {},
+            txt_title_emptyText: {},
+            listItem: {},
+            listItemWithEndAction: {},
+            itemContent: {},
+            listAvatarBrand: {backgroundColor: '#fff', borderColor: '#ddd'},
+            listAvatarText: {color: '#000'},
+            listAvatar: {},
+            itemText: {},
+            itemSubtext: {},
+            iconButtonGhost: {},
+            iconButtonGhostIcon: {color: '#000'},
+            saveButton: {},
+            saveButtonDisabled: {},
+            saveButtonText: {color: '#000'},
+          },
+        }),
+      );
+      await flush();
+    });
+
+    expect(peopleActions.getPeopleMedia).toHaveBeenCalledWith({
+      people: '/people/77',
+      'mediaType.type': 'avatar',
+      itemsPerPage: 1,
+    });
+  });
+
+  it('formats contact rows as name alias and id link type', () => {
+    const contact = {
+      id: '/people/77',
+      name: 'Maria Silva',
+      alias: 'Mari',
+      linkType: 'employee',
+      peopleLink: {
+        linkType: 'owner',
+      },
+    };
+
+    expect(formatEmployeeContactTitle(contact)).toBe('MARIA SILVA / MARI');
+    expect(formatEmployeeContactMeta(contact)).toBe('ID: 77 / owner');
+  });
+
+  it('uses the generic upload flow before saving client JPG/PNG media', async () => {
+    peopleActions.getMediaTypes.mockResolvedValue([
+      {
+        id: 12,
+        '@id': '/media_types/12',
+        type: 'icon',
+        peopleType: 'J',
+      },
+    ]);
+    peopleActions.getPeopleMedia.mockResolvedValue([]);
+    peopleActions.savePeopleMedia.mockResolvedValue({id: 130});
+
+    let tree;
+
+    await renderer.act(async () => {
+      tree = renderer.create(
+        React.createElement(MediaTab, {
+          client: {
+            id: 11,
+            '@id': '/people/11',
+            peopleType: 'J',
+          },
+        }),
+      );
+      await flush();
+    });
+
+    const upload = tree.root.findByType('defaultupload');
+
+    expect(upload.props.acceptedTypes).toBe('image/png,image/jpeg,.png,.jpg,.jpeg');
+    expect(upload.props.onUploadFile).toBeUndefined();
+    expect(upload.props.uploadResultAlreadyAttached).toBeUndefined();
+
+    await renderer.act(async () => {
+      await upload.props.onAttachFile({id: 77, name: 'cliente.jpg'});
+    });
+
+    expect(peopleActions.savePeopleMedia).toHaveBeenCalledWith({
+      id: undefined,
+      people: '/people/11',
+      mediaType: '/media_types/12',
+      file: '/files/77',
+    });
+    expect(peopleActions.uploadPeopleMedia).not.toHaveBeenCalled();
+  });
+});

package/src/tests/react/components/tabs/salesmanTab.helpers.test.mjs

@@ -0,0 +1,75 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import {
+  buildAvailableSalesmanOptions,
+  buildSalesmanSavePayload,
+  canManageSalesmen,
+  formatCommissionLabel,
+  normalizeCommissionValue,
+  normalizeSalesmanLink,
+  toPeopleIri,
+} from '../../../../react/components/tabs/salesmanTab.helpers.js';
+
+describe('salesmanTab.helpers', () => {
+  it('gates management to MANAGER app type only', () => {
+    assert.equal(canManageSalesmen('MANAGER'), true);
+    assert.equal(canManageSalesmen('manager'), true);
+    assert.equal(canManageSalesmen('CRM'), false);
+    assert.equal(canManageSalesmen(''), false);
+  });
+
+  it('normalizes commission values and labels', () => {
+    assert.equal(normalizeCommissionValue('12,5'), 12.5);
+    assert.equal(normalizeCommissionValue('abc'), 0);
+    assert.equal(formatCommissionLabel(10), '10,00%');
+  });
+
+  it('builds people IRI and normalizes links', () => {
+    assert.equal(toPeopleIri({ id: 7 }), '/people/7');
+    assert.equal(toPeopleIri('/people/9'), '/people/9');
+    const link = normalizeSalesmanLink({
+      id: 3,
+      company: { id: 11, name: 'Ana' },
+      comission: '5',
+      minimum_comission: '1',
+    });
+    assert.equal(link.sellerId, '11');
+    assert.equal(link.commission, 5);
+    assert.equal(link.minimumCommission, 1);
+  });
+
+  it('filters already linked salesmen from options', () => {
+    const options = buildAvailableSalesmanOptions({
+      salesmen: [
+        { id: 1, name: 'A' },
+        { id: 2, name: 'B' },
+      ],
+      linkedSalesmen: [{ sellerId: '1' }],
+      editingLink: null,
+    });
+    assert.equal(options.length, 1);
+    assert.equal(options[0].id, '2');
+  });
+
+  it('builds save payload for create and update', () => {
+    const created = buildSalesmanSavePayload({
+      editingLink: null,
+      formData: { sellerIri: '/people/5', commission: '8', minimumCommission: '2' },
+      clientIri: '/people/20',
+      linkType: 'sellers-client',
+    });
+    assert.equal(created.company, '/people/5');
+    assert.equal(created.people, '/people/20');
+    assert.equal(created.comission, 8);
+    assert.equal(created.minimum_comission, 2);
+    assert.equal(created.id, undefined);
+
+    const updated = buildSalesmanSavePayload({
+      editingLink: { id: '99' },
+      formData: { sellerIri: '/people/5', commission: '8', minimumCommission: '2' },
+      clientIri: '/people/20',
+      linkType: 'sellers-client',
+    });
+    assert.equal(updated.id, '99');
+  });
+});