@controleonline/ui-common 1.2.70

package/src/tests/react/utils/runtimeFooter.test.js

@@ -0,0 +1,429 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+const {jest, test: jestCompatTest} = require('@jest/globals')
+
+jest.mock('@controleonline/ui-common/src/react/utils/printerDevices', () => ({
+  getDeviceTypeLabel: value => String(value || ''),
+}))
+
+const {
+  getRuntimeFooterDebugInfo,
+  getRuntimeFooterNativeIdentifierCandidates,
+  getRuntimeFooterPrimaryText,
+  getRuntimeFooterStoredVersion,
+  getRuntimeFooterWebIdentifierCandidates,
+  getRuntimeFooterWebHost,
+} = require('../../../react/utils/runtimeFooter')
+
+const originalLocationDescriptor = Object.getOwnPropertyDescriptor(globalThis, 'location')
+const originalTranslator = global.t
+const commonOptionTranslations = {
+  counterService: 'Balcão',
+  waiterService: 'Garçom',
+  selfServiceKiosk: 'Totem',
+  singleItemSale: 'Venda única',
+  cashierPOS: 'PDV',
+}
+
+const setLocation = value => {
+  Object.defineProperty(globalThis, 'location', {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value,
+  })
+}
+
+const restoreLocation = () => {
+  if (originalLocationDescriptor) {
+    Object.defineProperty(globalThis, 'location', originalLocationDescriptor)
+    return
+  }
+
+  delete globalThis.location
+}
+
+test.before(() => {
+  global.t = {
+    getMessageFromBuckets: (store, type, key) =>
+      store === 'common' && type === 'option'
+        ? commonOptionTranslations[key] || ''
+        : '',
+  }
+})
+
+test.after(() => {
+  global.t = originalTranslator
+})
+
+test('prefers the persisted public ip for web runtime devices', () => {
+  setLocation({hostname: '10.0.0.15'})
+
+  try {
+    assert.equal(
+      getRuntimeFooterPrimaryText({
+        device: {
+          alias: 'app',
+          appVersion: '1.3.6',
+          deviceType: 'web',
+          id: 'web-12',
+          externalIp: '198.51.100.21',
+          metadata: {
+            network: {
+              publicIp: '198.51.100.21',
+            },
+          },
+        },
+        appVersion: '1.3.6',
+        deviceConfig: {
+          device: {
+            metadata: {
+              network: {
+                publicIp: '203.0.113.42',
+              },
+            },
+          },
+          configs: {
+            'config-version': '1.3.5',
+          },
+        },
+      }),
+      'web (203.0.113.42) / v1.3.6',
+    )
+
+    const debugInfo = getRuntimeFooterDebugInfo({
+      device: {
+        alias: 'app',
+        appVersion: '1.3.6',
+        deviceType: 'web',
+        id: 'web-12',
+        externalIp: '198.51.100.21',
+        metadata: {
+          network: {
+            publicIp: '198.51.100.21',
+          },
+        },
+      },
+      appVersion: '1.3.6',
+      deviceConfig: {
+        device: {
+          metadata: {
+            network: {
+              publicIp: '203.0.113.42',
+            },
+          },
+        },
+        configs: {
+          'config-version': '1.3.5',
+        },
+      },
+    })
+
+    assert.equal(debugInfo.runtimeDetailSource, 'device_config.device.metadata.network.publicIp')
+    assert.equal(debugInfo.rawValues.storedDeviceMetadataPublicIp, '203.0.113.42')
+    assert.equal(debugInfo.rawValues.deviceMetadataPublicIp, '198.51.100.21')
+  } finally {
+    restoreLocation()
+  }
+})
+
+test('normalizes localhost to the loopback address on web', () => {
+  setLocation({hostname: 'localhost'})
+
+  try {
+    assert.equal(getRuntimeFooterWebHost(), '127.0.0.1')
+  } finally {
+    restoreLocation()
+  }
+})
+
+test('falls back to the browser hostname for web when no persisted public ip exists', () => {
+  setLocation({hostname: 'localhost'})
+
+  try {
+    const candidates = getRuntimeFooterWebIdentifierCandidates({
+      device: {
+        deviceType: 'web',
+        id: 'web-12',
+      },
+      deviceConfig: {},
+    })
+
+    assert.equal(candidates[0]?.value, '127.0.0.1')
+    assert.equal(candidates[0]?.source, 'location.hostname')
+  } finally {
+    restoreLocation()
+  }
+})
+
+test('recognizes backend web devices by their persisted runtime metadata or device key', () => {
+  const debugInfo = getRuntimeFooterDebugInfo({
+    device: {
+      device: 'web-12',
+      metadata: {
+        runtime: 'web',
+        network: {
+          publicIp: '198.51.100.21',
+        },
+      },
+    },
+    deviceConfig: {
+      device: {
+        device: 'web-12',
+        metadata: {
+          runtime: 'web',
+          network: {
+            publicIp: '203.0.113.42',
+          },
+        },
+      },
+    },
+  })
+
+  assert.equal(debugInfo.isWebRuntime, true)
+  assert.equal(debugInfo.runtimeDetail, '203.0.113.42')
+  assert.equal(
+    debugInfo.runtimeDetailSource,
+    'device_config.device.metadata.network.publicIp',
+  )
+})
+
+test('reads the persisted config-version for non-web runtimes', () => {
+  assert.equal(
+    getRuntimeFooterStoredVersion({
+      configs: JSON.stringify({
+        'config-version': '1.3.5',
+      }),
+    }),
+    'v1.3.5',
+  )
+
+  assert.equal(
+    getRuntimeFooterPrimaryText({
+      device: {
+        alias: 'PDV',
+        appVersion: '1.3.7',
+        deviceType: 'android',
+        id: 'native-12',
+      },
+      appVersion: '1.3.6',
+      deviceConfig: {
+        device: {
+          device: '229252771069b294',
+        },
+        configs: {
+          'config-version': '1.3.5',
+        },
+      },
+    }),
+    'PDV (229252771069b294) / v1.3.7',
+  )
+})
+
+test('prefers the backend device identifier used by the devices page', () => {
+  assert.equal(
+    getRuntimeFooterPrimaryText({
+      device: {
+        alias: 'PDV',
+        appVersion: '1.3.7',
+        deviceType: 'android',
+        id: 'd41ac8afb9f178eb',
+      },
+      appVersion: '1.3.6',
+      deviceConfig: {
+        device: {
+          device: '229252771069b294',
+          metadata: {
+            app: {
+              version: '1.3.7',
+            },
+          },
+        },
+        configs: {
+          'config-version': '1.3.7',
+        },
+      },
+    }),
+    'PDV (229252771069b294) / v1.3.7',
+  )
+
+  const debugInfo = getRuntimeFooterDebugInfo({
+    device: {
+      alias: 'PDV',
+      appVersion: '1.3.7',
+      deviceType: 'android',
+      id: 'd41ac8afb9f178eb',
+    },
+    appVersion: '1.3.6',
+    deviceConfig: {
+      device: {
+        device: '229252771069b294',
+        metadata: {
+          app: {
+            version: '1.3.7',
+          },
+        },
+      },
+      configs: {
+        'config-version': '1.3.7',
+      },
+    },
+  })
+
+  assert.equal(debugInfo.versionLabel, 'v1.3.7')
+  assert.equal(debugInfo.displayName, 'PDV (229252771069b294)')
+  assert.equal(debugInfo.runtimeDetail, '229252771069b294')
+  assert.equal(debugInfo.runtimeDetailSource, 'device_config.device.device')
+  assert.equal(debugInfo.versionCandidates[0]?.source, 'device_config.device.metadata.app.version')
+  assert.equal(debugInfo.rawValues.deviceId, 'd41ac8afb9f178eb')
+  assert.equal(debugInfo.rawValues.storedDeviceIdentifier, '229252771069b294')
+})
+
+test('shows the PDV operation mode when the runtime device type is available', () => {
+  const params = {
+    device: {
+      alias: 'PDV',
+      appVersion: '1.3.7',
+      deviceType: 'android',
+      id: 'd41ac8afb9f178eb',
+      type: 'PDV',
+    },
+    appVersion: '1.3.6',
+    deviceConfig: {
+      device: {
+        device: '229252771069b294',
+        type: 'PDV',
+        metadata: {
+          app: {
+            version: '1.3.7',
+          },
+        },
+      },
+      configs: {
+        'config-version': '1.3.7',
+        'pos-operation-mode': 'waiter',
+      },
+    },
+  }
+
+  assert.equal(
+    getRuntimeFooterPrimaryText(params),
+    'PDV • Garçom / v1.3.7',
+  )
+
+  const debugInfo = getRuntimeFooterDebugInfo(params)
+
+  assert.equal(debugInfo.displayName, 'PDV • Garçom')
+  assert.equal(debugInfo.runtimeDetail, 'Garçom')
+  assert.equal(
+    debugInfo.runtimeDetailSource,
+    'device_config.configs.pos-operation-mode',
+  )
+  assert.equal(debugInfo.rawValues.operationalType, 'PDV')
+  assert.equal(debugInfo.rawValues.operationMode, 'waiter')
+  assert.equal(debugInfo.rawValues.operationModeLabel, 'Garçom')
+})
+
+test('keeps the device identifier while adding the operation mode to the footer', () => {
+  assert.equal(
+    getRuntimeFooterPrimaryText({
+      device: {
+        alias: 'terminal-7',
+        appVersion: '1.3.7',
+        deviceType: 'android',
+        id: 'd41ac8afb9f178eb',
+        type: 'PDV',
+      },
+      appVersion: '1.3.6',
+      deviceConfig: {
+        device: {
+          device: '229252771069b294',
+          type: 'PDV',
+          metadata: {
+            app: {
+              version: '1.3.7',
+            },
+          },
+        },
+        configs: {
+          'config-version': '1.3.7',
+          'pos-operation-mode': 'totem',
+        },
+      },
+    }),
+    'terminal-7 • PDV • Totem / v1.3.7',
+  )
+})
+
+test('does not invent a fallback label when the operation mode translation is missing', () => {
+  const debugInfo = getRuntimeFooterDebugInfo({
+    device: {
+      alias: 'PDV',
+      appVersion: '1.3.7',
+      deviceType: 'android',
+      id: 'd41ac8afb9f178eb',
+      type: 'PDV',
+    },
+    appVersion: '1.3.6',
+    deviceConfig: {
+      device: {
+        device: '229252771069b294',
+        type: 'PDV',
+        metadata: {
+          app: {
+            version: '1.3.7',
+          },
+        },
+      },
+      configs: {
+        'config-version': '1.3.7',
+        'pos-operation-mode': 'unknown-mode',
+      },
+    },
+  })
+
+  assert.equal(debugInfo.operationModeLabel, '')
+  assert.equal(debugInfo.displayName, 'PDV (229252771069b294)')
+  assert.equal(debugInfo.primaryText, 'PDV (229252771069b294) / v1.3.7')
+})
+
+test('renders totem mode in the runtime footer', () => {
+  assert.equal(
+    getRuntimeFooterPrimaryText({
+      device: {
+        appVersion: '1.3.7',
+        deviceType: 'android',
+        id: 'native-13',
+        type: 'PDV',
+      },
+      appVersion: '1.3.6',
+      deviceConfig: {
+        device: {
+          device: '229252771069b294',
+          type: 'PDV',
+        },
+        configs: {
+          'config-version': '1.3.7',
+          'pos-operation-mode': 'totem',
+        },
+      },
+    }),
+    'android • PDV • Totem / v1.3.7',
+  )
+})
+
+test('falls back to the local device id when the backend identifier is unavailable', () => {
+  const candidates = getRuntimeFooterNativeIdentifierCandidates({
+    device: {
+      id: 'local-device-99',
+    },
+    deviceConfig: {
+      device: {},
+    },
+  })
+
+  assert.equal(candidates[0]?.value, 'local-device-99')
+  assert.equal(candidates[0]?.source, 'device.id')
+})
+
+jestCompatTest('jest compatibility placeholder', () => {})

