Skip to content

The open alternative to Salesforce, designed for AI.

6.3 KB
Raw Blame
import { useCallback } from 'react';

import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
import { DateFormat } from '@/localization/constants/DateFormat';
import { NumberFormat } from '@/localization/constants/NumberFormat';
import { TimeFormat } from '@/localization/constants/TimeFormat';
import {
  workspaceMemberFormatPreferencesState,
  type WorkspaceMemberFormatPreferences,
} from '@/localization/states/workspaceMemberFormatPreferencesState';
import { detectCalendarStartDay } from '@/localization/utils/detection/detectCalendarStartDay';
import { detectDateFormat } from '@/localization/utils/detection/detectDateFormat';
import { detectNumberFormat } from '@/localization/utils/detection/detectNumberFormat';
import { detectTimeFormat } from '@/localization/utils/detection/detectTimeFormat';
import { detectTimeZone } from '@/localization/utils/detection/detectTimeZone';
import { getFormatPreferencesFromWorkspaceMember } from '@/localization/utils/format-preferences/getFormatPreferencesFromWorkspaceMember';
import { getWorkspaceMemberUpdateFromFormatPreferences } from '@/localization/utils/format-preferences/getWorkspaceMemberUpdateFromFormatPreferences';
import { useUpdateWorkspaceMemberSettings } from '@/workspace-member/hooks/useUpdateWorkspaceMemberSettings';
import { useAtomState } from '@/ui/utilities/state/jotai/hooks/useAtomState';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { CalendarStartDay } from 'twenty-shared/constants';
import { logError } from '~/utils/logError';

export type FormatPreferenceKey = keyof WorkspaceMemberFormatPreferences;

export const useFormatPreferences = () => {
  const [
    workspaceMemberFormatPreferences,
    setWorkspaceMemberFormatPreferences,
  ] = useAtomState(workspaceMemberFormatPreferencesState);
  const currentWorkspaceMember = useAtomStateValue(currentWorkspaceMemberState);

  const { updateWorkspaceMemberSettings } = useUpdateWorkspaceMemberSettings();

  const updateFormatPreference = useCallback(
    async <K extends FormatPreferenceKey>(
      key: K,
      value: WorkspaceMemberFormatPreferences[K],
    ) => {
      if (!currentWorkspaceMember?.id) {
        logError('User is not logged in');
        return;
      }

      let resolvedValue = value;
      if (
        value === 'SYSTEM' ||
        value === 'system' ||
        value === CalendarStartDay.SYSTEM
      ) {
        switch (key) {
          case 'timeZone':
            resolvedValue =
              detectTimeZone() as WorkspaceMemberFormatPreferences[K];
            break;
          case 'dateFormat':
            resolvedValue = DateFormat[
              detectDateFormat()
            ] as WorkspaceMemberFormatPreferences[K];
            break;
          case 'timeFormat':
            resolvedValue = TimeFormat[
              detectTimeFormat()
            ] as WorkspaceMemberFormatPreferences[K];
            break;
          case 'numberFormat':
            resolvedValue = NumberFormat[
              detectNumberFormat()
            ] as WorkspaceMemberFormatPreferences[K];
            break;
          case 'calendarStartDay':
            resolvedValue = CalendarStartDay[
              detectCalendarStartDay()
            ] as WorkspaceMemberFormatPreferences[K];
            break;
        }
      }

      setWorkspaceMemberFormatPreferences(
        (prev: WorkspaceMemberFormatPreferences) => ({
          ...prev,
          [key]: resolvedValue,
        }),
      );

      const workspaceMemberUpdate =
        getWorkspaceMemberUpdateFromFormatPreferences({
          [key]: value, // Use original value (including SYSTEM) for backend
        });

      try {
        await updateWorkspaceMemberSettings({
          workspaceMemberId: currentWorkspaceMember.id,
          update: workspaceMemberUpdate,
        });
      } catch (error) {
        logError(error);
        throw error;
      }
    },
    [
      currentWorkspaceMember,
      updateWorkspaceMemberSettings,
      setWorkspaceMemberFormatPreferences,
    ],
  );

  const updateMultipleFormatPreferences = useCallback(
    async (updates: Partial<WorkspaceMemberFormatPreferences>) => {
      if (!currentWorkspaceMember?.id) {
        logError('User is not logged in');
        return;
      }

      const resolvedUpdates = { ...updates };
      Object.entries(updates).forEach(([key, value]) => {
        if (
          value === 'SYSTEM' ||
          value === 'system' ||
          value === CalendarStartDay.SYSTEM
        ) {
          switch (key) {
            case 'timeZone':
              resolvedUpdates.timeZone = detectTimeZone();
              break;
            case 'dateFormat':
              resolvedUpdates.dateFormat = DateFormat[detectDateFormat()];
              break;
            case 'timeFormat':
              resolvedUpdates.timeFormat = TimeFormat[detectTimeFormat()];
              break;
            case 'numberFormat':
              resolvedUpdates.numberFormat = NumberFormat[detectNumberFormat()];
              break;
            case 'calendarStartDay':
              resolvedUpdates.calendarStartDay =
                CalendarStartDay[detectCalendarStartDay()];
              break;
          }
        }
      });

      setWorkspaceMemberFormatPreferences((prev) => ({
        ...prev,
        ...resolvedUpdates,
      }));

      const workspaceMemberUpdate =
        getWorkspaceMemberUpdateFromFormatPreferences(updates);

      try {
        await updateWorkspaceMemberSettings({
          workspaceMemberId: currentWorkspaceMember.id,
          update: workspaceMemberUpdate,
        });
      } catch (error) {
        logError(error);
        throw error;
      }
    },
    [
      currentWorkspaceMember,
      updateWorkspaceMemberSettings,
      setWorkspaceMemberFormatPreferences,
    ],
  );

  const initializeFormatPreferences = useCallback(
    (workspaceMember: typeof currentWorkspaceMember) => {
      if (!workspaceMember) return;

      const preferences =
        getFormatPreferencesFromWorkspaceMember(workspaceMember);
      setWorkspaceMemberFormatPreferences(preferences);
    },
    [setWorkspaceMemberFormatPreferences],
  );

  return {
    formatPreferences: workspaceMemberFormatPreferences,
    updateFormatPreference,
    updateMultipleFormatPreferences,
    initializeFormatPreferences,
  };
};