Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

10.7 KB
Raw Blame
defmodule PlausibleWeb.Live.RegisterForm do
  @moduledoc """
  LiveView for registration form.
  """

  use PlausibleWeb, :live_view

  alias Plausible.Auth
  alias Plausible.Repo
  alias Plausible.Teams
  alias PlausibleWeb.Layouts

  @signup_error_categories %{
    name: "name",
    email: "email",
    password: "password"
  }

  def mount(params, _session, socket) do
    socket =
      socket
      |> assign(:legacy_layout?, false)
      |> assign_new(:invitation, fn ->
        if invitation_id = params["invitation_id"] do
          find_by_id_unified(invitation_id)
        end
      end)
      |> assign_new(:team_identifier, fn %{invitation: invitation} ->
        if invitation do
          invitation.team_identifier
        end
      end)

    if socket.assigns.live_action == :register_from_invitation_form and
         socket.assigns.invitation == nil do
      {:ok, redirect(socket, to: "/invitation-expired")}
    else
      changeset =
        if invitation = socket.assigns.invitation do
          Auth.User.settings_changeset(%Auth.User{email: invitation.email})
        else
          Auth.User.settings_changeset(%Auth.User{})
        end

      {heading, subtitle} = heading_and_subtitle(socket.assigns.live_action)

      {:ok,
       assign(socket,
         form: to_form(changeset),
         captcha_error: nil,
         password_strength: Auth.User.password_strength(changeset),
         disable_submit: false,
         signup_previous_error: nil,
         trigger_submit: false,
         heading: heading,
         subtitle: subtitle
       )}
    end
  end

  defp heading_and_subtitle(:register_from_invitation_form) do
    {"Create your account", "Accept your invitation to join your team."}
  end

  defp heading_and_subtitle(:register_form) do
    if ce?() do
      {"Create your #{Plausible.product_name()} account",
       "Start tracking privacy-friendly analytics in minutes."}
    else
      {"Start your 30-day free trial", "No credit card required. Cancel anytime."}
    end
  end

  def render(assigns) do
    ~H"""
    <Layouts.auth heading={@heading} subtitle={@subtitle} flash={@flash}>
      <.auth_container>
        <.form
          :let={f}
          for={@form}
          id="register-form"
          class="flex flex-col gap-y-6"
          action={~p"/login"}
          onsubmit={form_submit_event(@invitation, @signup_previous_error)}
          phx-change="validate"
          phx-submit="register"
          phx-trigger-action={@trigger_submit}
        >
          <input name="user[register_action]" type="hidden" value={@live_action} />
          <input
            :if={@team_identifier}
            name="user[team_identifier]"
            type="hidden"
            value={@team_identifier}
          />

          <%= if @invitation do %>
            <.email_input field={f[:email]} for_invitation={true} />
            <.name_input field={f[:name]} />
          <% else %>
            <.name_input field={f[:name]} />
            <.email_input field={f[:email]} for_invitation={false} />
          <% end %>

          <div class="flex flex-col gap-y-2">
            <label
              for={f[:password].id}
              class="text-sm font-semibold text-gray-800 dark:text-gray-200"
            >
              Password
            </label>
            <div>
              <.password_input_with_strength
                field={f[:password]}
                strength={@password_strength}
                phx-debounce={200}
              />
            </div>
            <.password_length_hint minimum={12} field={f[:password]} hide_when_used?={true} />
          </div>

          <%= if PlausibleWeb.Captcha.enabled?() do %>
            <PlausibleWeb.Components.Captcha.widget error={@captcha_error} />
          <% end %>

          <div class="flex flex-col gap-y-4">
            <% submit_text =
              if ce?() or @invitation do
                "Create my account"
              else
                "Start my free trial"
              end %>
            <.button
              id="register"
              type="submit"
              class="w-full"
              x-data={"{ captchaReady: #{not PlausibleWeb.Captcha.enabled?()} }"}
              x-on:frc-captcha-ready.window="captchaReady = true"
              x-on:frc-captcha-reset.window="captchaReady = false"
              x-bind:disabled={"!captchaReady || #{@disable_submit}"}
            >
              {submit_text}
            </.button>

            <p class="text-sm text-center text-gray-500 dark:text-gray-400">
              Already have an account?
              <.styled_link href="/login">
                Sign in
              </.styled_link>
            </p>
          </div>
        </.form>
      </.auth_container>
    </Layouts.auth>
    """
  end

  on_ee do
    defp form_submit_event(invitation, previous_error) do
      options = Jason.encode!(%{"props" => %{"previous_error" => previous_error || "none"}})

      "window.plausible('Signup#{if invitation, do: " via invitation"}', #{options})"
    end
  else
    defp form_submit_event(_, _), do: ""
  end

  defp name_input(assigns) do
    ~H"""
    <div class="flex flex-col gap-y-2">
      <label for={@field.id} class="text-sm font-semibold text-gray-800 dark:text-gray-200">
        Full name
      </label>
      <div>
        <.input
          field={@field}
          placeholder="Jane Doe"
          phx-debounce={200}
          autofocus="autofocus"
        />
      </div>
    </div>
    """
  end

  defp email_input(assigns) do
    email_readonly =
      if assigns[:for_invitation] do
        [readonly: "readonly"]
      else
        []
      end

    assigns = assign(assigns, :email_readonly, email_readonly)

    ~H"""
    <div class="flex flex-col gap-y-2">
      <label for={@field.id} class="text-sm font-semibold text-gray-800 dark:text-gray-200">
        Email
      </label>
      <div>
        <.input
          type="email"
          field={@field}
          placeholder="[email protected]"
          phx-debounce={200}
          {@email_readonly}
        />
      </div>
    </div>
    """
  end

  def handle_event("validate", %{"user" => params}, socket) do
    changeset =
      params
      |> Auth.User.new()
      |> Map.put(:action, :validate)

    password_strength = Auth.User.password_strength(changeset)

    {:noreply,
     assign(socket,
       form: to_form(changeset),
       password_strength: password_strength,
       captcha_error: nil
     )}
  end

  def handle_event(
        "register",
        %{"user" => _} = params,
        %{assigns: %{invitation: %{} = invitation}} = socket
      ) do
    case Plausible.Auth.check_registration_enabled(:invitation) do
      :ok ->
        if PlausibleWeb.Captcha.verify(params["frc-captcha-response"]) do
          user =
            params["user"]
            |> Map.put("email", invitation.email)
            |> Auth.User.new()

          with_team? = invitation.type == :site_transfer

          add_user(socket, user, with_team?: with_team?)
        else
          {:noreply, captcha_failed(socket)}
        end

      {:error, _, message} ->
        socket =
          socket
          |> put_flash(:error, message)
          |> redirect(to: ~p"/login")

        {:noreply, socket}
    end
  end

  def handle_event("register", %{"user" => _} = params, socket) do
    case Plausible.Auth.check_registration_enabled(:default) do
      :ok ->
        if PlausibleWeb.Captcha.verify(params["frc-captcha-response"]) do
          user = Auth.User.new(params["user"])

          add_user(socket, user)
        else
          {:noreply, captcha_failed(socket)}
        end

      {:error, _, message} ->
        socket =
          socket
          |> put_flash(:error, message)
          |> redirect(to: ~p"/login")

        {:noreply, socket}
    end
  end

  defp captcha_failed(socket) do
    error = "Please complete the captcha to register"

    socket
    |> assign(captcha_error: error, signup_previous_error: "captcha")
    |> PlausibleWeb.Components.Captcha.reset()
  end

  defp add_user(socket, user, opts \\ []) do
    result =
      Repo.transaction(fn ->
        do_add_user(user, opts)
      end)

    case result do
      {:ok, _user} ->
        socket = assign(socket, disable_submit: true)

        {:noreply, assign(socket, trigger_submit: true)}

      {:error, changeset} ->
        socket =
          socket
          |> assign(
            form: to_form(Map.put(changeset, :action, :validate)),
            signup_previous_error: signup_error(changeset)
          )
          |> PlausibleWeb.Components.Captcha.reset()

        {:noreply, socket}
    end
  end

  defp signup_error(changeset) do
    case List.first(changeset.errors) do
      {field, _error} -> Map.get(@signup_error_categories, field, "unknown")
      nil -> "unknown"
    end
  end

  defp do_add_user(user, opts) do
    case Repo.insert(user) do
      {:ok, user} ->
        if opts[:with_team?] do
          {:ok, _} = Plausible.Teams.get_or_create(user)
        end

        user

      {:error, reason} ->
        Repo.rollback(reason)
    end
  end

  defp find_by_id_unified(invitation_or_transfer_id) do
    result =
      with {:error, :invitation_not_found} <-
             find_team_invitation_by_id_unified(invitation_or_transfer_id),
           {:error, :invitation_not_found} <-
             find_invitation_by_id_unified(invitation_or_transfer_id) do
        find_transfer_by_id_unified(invitation_or_transfer_id)
      end

    case result do
      {:error, :invitation_not_found} -> nil
      {:ok, unified} -> unified
    end
  end

  defp find_team_invitation_by_id_unified(id) do
    invitation =
      Teams.Invitation
      |> Repo.get_by(invitation_id: id)
      |> Repo.preload(:team)

    case invitation do
      nil ->
        {:error, :invitation_not_found}

      team_invitation ->
        {:ok,
         %{
           type: :team_invitation,
           email: team_invitation.email,
           team_identifier: team_invitation.team.identifier
         }}
    end
  end

  defp find_invitation_by_id_unified(id) do
    invitation =
      Teams.GuestInvitation
      |> Repo.get_by(invitation_id: id)
      |> Repo.preload(:team_invitation)

    case invitation do
      nil ->
        {:error, :invitation_not_found}

      guest_invitation ->
        {:ok,
         %{
           type: :guest_invitation,
           email: guest_invitation.team_invitation.email,
           team_identifier: nil
         }}
    end
  end

  defp find_transfer_by_id_unified(id) do
    transfer =
      Teams.SiteTransfer
      |> Repo.get_by(transfer_id: id)

    case transfer do
      nil ->
        {:error, :invitation_not_found}

      transfer ->
        {:ok,
         %{
           type: :site_transfer,
           email: transfer.email,
           team_identifier: nil
         }}
    end
  end
end