@controleonline/ui-common 1.2.70

package/src/react/components/ManagerPushBridge.native.js

@@ -0,0 +1,345 @@
+import React, {useCallback, useEffect, useMemo, useRef} from 'react';
+import {Platform} from 'react-native';
+import * as Notifications from 'expo-notifications';
+import {env as APP_ENV} from '@env';
+import {useStore} from '@store';
+import {
+  ensureManagerOrderNotificationPermission,
+  isManagerAppType,
+  resolveManagerOrderNotificationPreferences,
+} from '@controleonline/ui-common/src/react/utils/managerOrderNotifications';
+import {
+  queueNotificationNavigation,
+} from '@controleonline/ui-common/src/react/utils/notificationNavigation';
+
+const normalizeText = value => String(value || '').trim();
+
+const isPlainObject = value =>
+  !!value && typeof value === 'object' && !Array.isArray(value);
+
+const extractOrderIdFromResponse = response => {
+  const data = response?.notification?.request?.content?.data || {};
+  const candidate =
+    data?.orderId ||
+    data?.order_id ||
+    data?.order ||
+    data?.id ||
+    data?.orderDetailsId ||
+    '';
+
+  return normalizeText(candidate).replace(/\D+/g, '');
+};
+
+const extractManagerPushToken = metadata =>
+  normalizeText(
+    metadata?.pushTokens?.manager?.android?.deviceToken || '',
+  );
+
+const resolvePersistableDeviceEntityId = deviceInfo =>
+  normalizeText(deviceInfo?.entityId || deviceInfo?.apiId || deviceInfo?.['@id'])
+    .replace(/\D+/g, '');
+
+const mergeManagerPushTokenMetadata = (metadata, deviceToken) => {
+  const normalizedMetadata = isPlainObject(metadata) ? metadata : {};
+  const nextMetadata = {
+    ...normalizedMetadata,
+  };
+
+  const pushTokens = isPlainObject(normalizedMetadata.pushTokens)
+    ? {...normalizedMetadata.pushTokens}
+    : {};
+  const managerTokens = isPlainObject(pushTokens.manager)
+    ? {...pushTokens.manager}
+    : {};
+  const androidTokens = isPlainObject(managerTokens.android)
+    ? {...managerTokens.android}
+    : {};
+
+  if (normalizeText(deviceToken)) {
+    androidTokens.deviceToken = normalizeText(deviceToken);
+    managerTokens.android = androidTokens;
+    pushTokens.manager = managerTokens;
+    nextMetadata.pushTokens = pushTokens;
+    return nextMetadata;
+  }
+
+  delete androidTokens.deviceToken;
+  if (Object.keys(androidTokens).length > 0) {
+    managerTokens.android = androidTokens;
+  } else {
+    delete managerTokens.android;
+  }
+
+  if (Object.keys(managerTokens).length > 0) {
+    pushTokens.manager = managerTokens;
+  } else {
+    delete pushTokens.manager;
+  }
+
+  if (Object.keys(pushTokens).length > 0) {
+    nextMetadata.pushTokens = pushTokens;
+  } else {
+    delete nextMetadata.pushTokens;
+  }
+
+  return nextMetadata;
+};
+
+const ManagerPushBridge = ({device, setDevice}) => {
+  const authStore = useStore('auth');
+  const deviceStore = useStore('device');
+
+  const authGetters = authStore.getters;
+  const deviceActions = deviceStore.actions;
+
+  const {isLogged, sessionChecked, user} = authGetters;
+  const isManagerRuntime = isManagerAppType(APP_ENV?.APP_TYPE);
+  const pushPreferences = useMemo(
+    () => resolveManagerOrderNotificationPreferences(user),
+    [user],
+  );
+  const pushEnabled = isManagerRuntime && pushPreferences.pushEnabled;
+
+  const currentDeviceRef = useRef(device || {});
+  const pushTokenListenerRef = useRef(null);
+  const notificationResponseListenerRef = useRef(null);
+
+  const persistLocalDevice = useCallback(
+    nextDevice => {
+      if (!nextDevice?.id) {
+        return;
+      }
+
+      const currentSerializedDevice = JSON.stringify(
+        currentDeviceRef.current || {},
+      );
+      const nextSerializedDevice = JSON.stringify(nextDevice || {});
+      if (currentSerializedDevice === nextSerializedDevice) {
+        return;
+      }
+
+      currentDeviceRef.current = nextDevice;
+      setDevice(nextDevice);
+      localStorage.setItem('device', JSON.stringify(nextDevice));
+      deviceActions.setItem(nextDevice);
+    },
+    [deviceActions, setDevice],
+  );
+
+  const applyManagerPushToken = useCallback(
+    async (deviceToken, {persistImmediately = false} = {}) => {
+      const currentDevice = currentDeviceRef.current || {};
+      if (!currentDevice?.id) {
+        return false;
+      }
+
+      const normalizedToken = normalizeText(deviceToken);
+      const currentToken = extractManagerPushToken(currentDevice?.metadata);
+
+      if (
+        !persistImmediately &&
+        normalizedToken &&
+        currentToken === normalizedToken
+      ) {
+        return true;
+      }
+
+      if (!persistImmediately && !normalizedToken && !currentToken) {
+        return true;
+      }
+
+      if (persistImmediately && !normalizedToken && !currentToken) {
+        return true;
+      }
+
+      const nextMetadata = mergeManagerPushTokenMetadata(
+        currentDevice?.metadata,
+        normalizedToken,
+      );
+      const nextDevice = {
+        ...currentDevice,
+        metadata: nextMetadata,
+      };
+
+      persistLocalDevice(nextDevice);
+
+      if (!persistImmediately) {
+        return true;
+      }
+
+      const entityId = resolvePersistableDeviceEntityId(currentDevice);
+      if (!entityId) {
+        return true;
+      }
+
+      try {
+        await deviceActions.save({
+          id: entityId,
+          device: currentDevice.device || currentDevice.id,
+          alias: currentDevice.alias,
+          metadata: nextMetadata,
+        });
+      } catch (error) {
+        console.warn('Erro ao limpar push token do Gestor no logout', error);
+      }
+
+      return true;
+    },
+    [deviceActions, persistLocalDevice],
+  );
+
+  useEffect(() => {
+    currentDeviceRef.current = device || {};
+  }, [device]);
+
+  useEffect(() => {
+    if (Platform.OS !== 'android' || !isManagerRuntime) {
+      return;
+    }
+
+    global.clearManagerPushTokenOnLogout = () =>
+      applyManagerPushToken('', {persistImmediately: true});
+
+    return () => {
+      if (global.clearManagerPushTokenOnLogout) {
+        delete global.clearManagerPushTokenOnLogout;
+      }
+    };
+  }, [applyManagerPushToken]);
+
+  useEffect(() => {
+    if (
+      Platform.OS !== 'android' ||
+      !isManagerRuntime ||
+      !sessionChecked ||
+      !currentDeviceRef.current?.id
+    ) {
+      return;
+    }
+
+    let cancelled = false;
+
+    const configurePushSupport = async () => {
+      if (!isLogged) {
+        const currentToken = extractManagerPushToken(
+          currentDeviceRef.current?.metadata,
+        );
+
+        if (currentToken) {
+          await applyManagerPushToken('', {persistImmediately: true});
+        }
+
+        return;
+      }
+
+      const permissionStatus = await ensureManagerOrderNotificationPermission();
+
+      if (cancelled) {
+        return;
+      }
+
+      if (permissionStatus !== 'granted') {
+        await applyManagerPushToken('', {persistImmediately: true});
+        return;
+      }
+
+      if (!pushEnabled) {
+        const currentToken = extractManagerPushToken(
+          currentDeviceRef.current?.metadata,
+        );
+
+        if (currentToken) {
+          await applyManagerPushToken('', {persistImmediately: true});
+        }
+
+        return;
+      }
+
+      const devicePushToken = await Notifications.getDevicePushTokenAsync();
+      const nextToken = normalizeText(devicePushToken?.data);
+
+      if (cancelled) {
+        return;
+      }
+
+      if (!nextToken) {
+        await applyManagerPushToken('', {persistImmediately: true});
+      } else {
+        await applyManagerPushToken(nextToken, {persistImmediately: true});
+      }
+
+      if (!pushTokenListenerRef.current) {
+        pushTokenListenerRef.current = Notifications.addPushTokenListener(
+          token => {
+            const nextListenerToken = normalizeText(token?.data);
+            if (!nextListenerToken) {
+              return;
+            }
+
+            void applyManagerPushToken(nextListenerToken, {
+              persistImmediately: true,
+            });
+          },
+        );
+      }
+
+      if (!notificationResponseListenerRef.current) {
+        notificationResponseListenerRef.current =
+          Notifications.addNotificationResponseReceivedListener(response => {
+            const orderId = extractOrderIdFromResponse(response);
+            if (!orderId) {
+              return;
+            }
+
+            queueNotificationNavigation('OrderDetails', {id: orderId});
+
+            if (typeof Notifications.clearLastNotificationResponseAsync === 'function') {
+              Notifications.clearLastNotificationResponseAsync().catch(() => {});
+            }
+          });
+      }
+
+      if (typeof Notifications.getLastNotificationResponseAsync === 'function') {
+        const lastResponse = await Notifications.getLastNotificationResponseAsync();
+        const orderId = extractOrderIdFromResponse(lastResponse);
+
+        if (!cancelled && orderId) {
+          queueNotificationNavigation('OrderDetails', {id: orderId});
+
+          if (typeof Notifications.clearLastNotificationResponseAsync === 'function') {
+            Notifications.clearLastNotificationResponseAsync().catch(() => {});
+          }
+        }
+      }
+    };
+
+    configurePushSupport().catch(error => {
+      console.warn('Erro ao inicializar push nativo do Gestor', error);
+    });
+
+    return () => {
+      cancelled = true;
+
+      if (pushTokenListenerRef.current) {
+        pushTokenListenerRef.current.remove();
+        pushTokenListenerRef.current = null;
+      }
+
+      if (notificationResponseListenerRef.current) {
+        notificationResponseListenerRef.current.remove();
+        notificationResponseListenerRef.current = null;
+      }
+    };
+  }, [
+    applyManagerPushToken,
+    device?.id,
+    isLogged,
+    isManagerRuntime,
+    pushEnabled,
+    sessionChecked,
+  ]);
+
+  return null;
+};
+
+export default ManagerPushBridge;