package/src/tests/react/utils/runtimeLanguage.test.js

@@ -0,0 +1,80 @@
+const assert = require('node:assert/strict')
+const test = require('node:test')
+
+const {
+  normalizeLanguageCode,
+  resolveCompanyLanguageCode,
+  resolveConfiguredLanguage,
+} = require('../../../react/utils/runtimeLanguage')
+
+test('normalizes language separators and casing', () => {
+  assert.equal(normalizeLanguageCode(' PT_BR '), 'pt-br')
+})
+
+test('reads the current company language from nested company settings first', () => {
+  assert.equal(
+    resolveCompanyLanguageCode({
+      language: {
+        locale: 'en_US',
+      },
+    }),
+    'en-us',
+  )
+})
+
+test('prefers the selected company language over cached config and session values', () => {
+  assert.equal(
+    resolveConfiguredLanguage({
+      currentCompany: {
+        language: {
+          code: 'en_US',
+        },
+      },
+      defaultCompany: {
+        language: {
+          code: 'pt_BR',
+        },
+      },
+      currentConfig: {
+        language: 'es-es',
+      },
+      sessionData: {
+        language: 'fr-fr',
+      },
+    }),
+    'en-us',
+  )
+})
+
+test('falls back through default company, config, session and the hardcoded default', () => {
+  assert.equal(
+    resolveConfiguredLanguage({
+      defaultCompany: {
+        configs: {
+          language: 'de_DE',
+        },
+      },
+    }),
+    'de-de',
+  )
+
+  assert.equal(
+    resolveConfiguredLanguage({
+      currentConfig: {
+        language: 'it_IT',
+      },
+    }),
+    'it-it',
+  )
+
+  assert.equal(
+    resolveConfiguredLanguage({
+      sessionData: {
+        language: 'nl_NL',
+      },
+    }),
+    'nl-nl',
+  )
+
+  assert.equal(resolveConfiguredLanguage({}), 'pt-br')
+})

