Skip to content

The open alternative to Salesforce, designed for AI.

6.7 KB
Raw Blame
import { useIsLogged } from '@/auth/hooks/useIsLogged';
import { toOpenRecordInPreference } from '@/workspace-member/utils/toOpenRecordInPreference';
import { availableWorkspacesState } from '@/auth/states/availableWorkspacesState';
import { currentUserState } from '@/auth/states/currentUserState';
import { currentUserWorkspaceState } from '@/auth/states/currentUserWorkspaceState';
import { currentWorkspaceDeletedMembersState } from '@/auth/states/currentWorkspaceDeletedMembersState';
import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
import { currentWorkspaceMembersState } from '@/auth/states/currentWorkspaceMembersState';
import { currentWorkspaceState } from '@/auth/states/currentWorkspaceState';
import { isCurrentUserLoadedState } from '@/auth/states/isCurrentUserLoadedState';
import { useInitializeFormatPreferences } from '@/localization/hooks/useInitializeFormatPreferences';
import { getDateFnsLocale } from '@/ui/field/display/utils/getDateFnsLocale';
import { useSetAtomState } from '@/ui/utilities/state/jotai/hooks/useSetAtomState';
import { enUS } from 'date-fns/locale';
import { useStore } from 'jotai';
import { useCallback, useEffect, useState } from 'react';
import { type APP_LOCALES, SOURCE_LOCALE } from 'twenty-shared/translations';
import { type CurrentUserWorkspaceObjectPermissions } from '@/auth/types/CurrentUserWorkspaceObjectPermissions';
import { isDefined } from 'twenty-shared/utils';
import { doNotTranslate } from 'twenty-shared/i18n';
import { useQuery } from '@apollo/client/react';
import {
  type WorkspaceMember,
  GetCurrentUserDocument,
} from '~/generated-metadata/graphql';
import { dateLocaleState } from '@/localization/states/dateLocaleState';
import { dynamicActivate } from '~/utils/i18n/dynamicActivate';
import { type ColorScheme } from '@/ui/theme/types/ColorScheme';
import { type UiScale } from '@/ui/theme/types/UiScale';

export const UserMetadataProviderInitialEffect = () => {
  const isLogged = useIsLogged();
  const store = useStore();
  const [isInitialized, setIsInitialized] = useState(false);

  const setCurrentUser = useSetAtomState(currentUserState);
  const setCurrentWorkspace = useSetAtomState(currentWorkspaceState);
  const setCurrentUserWorkspace = useSetAtomState(currentUserWorkspaceState);
  const setAvailableWorkspaces = useSetAtomState(availableWorkspacesState);
  const setCurrentWorkspaceMember = useSetAtomState(
    currentWorkspaceMemberState,
  );
  const setCurrentWorkspaceMembers = useSetAtomState(
    currentWorkspaceMembersState,
  );
  const setCurrentWorkspaceDeletedMembers = useSetAtomState(
    currentWorkspaceDeletedMembersState,
  );
  const setIsCurrentUserLoaded = useSetAtomState(isCurrentUserLoadedState);

  const { initializeFormatPreferences } = useInitializeFormatPreferences();

  const updateLocaleCatalog = useCallback(
    async (newLocale: keyof typeof APP_LOCALES) => {
      const localeValue = store.get(dateLocaleState.atom);
      if (localeValue.locale !== newLocale) {
        getDateFnsLocale(newLocale).then((localeCatalog) => {
          const newValue = {
            locale: newLocale,
            localeCatalog: localeCatalog || enUS,
          };
          store.set(dateLocaleState.atom, newValue);
        });
      }
    },
    [store],
  );

  const shouldSkipUserQuery = !isLogged;

  const { data: userQueryData, loading: userQueryLoading } = useQuery(
    GetCurrentUserDocument,
    {
      skip: shouldSkipUserQuery,
      fetchPolicy: 'network-only',
    },
  );

  useEffect(() => {
    if (isInitialized) {
      return;
    }

    if (!isLogged) {
      setIsCurrentUserLoaded(true);
      setIsInitialized(true);
      return;
    }

    if (userQueryLoading || !isDefined(userQueryData?.currentUser)) {
      return;
    }

    setCurrentUser(userQueryData.currentUser);

    if (isDefined(userQueryData.currentUser.currentWorkspace)) {
      setCurrentWorkspace({
        ...userQueryData.currentUser.currentWorkspace,
        defaultRole:
          userQueryData.currentUser.currentWorkspace.defaultRole ?? null,
        workspaceCustomApplication:
          userQueryData.currentUser.currentWorkspace
            .workspaceCustomApplication ?? null,
      });
    }

    if (isDefined(userQueryData.currentUser.currentUserWorkspace)) {
      setCurrentUserWorkspace({
        permissionFlags:
          userQueryData.currentUser.currentUserWorkspace.permissionFlags ?? [],
        twoFactorAuthenticationMethodSummary:
          userQueryData.currentUser.currentUserWorkspace
            .twoFactorAuthenticationMethodSummary ?? [],
        objectsPermissions:
          (userQueryData.currentUser.currentUserWorkspace
            .objectsPermissions as CurrentUserWorkspaceObjectPermissions[]) ??
          [],
        isImpersonating:
          userQueryData.currentUser.currentUserWorkspace.isImpersonating ??
          false,
      });
    }

    const {
      workspaceMember,
      workspaceMembers,
      deletedWorkspaceMembers,
      availableWorkspaces,
    } = userQueryData.currentUser;

    const affectDefaultValuesOnEmptyWorkspaceMemberFields = (
      workspaceMember: WorkspaceMember,
    ) => {
      return {
        ...workspaceMember,
        colorScheme:
          (workspaceMember.colorScheme as ColorScheme) ??
          doNotTranslate('System'),
        uiScale:
          (workspaceMember.uiScale as UiScale) ?? doNotTranslate('Default'),
        openRecordIn: toOpenRecordInPreference(workspaceMember.openRecordIn),
        locale:
          (workspaceMember.locale as keyof typeof APP_LOCALES) ?? SOURCE_LOCALE,
      };
    };

    if (isDefined(workspaceMember)) {
      const updatedWorkspaceMember =
        affectDefaultValuesOnEmptyWorkspaceMemberFields(workspaceMember);
      setCurrentWorkspaceMember(updatedWorkspaceMember);

      updateLocaleCatalog(updatedWorkspaceMember.locale);

      initializeFormatPreferences(updatedWorkspaceMember);

      dynamicActivate(
        (workspaceMember.locale as keyof typeof APP_LOCALES) ?? SOURCE_LOCALE,
      );
    }

    if (isDefined(workspaceMembers)) {
      setCurrentWorkspaceMembers(workspaceMembers);
    }

    if (isDefined(deletedWorkspaceMembers)) {
      setCurrentWorkspaceDeletedMembers(deletedWorkspaceMembers);
    }

    if (isDefined(availableWorkspaces)) {
      setAvailableWorkspaces(availableWorkspaces);
    }

    setIsCurrentUserLoaded(true);
    setIsInitialized(true);
  }, [
    isInitialized,
    isLogged,
    userQueryLoading,
    userQueryData?.currentUser,
    setCurrentUser,
    setCurrentUserWorkspace,
    setCurrentWorkspaceMembers,
    setAvailableWorkspaces,
    setCurrentWorkspace,
    setCurrentWorkspaceMember,
    initializeFormatPreferences,
    setCurrentWorkspaceDeletedMembers,
    updateLocaleCatalog,
    setIsCurrentUserLoaded,
  ]);

  return null;
};