@controleonline/ui-common 1.2.89 → 1.2.91

package/src/react/components/DefaultProvider.native.lifecycle.js

@@ -0,0 +1,323 @@
+import {useEffect} from 'react';
+
+// Extracted bootstrap effects retain their dependency arrays and invocation order.
+
+export function useNativeTranslationRefresh({setTranslateVersion}) {
+  useEffect(() => {
+    global.refreshTranslationsUI = () => {
+      setTranslateVersion(version => version + 1);
+    };
+
+    return () => {
+      if (global.refreshTranslationsUI) {
+        delete global.refreshTranslationsUI;
+      }
+    };
+  }, []);
+}
+
+export function useNativeTranslationReset({isLogged, isPublicRouteActive, setTranslateReady, setActiveTranslateBootstrapKey, translateBootstrapKeyRef, translateActions}) {
+  useEffect(() => {
+    if (isLogged && !isPublicRouteActive) {
+      return;
+    }
+
+    setTranslateReady(true);
+    setActiveTranslateBootstrapKey('');
+    translateBootstrapKeyRef.current = '';
+    translateActions.setMessages({});
+    translateActions.setPendingMessages?.({});
+
+    if (global.t) {
+      delete global.t;
+    }
+  }, [isLogged, isPublicRouteActive, translateActions]);
+}
+
+export function useNativeAppLifecycle({AppState, setAppState}) {
+  useEffect(() => {
+    const subscription = AppState.addEventListener('change', nextState => {
+      setAppState(nextState || 'active');
+    });
+
+    return () => {
+      subscription?.remove?.();
+    };
+  }, []);
+}
+
+export function useNativeNativeVersion({DeviceInfo, device, fetchDeviceId}) {
+  useEffect(() => {
+    const checkVersion = async () => {
+      const appVersion = await DeviceInfo.getVersion();
+      if (
+        device &&
+        ((device.appVersion && device.appVersion != appVersion) || !device.appName)
+      ) {
+        fetchDeviceId();
+      }
+    };
+    checkVersion();
+  }, [device]);
+}
+
+export function useNativeNativeDeviceIdentity({device, fetchDeviceId, deviceActions}) {
+  useEffect(() => {
+    if (!device || !device.id) {
+      fetchDeviceId();
+    } else {
+      deviceActions.setItem(device);
+    }
+  }, [device]);
+}
+
+export function useNativeMainCompany({device, peopleActions}) {
+  useEffect(() => {
+    if (device && device.id) {
+      peopleActions.mainCompany();
+    }
+  }, [device?.id]);
+}
+
+export function useNativeDeviceConfigReset({deviceConfigPeopleIri, lastDeviceConfigPeopleIriRef, setDeviceConfigFetched, setDeviceRuntimeConfigSynced, deviceConfigsActions}) {
+  useEffect(() => {
+    if (
+      !deviceConfigPeopleIri ||
+      lastDeviceConfigPeopleIriRef.current === deviceConfigPeopleIri
+    ) {
+      return;
+    }
+
+    lastDeviceConfigPeopleIriRef.current = deviceConfigPeopleIri;
+    setDeviceConfigFetched(false);
+    setDeviceRuntimeConfigSynced(false);
+    deviceConfigsActions.setItem({});
+  }, [deviceConfigPeopleIri, deviceConfigsActions]);
+}
+
+export function useNativeDeviceRegistration({sessionChecked, isLogged, deviceConfigPeopleIri, device, deviceConfigFetched, currentCompany, canAdministerCompany, mainCompany, user, deviceActions, runtimeDeviceType, buildDeviceRegistrationPayload, app_type, hasDeviceRecordChanges, setDevice}) {
+  useEffect(() => {
+    if (!sessionChecked || !isLogged || !deviceConfigPeopleIri || !device?.id || deviceConfigFetched) {
+      return;
+    }
+
+    // Device registration changes tenant context and is not valid without an
+    // active company or administrative authority for that company.
+    if (
+      !currentCompany?.id ||
+      !canAdministerCompany({company: currentCompany, mainCompany, user})
+    ) {
+      return;
+    }
+
+    let cancelled = false;
+
+    const syncDeviceRegistration = async () => {
+      const items = await deviceActions.getItems({
+        device: device.id,
+        people: deviceConfigPeopleIri,
+        type: runtimeDeviceType,
+      });
+
+      if (cancelled) {
+        return;
+      }
+
+      const existingDevice =
+        Array.isArray(items) && items.length > 0 ? items[0] : null;
+      const nextDevice = buildDeviceRegistrationPayload({
+        deviceInfo: device,
+        appType: app_type,
+        existingDevice,
+      });
+
+      if (!hasDeviceRecordChanges({existingDevice, nextDevice})) {
+        const nextLocalDevice = {
+          ...device,
+          entityId: existingDevice?.id || device?.entityId || null,
+          entityIri:
+            existingDevice?.['@id'] ||
+            device?.entityIri ||
+            (existingDevice?.id ? `/devices/${existingDevice.id}` : null),
+          alias: existingDevice?.alias || nextDevice.alias,
+          type: device?.type || runtimeDeviceType,
+          metadata: {
+            ...(existingDevice?.metadata || {}),
+            ...(nextDevice.metadata || {}),
+          },
+        };
+
+        if (JSON.stringify(nextLocalDevice) !== JSON.stringify(device)) {
+          setDevice(nextLocalDevice);
+          localStorage.setItem('device', JSON.stringify(nextLocalDevice));
+          deviceActions.setItem(nextLocalDevice);
+        }
+        return;
+      }
+
+      const savedDevice = await deviceActions.save(nextDevice);
+      if (cancelled || !savedDevice) {
+        return;
+      }
+
+      const nextLocalDevice = {
+        ...device,
+        entityId: savedDevice?.id || device?.entityId || null,
+        entityIri:
+          savedDevice?.['@id'] ||
+          device?.entityIri ||
+          (savedDevice?.id ? `/devices/${savedDevice.id}` : null),
+        alias: savedDevice.alias || nextDevice.alias,
+        type: device?.type || runtimeDeviceType,
+        metadata: {
+          ...(savedDevice?.metadata || {}),
+          ...(nextDevice.metadata || {}),
+        },
+      };
+
+      if (JSON.stringify(nextLocalDevice) !== JSON.stringify(device)) {
+        setDevice(nextLocalDevice);
+        localStorage.setItem('device', JSON.stringify(nextLocalDevice));
+        deviceActions.setItem(nextLocalDevice);
+      }
+    };
+
+    syncDeviceRegistration().catch(() => {});
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    device?.appVersion,
+    device?.batteryLevel,
+    device?.buildNumber,
+    device?.deviceType,
+    device?.id,
+    device?.metadata,
+    device?.manufacturer,
+    device?.model,
+    device?.systemVersion,
+    deviceConfigFetched,
+    deviceConfigPeopleIri,
+    isLogged,
+    currentCompany,
+    mainCompany,
+    sessionChecked,
+    runtimeDeviceType,
+    user,
+  ]);
+}
+
+export function useNativePrinters({isShopClientApp, sessionChecked, isLogged, currentCompany, printerActions}) {
+  useEffect(() => {
+    if (isShopClientApp || !sessionChecked || !isLogged || !currentCompany?.id) {
+      return;
+    }
+
+    printerActions
+      .ensureCompanyPrintersLoaded({people: currentCompany.id})
+      .catch(() => {});
+  }, [currentCompany?.id, isLogged, isShopClientApp, printerActions, sessionChecked]);
+}
+
+export function useNativePaymentTypes({isShopClientApp, companyConfigs, currentCompany, device_config, paymentTypeActions, mainConfigsDiscovered, api, selectPosWalletPaymentTypes, getPaymentGateway}) {
+  useEffect(() => {
+    const paymentConfigSource = isShopClientApp
+      ? Object.keys(companyConfigs || {}).length > 0
+        ? companyConfigs
+        : currentCompany?.configs
+      : device_config?.configs;
+
+    if (!currentCompany?.id || !paymentConfigSource) {
+      paymentTypeActions.setItems([]);
+      return;
+    }
+
+    if (!isShopClientApp && !mainConfigsDiscovered) {
+      return;
+    }
+
+    let isMounted = true;
+
+    api
+      .fetch('wallet_payment_types', {
+        params: {
+          people: `/people/${currentCompany.id}`,
+        },
+      })
+      .then(response => {
+        if (!isMounted) {
+          return;
+        }
+
+        const walletPaymentTypes = Array.isArray(response?.member)
+          ? response.member
+          : Array.isArray(response?.['hydra:member'])
+            ? response['hydra:member']
+            : Array.isArray(response)
+              ? response
+              : [];
+        paymentTypeActions.setItems(
+          selectPosWalletPaymentTypes({
+            walletPaymentTypes,
+            deviceConfigs: paymentConfigSource,
+            companyConfigs,
+            gateway: getPaymentGateway(device_config || paymentConfigSource),
+          }),
+        );
+      })
+      .catch(() => {
+        if (isMounted) {
+          paymentTypeActions.setItems([]);
+        }
+      });
+
+    return () => {
+      isMounted = false;
+    };
+  }, [
+    companyConfigs,
+    currentCompany?.configs,
+    currentCompany?.id,
+    device_config?.configs,
+    isShopClientApp,
+    paymentTypeActions,
+  ]);
+}
+
+export function useNativeDeviceConfigFetch({device, isLogged, currentCompany, setDeviceConfigFetched, setDeviceRuntimeConfigSynced, deviceConfigsActions, runtimeDeviceType, parseConfigsObject}) {
+  useEffect(() => {
+    if (
+      device &&
+      device.id &&
+      isLogged &&
+      currentCompany &&
+      Object.entries(currentCompany).length > 0
+    ) {
+      setDeviceConfigFetched(false);
+      setDeviceRuntimeConfigSynced(false);
+      deviceConfigsActions
+        .getItems({
+          'device.device': device.id,
+          people: '/people/' + currentCompany.id,
+          type: runtimeDeviceType,
+        })
+        .then(data => {
+          if (Array.isArray(data) && data.length > 0) {
+            const nextItem = {
+              ...data[0],
+              configs: parseConfigsObject(data[0]?.configs),
+            };
+            deviceConfigsActions.setItem(nextItem);
+            return;
+          }
+
+          deviceConfigsActions.setItem({});
+        })
+        .catch(() => {})
+        .finally(() => {
+          setDeviceConfigFetched(true);
+        });
+    }
+  }, [currentCompany?.id, isLogged, device?.id, runtimeDeviceType]);
+}

