Skip to content

The open alternative to Salesforce, designed for AI.

5.7 KB
Raw Blame
import { currentUserState } from '@/auth/states/currentUserState';
import { useUpdateGettingStarted } from '@/getting-started/hooks/useUpdateGettingStarted';
import { getValidInviteEmails } from '@/onboarding/utils/getValidInviteEmails';
import { TextInput } from '@/ui/input/components/TextInput';
import { useAtomStateValue } from '@/ui/utilities/state/jotai/hooks/useAtomStateValue';
import { useCreateWorkspaceInvitation } from '@/workspace-invitation/hooks/useCreateWorkspaceInvitation';
import { useQuery } from '@apollo/client/react';
import { styled } from '@linaria/react';
import { useLingui } from '@lingui/react/macro';
import { isNonEmptyString } from '@sniptt/guards';
import { type FormEvent, useState } from 'react';
import { isDefined, isNonEmptyArray } from 'twenty-shared/utils';
import { useToast } from 'twenty-ui/components/feedback';
import { IconX } from 'twenty-ui/icon';
import { Button } from 'twenty-ui/primitives/input';
import { Text } from 'twenty-ui/primitives/typography';
import { themeCssVariables } from 'twenty-ui/theme';
import {
  GetInviteSuggestionsDocument,
  GettingStartedStepActionKey,
} from '~/generated-metadata/graphql';

const StyledForm = styled.form`
  display: flex;
  flex-direction: column;
  gap: ${themeCssVariables.spacing[4]};
`;

const StyledEmailField = styled.div`
  display: flex;
  flex-direction: column;
  gap: ${themeCssVariables.spacing[1]};
`;

const StyledEmailInputs = styled.div`
  display: flex;
  flex-direction: column;
  gap: ${themeCssVariables.spacing[4]};
`;

const StyledFooter = styled.div`
  display: flex;
`;

export const GettingStartedInviteAction = () => {
  const { t } = useLingui();
  const { enqueueToast } = useToast();
  const { updateGettingStarted } = useUpdateGettingStarted();
  const { sendInvitation } = useCreateWorkspaceInvitation();
  const currentUser = useAtomStateValue(currentUserState);
  const emailDomain = currentUser?.email.split('@').at(1);
  const emailPlaceholder = isNonEmptyString(emailDomain)
    ? t`name@${emailDomain}`
    : t`Email address`;
  const { data } = useQuery(GetInviteSuggestionsDocument, {
    fetchPolicy: 'cache-first',
  });
  const [draftEmails, setDraftEmails] = useState<string[] | null>(null);
  const [isSending, setIsSending] = useState(false);

  const suggestedEmails = (data?.getInviteSuggestions ?? []).map(
    (suggestion) => suggestion.email,
  );
  const emails = draftEmails ?? [...suggestedEmails, ''];
  const validEmails = getValidInviteEmails(emails);
  const hasSuggestedEmail = emails.some((email) =>
    suggestedEmails.includes(email),
  );

  const isInvalidEmail = (email: string) =>
    isNonEmptyString(email) && !isNonEmptyArray(getValidInviteEmails([email]));

  const hasInvalidEmail = emails.some(isInvalidEmail);

  const saveDraftEmails = (nextEmails: string[]) => {
    const lastFilledEmailIndex = nextEmails.findLastIndex(isNonEmptyString);

    setDraftEmails([...nextEmails.slice(0, lastFilledEmailIndex + 1), '']);
  };

  const updateEmail = ({ index, email }: { index: number; email: string }) =>
    saveDraftEmails(
      emails.map((currentEmail, emailIndex) =>
        emailIndex === index ? email : currentEmail,
      ),
    );

  const removeEmail = (index: number) =>
    saveDraftEmails(emails.filter((_, emailIndex) => emailIndex !== index));

  const sendInvitations = async (event: FormEvent<HTMLFormElement>) => {
    event.preventDefault();
    setIsSending(true);

    try {
      const { data: sendInvitationsData } = await sendInvitation({
        emails: validEmails,
      });

      if (!isDefined(sendInvitationsData)) {
        return;
      }

      const { result: invitations, errors } =
        sendInvitationsData.sendInvitations;

      if (isNonEmptyArray(errors)) {
        enqueueToast({ status: 'error', children: errors.join(', ') });
      }

      if (invitations.length === 0) {
        return;
      }

      const invitedEmails = invitations.map((invitation) =>
        invitation.email.toLowerCase(),
      );

      setDraftEmails([
        ...validEmails.filter((email) => !invitedEmails.includes(email)),
        '',
      ]);
      enqueueToast({
        status: 'success',
        children: t`Invite link sent to email addresses`,
      });
      void updateGettingStarted({
        completedStepActionKey: GettingStartedStepActionKey.INVITE_TEAM,
      });
    } finally {
      setIsSending(false);
    }
  };

  return (
    <StyledForm onSubmit={(event) => void sendInvitations(event)}>
      <StyledEmailField>
        {hasSuggestedEmail && (
          <Text size="xs" color="light">{t`Found in your emails`}</Text>
        )}
        <StyledEmailInputs>
          {emails.map((email, index) => {
            const emailNumber = index + 1;
            const isLastInput = index === emails.length - 1;

            return (
              <TextInput
                key={index}
                type="email"
                value={email}
                error={isInvalidEmail(email) ? t`Invalid email` : undefined}
                noErrorHelper
                aria-label={t`Teammate email ${emailNumber}`}
                placeholder={emailPlaceholder}
                disabled={isSending}
                onChange={(text) => updateEmail({ index, email: text })}
                RightIcon={isLastInput ? undefined : IconX}
                onRightIconClick={
                  isLastInput ? undefined : () => removeEmail(index)
                }
                fullWidth
              />
            );
          })}
        </StyledEmailInputs>
      </StyledEmailField>
      <StyledFooter>
        <Button
          type="submit"
          variant="solid"
          color="accent"
          loading={isSending}
          disabled={validEmails.length === 0 || hasInvalidEmail}
        >{t`Invite`}</Button>
      </StyledFooter>
    </StyledForm>
  );
};