package/src/tests/react/utils/runtimeMenu.test.js

@@ -0,0 +1,174 @@
+/* global describe, expect, it */
+
+import {
+  filterRuntimeMenuModulesByType,
+  flattenRuntimeMenuItemsByType,
+  getRuntimeMenuRoutes,
+  normalizeRuntimeMenuIcon,
+  normalizeRuntimeMenuResponse,
+  userHasRole,
+} from '../../../react/utils/runtimeMenu';
+
+describe('runtimeMenu', () => {
+  it('normalizes legacy menu response modules into sorted arrays', () => {
+    const result = normalizeRuntimeMenuResponse({
+      response: {
+        data: {
+          modules: {
+            2: {
+              id: 2,
+              label: 'Config',
+              menus: [
+                {id: 20, label: 'B', route: 'BRoute', sortOrder: 20, menuType: 'toolbar'},
+                {id: 10, label: 'A', route: 'ARoute', sortOrder: 10},
+              ],
+            },
+          },
+        },
+      },
+    });
+
+    expect(result).toHaveLength(1);
+    expect(result[0].menus.map(item => item.route)).toEqual(['ARoute', 'BRoute']);
+    expect(result[0].menus[0].routeParams).toEqual({});
+    expect(result[0].menus.map(item => item.menuType)).toEqual(['home', 'toolbar']);
+  });
+
+  it('builds route sets and checks super admin role', () => {
+    const menus = normalizeRuntimeMenuResponse({
+      modules: {
+        1: {
+          menus: [
+            {route: 'HomePage'},
+            {route: 'MenuAccessConfigPage'},
+          ],
+        },
+      },
+    });
+
+    expect(getRuntimeMenuRoutes(menus).has('MenuAccessConfigPage')).toBe(true);
+    expect(userHasRole({roles: ['ROLE_SUPER']}, 'ROLE_SUPER')).toBe(true);
+    expect(userHasRole({roles: ['ROLE_MANAGER']}, 'ROLE_SUPER')).toBe(false);
+  });
+
+  it('normalizes snake_case menu_key into menuKey for runtime usage', () => {
+    const menus = normalizeRuntimeMenuResponse({
+      modules: {
+        1: {
+          menus: [
+            {menu_key: 'menu_access', route: 'MenuAccessConfigPage'},
+          ],
+        },
+      },
+    });
+
+    expect(menus[0].menus[0].menuKey).toBe('menu_access');
+  });
+
+  it('converts legacy material icon names into feather-compatible names', () => {
+    expect(normalizeRuntimeMenuIcon('shopping_cart')).toBe('shopping-cart');
+    expect(normalizeRuntimeMenuIcon('account_balance')).toBe('dollar-sign');
+
+    const menus = normalizeRuntimeMenuResponse({
+      modules: {
+        1: {
+          icon: 'account_balance',
+          menus: [
+            {
+              icon: 'shopping_cart',
+              route: 'OrderHistoryPage',
+            },
+          ],
+        },
+      },
+    });
+
+    expect(menus[0].icon).toBe('dollar-sign');
+    expect(menus[0].menus[0].icon).toBe('shopping-cart');
+  });
+
+  it('filters runtime menu modules by menu type', () => {
+    const menus = normalizeRuntimeMenuResponse({
+      modules: {
+        1: {
+          label: 'Mix',
+          menus: [
+            {route: 'HomePage', menuType: 'home', sortOrder: 10},
+            {route: 'ToolbarPage', menu_type: 'toolbar', sortOrder: 20},
+          ],
+        },
+      },
+    });
+
+    const toolbarMenus = filterRuntimeMenuModulesByType(menus, 'toolbar');
+
+    expect(toolbarMenus).toHaveLength(1);
+    expect(toolbarMenus[0].menus).toHaveLength(1);
+    expect(toolbarMenus[0].menus[0]).toMatchObject({
+      route: 'ToolbarPage',
+      menuType: 'toolbar',
+    });
+    expect(
+      flattenRuntimeMenuItemsByType(menus, 'toolbar').map(item => item.route),
+    ).toEqual(['ToolbarPage']);
+  });
+
+  it('falls back to the manager core menu when the runtime menu is empty', () => {
+    const menus = normalizeRuntimeMenuResponse({}, {appType: 'MANAGER'});
+
+    expect(menus).toHaveLength(4);
+    expect(menus.map(module => module.label)).toEqual([
+      'Financeiro',
+      'Operacoes',
+      'Comercial',
+      'Configuracoes',
+    ]);
+    expect(menus[0].menus[0]).toMatchObject({
+      label: 'Financeiro',
+      menuKey: 'financial_hub',
+      route: 'FinancialHubPage',
+      menuType: 'home',
+    });
+    expect(menus[0].menus[1]).toMatchObject({
+      label: 'Demonstrativo de resultados',
+      menuKey: 'income_statement',
+      route: 'IncomeStatement',
+    });
+    expect(menus[1].menus[0]).toMatchObject({
+      label: 'Pedidos',
+      menuKey: 'orders',
+      route: 'OrderHistoryPage',
+    });
+    expect(menus[2].menus[0]).toMatchObject({
+      label: 'Cadastro de clientes',
+      menuKey: 'clients',
+      route: 'ClientsIndex',
+    });
+    expect(menus[2].menus[1]).toMatchObject({
+      label: 'Fornecedores',
+      menuKey: 'providers',
+      route: 'ProvidersIndex',
+    });
+    expect(menus[2].menus[2]).toMatchObject({
+      label: 'Cadastro de franquias',
+      menuKey: 'franchisees',
+      route: 'FranchiseesIndex',
+    });
+    expect(menus[3].menus.map(item => item.route)).toEqual([
+      'DevicesIndex',
+      'ConfiguratorPage',
+    ]);
+  });
+
+  it('does not invent a fallback menu for non-manager apps', () => {
+    expect(
+      normalizeRuntimeMenuResponse({}, {appType: 'SHOP'}),
+    ).toEqual([]);
+  });
+
+  it('can skip the manager fallback when requested', () => {
+    expect(
+      normalizeRuntimeMenuResponse({}, {appType: 'MANAGER', allowFallback: false}),
+    ).toEqual([]);
+  });
+});