package/src/react/components/DefaultProvider.web.configuration.js

@@ -0,0 +1,327 @@
+import {useEffect} from 'react';
+
+// Extracted bootstrap effects retain their dependency arrays and invocation order.
+
+export function useWebDeviceConfigFetch({device, isLogged, deviceConfigPeopleIri, setDeviceConfigFetched, setDeviceRuntimeConfigSynced, deviceConfigsActions, runtimeDeviceType, selectRuntimeDeviceConfig, parseConfigsObject}) {
+  useEffect(() => {
+    if (!device?.id || !isLogged || !deviceConfigPeopleIri) {
+      return;
+    }
+
+    setDeviceConfigFetched(false);
+    setDeviceRuntimeConfigSynced(false);
+    deviceConfigsActions.setItem({});
+
+    deviceConfigsActions
+      .getItems({
+        'device.device': device.id,
+        people: deviceConfigPeopleIri,
+        type: runtimeDeviceType,
+      })
+      .then(data => {
+        const selectedConfig = selectRuntimeDeviceConfig({
+          items: data,
+          deviceId: device.id,
+          companyId: deviceConfigPeopleIri,
+          runtimeDeviceType,
+        });
+
+        if (selectedConfig) {
+          const nextItem = {
+            ...selectedConfig,
+            configs: parseConfigsObject(selectedConfig?.configs),
+          };
+          deviceConfigsActions.setItem(nextItem);
+          return;
+        }
+
+        deviceConfigsActions.setItem({});
+      })
+      .catch(() => {})
+      .finally(() => {
+        setDeviceConfigFetched(true);
+      });
+  }, [
+    device?.id,
+    deviceConfigPeopleIri,
+    deviceConfigsActions,
+    isLogged,
+    runtimeDeviceType,
+  ]);
+}
+
+export function useWebDeviceConfigSync({deviceConfigFetched, isLogged, deviceConfigPeopleIri, device, deviceRuntimeConfigSynced, runtimeDeviceType, device_config, buildDefaultDeviceConfigs, buildProviderManagedDeviceConfigs, appVersion, setDeviceRuntimeConfigSynced, deviceConfigsActions, user}) {
+  useEffect(() => {
+    if (
+      !deviceConfigFetched ||
+      !isLogged ||
+      !deviceConfigPeopleIri ||
+      !device?.id ||
+      deviceRuntimeConfigSynced
+    ) {
+      return;
+    }
+
+    const isNewPdvConfig =
+      runtimeDeviceType === 'PDV' &&
+      !device_config?.id &&
+      !device_config?.['@id'];
+    const buildDeviceConfigs = isNewPdvConfig
+      ? buildDefaultDeviceConfigs
+      : buildProviderManagedDeviceConfigs;
+    const {nextConfigs, needsUpdate} = buildDeviceConfigs({
+      configs: device_config?.configs,
+      appVersion,
+      deviceInfo: device,
+    });
+
+    if (!needsUpdate) {
+      setDeviceRuntimeConfigSynced(true);
+      return;
+    }
+
+    // app-community#821: never auto-persist device_config from global bootstrap.
+    // Provider-managed fields (config-version, pos-gateway, screen metrics) stay
+    // in memory only. POST/PUT to /device_configs* is reserved for explicit
+    // device settings UI — avoids 403 from DeviceFinancialConfigAuthorizationSubscriber
+    // on pages like order-history (PDV/MANAGER types are fully protected).
+    const currentItem = device_config || {};
+    deviceConfigsActions.setItem({
+      ...currentItem,
+      configs: nextConfigs,
+      device: currentItem.device || device.id,
+      people: currentItem.people || deviceConfigPeopleIri,
+      type: currentItem.type || runtimeDeviceType,
+    });
+    setDeviceRuntimeConfigSynced(true);
+  }, [
+    appVersion,
+    device?.id,
+    device?.manufacturer,
+    device?.isEmulator,
+    deviceConfigFetched,
+    deviceConfigPeopleIri,
+    deviceRuntimeConfigSynced,
+    deviceConfigsActions,
+    device_config,
+    isLogged,
+    runtimeDeviceType,
+    user,
+  ]);
+}
+
+export function useWebMainConfigReset({isLogged, currentCompany, device, setMainConfigsDiscovered}) {
+  useEffect(() => {
+    if (!isLogged || !currentCompany?.id || !device?.id) {
+      return;
+    }
+
+    setMainConfigsDiscovered(false);
+  }, [isLogged, currentCompany?.id, device?.id]);
+}
+
+export function useWebMainConfigDiscovery({isLogged, currentCompany, device, mainConfigsDiscovered, configActions, setMainConfigsDiscovered}) {
+  useEffect(() => {
+    if (
+      !isLogged ||
+      !currentCompany?.id ||
+      !device?.id ||
+      mainConfigsDiscovered
+    ) {
+      return;
+    }
+
+    configActions
+      .discoveryMainConfigs({
+        people: '/people/' + currentCompany.id,
+      })
+      .catch(() => { })
+      .finally(() => {
+        setMainConfigsDiscovered(true);
+      });
+  }, [configActions, currentCompany?.id, device?.id, isLogged, mainConfigsDiscovered]);
+}
+
+export function useWebMainConfigSeed({isLogged, currentCompany, mainConfigsDiscovered, configActions}) {
+  useEffect(() => {
+    if (
+      isLogged &&
+      currentCompany &&
+      Object.entries(currentCompany).length > 0 &&
+      !mainConfigsDiscovered
+    ) {
+      configActions.setItems(currentCompany.configs);
+    }
+  }, [currentCompany, isLogged, mainConfigsDiscovered]);
+}
+
+export function useWebTranslationBootstrap({currentRouteName, isPublicRouteActive, isLogged, hasCurrentCompany, deviceConfigFetched, expectedTranslateBootstrapKey, translateBootstrapKeyRef, companies, currentCompany, mainCompany, setActiveTranslateBootstrapKey, setTranslateReady, configuredTranslationLanguage, Translate, stores, translateStore}) {
+  useEffect(() => {
+    if (!currentRouteName || isPublicRouteActive) {
+      return;
+    }
+
+    if (
+      !isLogged ||
+      !hasCurrentCompany ||
+      !deviceConfigFetched ||
+      !expectedTranslateBootstrapKey
+    ) {
+      return;
+    }
+
+    const currentConfig = JSON.parse(localStorage.getItem('config') || '{}');
+
+    if (
+      translateBootstrapKeyRef.current === expectedTranslateBootstrapKey &&
+      global.t
+    ) {
+      global.t.companies = companies;
+      global.t.currentCompany = currentCompany;
+      global.t.mainCompany = mainCompany;
+      setActiveTranslateBootstrapKey(expectedTranslateBootstrapKey);
+      setTranslateReady(true);
+
+      return;
+    }
+
+    setTranslateReady(false);
+
+    if (currentConfig.language !== configuredTranslationLanguage) {
+      const nextConfig = {
+        ...currentConfig,
+        language: configuredTranslationLanguage,
+      };
+      localStorage.setItem(
+        'config',
+        JSON.stringify(nextConfig),
+      );
+    }
+
+    translateBootstrapKeyRef.current = expectedTranslateBootstrapKey;
+    global.t = new Translate(
+      companies,
+      mainCompany,
+      currentCompany,
+      Object.keys(stores),
+      translateStore,
+    );
+    setActiveTranslateBootstrapKey(expectedTranslateBootstrapKey);
+    setTranslateReady(true);
+    global.refreshTranslationsUI?.();
+  }, [
+    companies,
+    configuredTranslationLanguage,
+    currentCompany,
+    currentRouteName,
+    mainCompany,
+    deviceConfigFetched,
+    expectedTranslateBootstrapKey,
+    hasCurrentCompany,
+    isLogged,
+    isPublicRouteActive,
+    translateStore,
+  ]);
+}
+
+export function useWebBootstrapReady({isLogged, hasCurrentCompany, currentRouteName, isTranslateBootstrapReady, onBootstrapReady}) {
+  useEffect(() => {
+    if (
+      !isLogged ||
+      !hasCurrentCompany ||
+      (currentRouteName && isTranslateBootstrapReady)
+    ) {
+      onBootstrapReady?.();
+    }
+  }, [
+    currentRouteName,
+    hasCurrentCompany,
+    isLogged,
+    isTranslateBootstrapReady,
+    onBootstrapReady,
+  ]);
+}
+
+export function useWebCompanies({device, isLogged, peopleActions}) {
+  useEffect(() => {
+    if (device && device.id && isLogged) {
+      peopleActions.myCompanies();
+    }
+  }, [isLogged, device?.id]);
+}
+
+export function useWebMenus({isLogged, currentCompany, actions, api, appType, normalizeRuntimeMenuResponse}) {
+  useEffect(() => {
+    if (!isLogged || !currentCompany?.id) {
+      actions.setMenus([]);
+      return undefined;
+    }
+
+    let cancelled = false;
+
+    api
+      .fetch('menus-people', {
+        params: {
+          myCompany: currentCompany.id,
+          appType,
+          menuType: 'home',
+        },
+      })
+      .then(result => {
+        if (!cancelled) {
+          actions.setMenus(normalizeRuntimeMenuResponse(result, {appType}));
+        }
+      })
+      .catch(() => {
+        if (!cancelled) {
+          actions.setMenus(normalizeRuntimeMenuResponse(null, {appType}));
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [actions, appType, currentCompany?.id, isLogged]);
+}
+
+export function useWebThemeFetch({api, parseThemeCss, setBaseThemeColors, actions, currentCompany, mainCompany, device}) {
+  useEffect(() => {
+    const fetchColors = async () => {
+      try {
+        const cssText = await api.fetch('themes-colors.css', {
+          responseType: 'text',
+        });
+        const parsedColors = parseThemeCss(cssText);
+        setBaseThemeColors(parsedColors);
+        actions.setColors(parsedColors);
+      } catch {
+        setBaseThemeColors({});
+      }
+    };
+
+    fetchColors();
+  }, [actions, currentCompany?.id, mainCompany?.id, device?.id]);
+}
+
+export function useWebThemePalette({resolveDomainThemeColors, baseThemeColors, mainCompany, resolveThemePalette, runtimeColors, applyPaletteToRuntimeColors, applyThemeCssVariables, actions, currentCompany, isShopClientApp}) {
+  useEffect(() => {
+    const mergedThemeColors = resolveDomainThemeColors(baseThemeColors, mainCompany);
+
+    const palette = resolveThemePalette(mergedThemeColors, runtimeColors);
+    applyPaletteToRuntimeColors(palette, runtimeColors);
+    applyThemeCssVariables({
+      themeColors: mergedThemeColors,
+      palette,
+    });
+
+    actions.setColors(mergedThemeColors);
+  }, [
+    actions,
+    baseThemeColors,
+    currentCompany?.id,
+    currentCompany?.theme?.colors,
+    mainCompany?.id,
+    mainCompany?.theme?.colors,
+    isShopClientApp,
+  ]);
+}