package/src/react/components/MessageService.js

@@ -0,0 +1,314 @@
+import React, {createContext, useContext, useEffect, useState} from 'react';
+import {Dimensions} from 'react-native';
+import {
+  Portal,
+  Dialog,
+  Paragraph,
+  Button,
+  TextInput as PaperTextInput,
+} from 'react-native-paper';
+import {toast, ToastPosition} from '@backpackapp-io/react-native-toast';
+import SystemErrorToast from './SystemErrorToast';
+import {
+  TOAST_DEFAULT_BOTTOM_OFFSET,
+  TOAST_DEFAULT_DURATION,
+  TOAST_DEFAULT_TOP_OFFSET,
+  TOAST_MODAL_COUNT_KEY,
+  TOAST_PROVIDER_KEYS,
+} from './toastConfig';
+import {
+  withErrorToastStyles,
+  withWarningToastStyles,
+} from '@controleonline/ui-common/src/react/utils/toastPresentation';
+import {
+  publishSystemError,
+  subscribeSystemErrors,
+} from '@controleonline/ui-common/src/react/utils/systemErrorChannel'
+
+const MessageContext = createContext();
+
+export const useMessage = () => useContext(MessageContext);
+
+const normalizeMessage = message => {
+  if (message === undefined || message === null) return ''
+  return message
+}
+
+const getDefaultProviderKey = () => {
+  const modalDepth = Number(global?.[TOAST_MODAL_COUNT_KEY] || 0)
+  if (modalDepth > 0) {
+    return TOAST_PROVIDER_KEYS.PERSIST
+  }
+
+  return TOAST_PROVIDER_KEYS.ROOT
+}
+
+const normalizeOptions = (options = {}, fallbackPosition = 'top') => {
+  const {
+    duration = TOAST_DEFAULT_DURATION,
+    position = fallbackPosition,
+    offsetTop,
+    offsetBottom,
+    providerKey,
+    styles: stylesOverride,
+    ...rest
+  } = options
+
+  const pressableAdjustments = {}
+
+  if (position === 'center') {
+    const screenCenterOffset = Math.max(
+      0,
+      Math.round(Dimensions.get('window').height * 0.45) -
+        TOAST_DEFAULT_TOP_OFFSET,
+    )
+    if (screenCenterOffset > 0) {
+      pressableAdjustments.marginTop = screenCenterOffset
+    }
+  }
+
+  if (position !== 'bottom' && typeof offsetTop === 'number') {
+    const topDiff = offsetTop - TOAST_DEFAULT_TOP_OFFSET
+    if (topDiff !== 0) {
+      pressableAdjustments.marginTop =
+        (pressableAdjustments.marginTop || 0) + topDiff
+    }
+  }
+
+  if (position === 'bottom' && typeof offsetBottom === 'number') {
+    const bottomDiff = offsetBottom - TOAST_DEFAULT_BOTTOM_OFFSET
+    if (bottomDiff !== 0) {
+      pressableAdjustments.marginBottom = bottomDiff
+    }
+  }
+
+  const mergedStyles =
+    Object.keys(pressableAdjustments).length > 0
+      ? {
+          ...(stylesOverride || {}),
+          pressable: {
+            ...(stylesOverride?.pressable || {}),
+            ...pressableAdjustments,
+          },
+        }
+      : stylesOverride
+
+  return {
+    duration,
+    position: position === 'bottom' ? ToastPosition.BOTTOM : ToastPosition.TOP,
+    providerKey: providerKey || getDefaultProviderKey(),
+    ...rest,
+    ...(mergedStyles ? {styles: mergedStyles} : {}),
+  }
+}
+
+export const MessageProvider = ({children}) => {
+  const [dialog, setDialog] = useState({
+    visible: false,
+    title: '',
+    message: '',
+    onConfirm: null,
+    onCancel: null,
+  });
+  const [prompt, setPrompt] = useState({
+    visible: false,
+    title: '',
+    message: '',
+    value: '',
+    placeholder: '',
+    confirmLabel: '',
+    cancelLabel: '',
+    keyboardType: 'default',
+    resolve: null,
+  });
+
+  const showToast = (message, options = {}) => {
+    return toast(normalizeMessage(message), normalizeOptions(options, 'center'));
+  };
+
+  // Backward-compatible aliases used by older module code
+  const showSuccess = (message, options = {}) => {
+    return toast.success(
+      normalizeMessage(message),
+      normalizeOptions(
+        {position: 'top', offsetTop: TOAST_DEFAULT_TOP_OFFSET, ...options},
+        'top',
+      ),
+    );
+  };
+
+  const showError = (message, options = {}) => {
+    return publishSystemError(message, options)
+  };
+
+  const showWarning = (message, options = {}) => {
+    return showToast(
+      message,
+      withWarningToastStyles({
+        position: 'top',
+        offsetTop: TOAST_DEFAULT_TOP_OFFSET,
+        ...options,
+      }),
+    );
+  };
+
+  const showInfo = (message, options = {}) => {
+    return showToast(message, {
+      position: 'top',
+      offsetTop: TOAST_DEFAULT_TOP_OFFSET,
+      ...options,
+    });
+  };
+
+  useEffect(() => {
+    return subscribeSystemErrors(({error, message, options = {}}) => {
+      toast.error(
+        <SystemErrorToast error={error || message} />,
+        normalizeOptions(
+          withErrorToastStyles({
+            position: 'top',
+            offsetTop: TOAST_DEFAULT_TOP_OFFSET,
+            ...options,
+          }),
+          'top',
+        ),
+      )
+    })
+  }, [])
+
+  const showDialog = ({title, message, onConfirm, onCancel}) => {
+    setDialog({
+      visible: true,
+      title,
+      message,
+      onConfirm,
+      onCancel,
+    });
+  };
+
+  const hideDialog = () => setDialog(d => ({...d, visible: false}));
+
+  const hidePrompt = () =>
+    setPrompt({
+      visible: false,
+      title: '',
+      message: '',
+      value: '',
+      placeholder: '',
+      confirmLabel: '',
+      cancelLabel: '',
+      keyboardType: 'default',
+      resolve: null,
+    });
+
+  const showPrompt = ({
+    title,
+    message,
+    defaultValue = '',
+    placeholder = '',
+    confirmLabel = '',
+    cancelLabel = '',
+    keyboardType = 'default',
+  }) =>
+    new Promise(resolve => {
+      setPrompt({
+        visible: true,
+        title: normalizeMessage(title),
+        message: normalizeMessage(message),
+        value: normalizeMessage(defaultValue),
+        placeholder: normalizeMessage(placeholder),
+        confirmLabel: normalizeMessage(confirmLabel),
+        cancelLabel: normalizeMessage(cancelLabel),
+        keyboardType,
+        resolve,
+      });
+    });
+
+  return (
+    <MessageContext.Provider
+      value={{
+        showToast,
+        showDialog,
+        showPrompt,
+        showSuccess,
+        showError,
+        showWarning,
+        showInfo,
+      }}>
+      {children}
+
+      <Portal>
+        <Dialog visible={dialog.visible} onDismiss={hideDialog}>
+          <Dialog.Title>{dialog.title}</Dialog.Title>
+          <Dialog.Content>
+            <Paragraph>{dialog.message}</Paragraph>
+          </Dialog.Content>
+          <Dialog.Actions>
+            <Button
+              onPress={() => {
+                hideDialog();
+                dialog.onCancel?.();
+              }}>
+              Cancelar
+            </Button>
+            <Button
+              onPress={() => {
+                hideDialog();
+                dialog.onConfirm?.();
+              }}>
+              Confirmar
+            </Button>
+          </Dialog.Actions>
+        </Dialog>
+
+        <Dialog
+          visible={prompt.visible}
+          onDismiss={() => {
+            prompt.resolve?.(null);
+            hidePrompt();
+          }}>
+          <Dialog.Title>{prompt.title}</Dialog.Title>
+          <Dialog.Content>
+            {!!prompt.message && <Paragraph>{prompt.message}</Paragraph>}
+            <PaperTextInput
+              autoFocus
+              mode="outlined"
+              value={prompt.value}
+              onChangeText={value => {
+                setPrompt(currentPrompt => ({
+                  ...currentPrompt,
+                  value,
+                }));
+              }}
+              keyboardType={prompt.keyboardType || 'default'}
+              placeholder={prompt.placeholder}
+              returnKeyType="done"
+              onSubmitEditing={() => {
+                const resolvedValue = String(prompt.value || '').trim();
+                prompt.resolve?.(resolvedValue || null);
+                hidePrompt();
+              }}
+            />
+          </Dialog.Content>
+          <Dialog.Actions>
+            <Button
+              onPress={() => {
+                prompt.resolve?.(null);
+                hidePrompt();
+              }}>
+              {prompt.cancelLabel || 'Cancelar'}
+            </Button>
+            <Button
+              onPress={() => {
+                const resolvedValue = String(prompt.value || '').trim();
+                prompt.resolve?.(resolvedValue || null);
+                hidePrompt();
+              }}>
+              {prompt.confirmLabel || 'Confirmar'}
+            </Button>
+          </Dialog.Actions>
+        </Dialog>
+      </Portal>
+    </MessageContext.Provider>
+  );
+};