Skip to content

The open alternative to Salesforce, designed for AI.

6.1 KB
Raw Blame
import { zodResolver } from '@hookform/resolvers/zod';
import { styled } from '@linaria/react';
import { useEffect } from 'react';
import { Controller, useForm } from 'react-hook-form';
import { z } from 'zod';

import { type RoleWithPartialMembers } from '@/settings/roles/types/RoleWithPartialMembers';
import { Select } from '@/ui/input/components/Select';
import { SettingsTextInput } from '@/ui/input/components/SettingsTextInput';
import { useCreateWorkspaceInvitation } from '@/workspace-invitation/hooks/useCreateWorkspaceInvitation';
import { sanitizeEmailList } from '@/workspace/utils/sanitizeEmailList';
import { i18n } from '@lingui/core';
import { msg, t } from '@lingui/core/macro';
import { useLingui } from '@lingui/react/macro';
import { isDefined } from 'twenty-shared/utils';
import { doNotTranslate } from 'twenty-shared/i18n';
import { useToast } from 'twenty-ui/components/feedback';
import {
  IconLock,
  IconSend,
  IconUser,
  type IconComponent,
} from 'twenty-ui/icon';
import { useIcons } from 'twenty-ui/icon/provider';
import { Button } from 'twenty-ui/primitives/input';
import { MOBILE_VIEWPORT, themeCssVariables } from 'twenty-ui/theme';

const StyledContainer = styled.div`
  align-items: center;
  display: flex;
  flex-direction: row;
  gap: ${themeCssVariables.spacing[2]};
  padding-bottom: ${themeCssVariables.spacing[3]};

  @media (max-width: ${MOBILE_VIEWPORT}px) {
    flex-wrap: wrap;
  }
`;

const StyledLinkContainer = styled.div`
  flex: 1 1 auto;
  min-width: 0;

  @media (max-width: ${MOBILE_VIEWPORT}px) {
    flex: 1 1 100%;
  }
`;

const StyledRoleContainer = styled.div`
  flex: 0 0 130px;
  min-width: 130px;

  @media (max-width: ${MOBILE_VIEWPORT}px) {
    flex: 1 1 100%;
  }
`;

const emailsEmptyErrorMessage = msg`Emails should not be empty`;

const validationSchema = z.object({
  emails: z.string().superRefine((value, ctx) => {
    if (!value.length) {
      return;
    }
    const emails = sanitizeEmailList(value.split(','));
    if (emails.length === 0) {
      ctx.addIssue({
        code: 'custom',
        message: i18n._(emailsEmptyErrorMessage),
      });
    }
    const invalidEmails: string[] = [];
    for (const email of emails) {
      const result = z.email().safeParse(email);
      if (!result.success) {
        invalidEmails.push(email);
      }
    }
    if (invalidEmails.length > 0) {
      const invalidEmailsList = invalidEmails.join(', ');
      ctx.addIssue({
        code: 'custom',
        message:
          invalidEmails.length > 1
            ? t`Invalid emails: ${invalidEmailsList}`
            : t`Invalid email: ${invalidEmailsList}`,
      });
    }
  }),
  roleId: z.string().optional(),
});

type FormInput = {
  emails: string;
  roleId?: string;
};

type WorkspaceInviteTeamProps = {
  roles: RoleWithPartialMembers[];
};

export const WorkspaceInviteTeam = ({ roles }: WorkspaceInviteTeamProps) => {
  const { t } = useLingui();
  const { getIcon } = useIcons();

  const { enqueueToast } = useToast();
  const { sendInvitation } = useCreateWorkspaceInvitation();

  const roleOptions: Array<{
    label: string;
    value: string;
    Icon?: IconComponent;
  }> = roles
    .filter((role) => role.canBeAssignedToUsers)
    .map((role) => ({
      label: role.label,
      value: role.id,
      Icon: getIcon(role.icon) ?? IconUser,
    }));

  const emptyRoleOption = {
    label: t`Default role`,
    value: '',
    Icon: IconLock,
  };

  const { reset, handleSubmit, control, formState, watch } = useForm<FormInput>(
    {
      mode: 'onSubmit',
      resolver: zodResolver(validationSchema),
      defaultValues: {
        emails: '',
        roleId: '',
      },
    },
  );
  const isEmailsEmpty = !watch('emails');

  const submit = handleSubmit(async ({ emails, roleId }) => {
    const emailsList = sanitizeEmailList(emails.split(','));
    const { data } = await sendInvitation({
      emails: emailsList,
      ...(roleId ? { roleId } : {}),
    });
    if (!isDefined(data)) {
      return;
    }

    if (data.sendInvitations.result.length > 0) {
      const invitationCount = data.sendInvitations.result.length;
      enqueueToast({
        status: 'success',
        children: t`${invitationCount} invitations sent`,
        duration: 2000,
      });

      return;
    }

    if (!data.sendInvitations.success) {
      enqueueToast({
        status: 'error',
        children: data.sendInvitations.errors.join(', '),
        duration: 5000,
      });
    }
  });

  const { isSubmitSuccessful, errors } = formState;

  useEffect(() => {
    if (isSubmitSuccessful) {
      reset();
    }
  }, [isSubmitSuccessful, reset]);

  return (
    <form onSubmit={submit}>
      <StyledContainer>
        <StyledLinkContainer>
          <Controller
            name="emails"
            control={control}
            render={({ field: { value, onChange }, fieldState: { error } }) => {
              return (
                <SettingsTextInput
                  instanceId="workspace-invite-team-emails"
                  placeholder={doNotTranslate(
                    '[email protected], [email protected]',
                  )}
                  value={value}
                  onChange={onChange}
                  error={error?.message}
                  fullWidth
                />
              );
            }}
          />
        </StyledLinkContainer>
        <StyledRoleContainer>
          <Controller
            name="roleId"
            control={control}
            render={({ field: { value, onChange } }) => {
              return (
                <Select
                  dropdownId="workspace-invite-team-role"
                  options={roleOptions}
                  emptyOption={emptyRoleOption}
                  value={value}
                  onChange={onChange}
                  withSearchInput
                  fullWidth
                  disabled={roleOptions.length === 0}
                />
              );
            }}
          />
        </StyledRoleContainer>
        <Button
          startIcon={<IconSend />}
          type="submit"
          disabled={isEmailsEmpty || !!errors.emails}
          variant="solid"
          color="accent"
        >{t`Invite`}</Button>
      </StyledContainer>
    </form>
  );
};