Skip to content

The open alternative to Salesforce, designed for AI.

3.6 KB
Raw Blame
import { createGraphColorRegistry } from '@/page-layout/widgets/graph/utils/createGraphColorRegistry';
import { getColorSchemeByIndex } from '@/page-layout/widgets/graph/utils/getColorSchemeByIndex';
import { SubscriptionInfoContainer } from '@/settings/billing/components/SubscriptionInfoContainer';
import { UsagePieChart } from '@/settings/usage/components/UsagePieChart';
import { UsageSectionSkeleton } from '@/settings/usage/components/UsageSectionSkeleton';
import { useUsageAnalyticsData } from '@/settings/usage/hooks/useUsageAnalyticsData';
import { useUsageValueFormatter } from '@/settings/usage/hooks/useUsageValueFormatter';
import { getUsageOperationTypeLabel } from '@/settings/usage/utils/getUsageOperationTypeLabel';
import { Select } from '@/ui/input/components/Select';
import { useLingui } from '@lingui/react/macro';
import { isDefined } from 'twenty-shared/utils';
import { Section } from 'twenty-ui/components/layout';
import { useTheme } from 'twenty-ui/theme';
import { type UsageOperationType } from '~/generated-metadata/graphql';

type UsageBreakdownField = 'operationType' | 'application' | 'model';

type UsageBreakdownPieSectionProps = {
  title: string;
  description?: string;
  operationTypes?: UsageOperationType[];
  userWorkspaceId?: string;
  skip?: boolean;
  breakdownField: UsageBreakdownField;
  sectionId: string;
};

export const UsageBreakdownPieSection = ({
  title,
  description,
  operationTypes,
  userWorkspaceId,
  skip,
  breakdownField,
  sectionId,
}: UsageBreakdownPieSectionProps) => {
  const theme = useTheme();
  const { t } = useLingui();
  const { formatUsageValue } = useUsageValueFormatter();
  const colorRegistry = createGraphColorRegistry(theme.color);

  const { analytics, isInitialLoading, period, setPeriod, periodOptions } =
    useUsageAnalyticsData({
      operationTypes,
      userWorkspaceId,
      skip,
    });

  if (isInitialLoading) {
    return <UsageSectionSkeleton />;
  }

  if (!analytics) {
    return null;
  }

  const breakdownDataByField = {
    operationType: analytics.usageByOperationType,
    application: analytics.usageByApplication,
    model: analytics.usageByModel,
  };
  const breakdownData = breakdownDataByField[breakdownField];

  if (breakdownData.length === 0) {
    return null;
  }

  const total = breakdownData.reduce(
    (sum, item) => sum + item.workspaceCreditsUsed,
    0,
  );

  // Operation types are a fixed vocabulary translated here; other breakdowns name workspace data only the server resolves
  const formatLabel = ({
    key,
    label,
  }: {
    key: string;
    label?: string | null;
  }) => {
    if (breakdownField !== 'operationType') {
      return label ?? key;
    }

    const operationTypeLabel = getUsageOperationTypeLabel(key);

    return isDefined(operationTypeLabel) ? t(operationTypeLabel) : key;
  };

  const pieData = breakdownData.map((item, index) => ({
    id: formatLabel(item),
    value: item.workspaceCreditsUsed,
    color: getColorSchemeByIndex(colorRegistry, index).solid,
  }));

  const resolvedDescription = description ?? formatUsageValue(total);

  return (
    <Section.Root>
      <Section.Header
        title={title}
        description={resolvedDescription}
        actions={
          <Select
            dropdownId={`${sectionId}-period`}
            value={period}
            options={periodOptions}
            onChange={setPeriod}
            needIconCheck
            selectSizeVariant="small"
          />
        }
      />
      <SubscriptionInfoContainer>
        <UsagePieChart data={pieData} />
      </SubscriptionInfoContainer>
    </Section.Root>
  );
};