defmodule Chesstrainer.MailingList do @moduledoc """ The marketing mailing list. Addresses arrive from the signup form on the landing page and from the opt-in checkbox on registration. A subscriber is only active once their address is confirmed: the landing-page form sends a confirmation email, while the registration checkbox relies on the account-confirmation email and is confirmed when the user's account is. A subscriber created from the landing page has no user; one created from registration is linked to the user so deleting the account also removes their address. Unsubscribing sets `unsubscribed_at` instead of deleting the row, so the address stays suppressed and is never emailed again unless it opts back in. """ import Ecto.Query, warn: false alias Chesstrainer.Accounts.User alias Chesstrainer.MailingList.Subscriber alias Chesstrainer.Repo @confirmation_cooldown_seconds 10 * 60 @doc """ Requests a subscription from the landing-page form. Returns `{:ok, :confirmation_required}` for a new or still-unconfirmed address, so the caller can send a confirmation email, and `{:ok, :already_subscribed}` for an address that has already confirmed. iex> subscribe("player@example.com") {:ok, :confirmation_required} iex> confirm("player@example.com") {:ok, %Subscriber{}} iex> subscribe("player@example.com") {:ok, :already_subscribed} """ def subscribe(email, opts \\ []) when is_binary(email) do changeset = %Subscriber{source: Keyword.get(opts, :source, :home)} |> Subscriber.changeset(%{email: email}) if changeset.valid? do email = Ecto.Changeset.get_field(changeset, :email) case Repo.get_by(Subscriber, email: email) do %Subscriber{confirmed_at: confirmed_at, unsubscribed_at: nil} when not is_nil(confirmed_at) -> {:ok, :already_subscribed} %Subscriber{} -> {:ok, :confirmation_required} nil -> insert_subscription(changeset, email) end else {:error, changeset} end end @doc """ Records a newly registered user's mailing-list opt-in. The subscriber stays unconfirmed until the account itself is confirmed. If the address was already subscribed anonymously, the existing row is linked to the user and re-sourced so the account deletion cascade removes it. """ def subscribe_user(%User{} = user) do %Subscriber{source: :registration, user_id: user.id} |> Subscriber.changeset(%{email: user.email}) |> Repo.insert( on_conflict: {:replace, [:user_id, :source, :updated_at]}, conflict_target: :email ) end @doc """ Confirms a subscription by email address. Confirming also clears a previous unsubscribe, so an address that opted out can rejoin only by going through a fresh confirmation. Returns `{:error, :not_found}` when the address is not on the list. """ def confirm(email) when is_binary(email) do case Repo.get_by(Subscriber, email: String.trim(email)) do nil -> {:error, :not_found} %Subscriber{} = subscriber -> confirm_subscriber(subscriber) end end @doc """ Unsubscribes an address from the mailing list. The row is kept so the address remains suppressed. Idempotent. """ def unsubscribe(email) when is_binary(email) do case Repo.get_by(Subscriber, email: String.trim(email)) do nil -> {:error, :not_found} %Subscriber{} = subscriber -> mark_unsubscribed(subscriber) end end @doc """ Unsubscribes the address linked to the given user account. """ def unsubscribe_user(%User{} = user) do case Repo.get_by(Subscriber, user_id: user.id) do nil -> {:error, :not_found} %Subscriber{} = subscriber -> mark_unsubscribed(subscriber) end end @doc "Returns true when the user has an active mailing-list subscription." def user_subscribed?(%User{} = user) do Subscriber |> where( [s], s.user_id == ^user.id and not is_nil(s.confirmed_at) and is_nil(s.unsubscribed_at) ) |> Repo.exists?() end @doc """ Keeps a user's linked subscription in step with their account email. Returns `{:ok, :no_subscription}` when the user was not on the list. """ def update_subscriber_email(%User{} = user, new_email) when is_binary(new_email) do case Repo.get_by(Subscriber, user_id: user.id) do nil -> {:ok, :no_subscription} %Subscriber{} = subscriber -> new_email = String.trim(new_email) case Repo.get_by(Subscriber, email: new_email) do # An anonymous row may already hold the new address. Remove it so the # unique email constraint does not block the account email change, # but keep its unsubscribe so moving an account email cannot opt an # address back in. %Subscriber{user_id: nil, unsubscribed_at: anonymous_unsubscribed_at} = anonymous -> Repo.delete!(anonymous) changeset = Subscriber.changeset(subscriber, %{email: new_email}) changeset = if anonymous_unsubscribed_at do Ecto.Changeset.put_change( changeset, :unsubscribed_at, subscriber.unsubscribed_at || anonymous_unsubscribed_at ) else changeset end Repo.update(changeset) _other -> subscriber |> Subscriber.changeset(%{email: new_email}) |> Repo.update() end end end @doc """ Confirms the subscription linked to a user whose account was just confirmed. Registration opt-ins use the account-confirmation email as their proof of address ownership, so this is called from the account confirmation flow. """ def confirm_user_subscription(%User{} = user) do now = DateTime.utc_now(:second) Subscriber |> where([s], s.user_id == ^user.id and is_nil(s.confirmed_at)) |> Repo.update_all(set: [confirmed_at: now, unsubscribed_at: nil, updated_at: now]) end @doc "Returns the number of active addresses on the mailing list." def count_confirmed_subscribers do Subscriber |> where([s], not is_nil(s.confirmed_at) and is_nil(s.unsubscribed_at)) |> Repo.aggregate(:count) end @doc """ Returns true when a confirmation email may be sent to this address. Addresses without a subscriber row are allowed, as are addresses that have not received a confirmation recently. This stops a repeated submission from turning into an email flood. """ def confirmation_allowed?(email) when is_binary(email) do case Repo.get_by(Subscriber, email: String.trim(email)) do nil -> true %Subscriber{confirmation_sent_at: nil} -> true %Subscriber{confirmation_sent_at: sent_at} -> DateTime.diff(DateTime.utc_now(:second), sent_at, :second) >= @confirmation_cooldown_seconds end end @doc "Records that a confirmation email was sent to this address." def mark_confirmation_sent(email) when is_binary(email) do case Repo.get_by(Subscriber, email: String.trim(email)) do nil -> :ok %Subscriber{} = subscriber -> subscriber |> Ecto.Changeset.change(confirmation_sent_at: DateTime.utc_now(:second)) |> Repo.update() end end defp confirm_subscriber(%Subscriber{} = subscriber) do attrs = if is_nil(subscriber.confirmed_at) do %{confirmed_at: DateTime.utc_now(:second), unsubscribed_at: nil} else %{unsubscribed_at: nil} end subscriber |> Ecto.Changeset.change(attrs) |> Repo.update() end defp mark_unsubscribed(%Subscriber{unsubscribed_at: nil} = subscriber) do subscriber |> Ecto.Changeset.change(unsubscribed_at: DateTime.utc_now(:second)) |> Repo.update() end defp mark_unsubscribed(%Subscriber{} = subscriber), do: {:ok, subscriber} defp insert_subscription(changeset, email) do case Repo.insert(changeset) do {:ok, _subscriber} -> {:ok, :confirmation_required} {:error, changeset} -> # A concurrent request may have inserted the address between the read # above and this insert; the unique constraint decides, so re-read it. if email_taken?(changeset) do case Repo.get_by(Subscriber, email: email) do %Subscriber{confirmed_at: confirmed_at, unsubscribed_at: nil} when not is_nil(confirmed_at) -> {:ok, :already_subscribed} %Subscriber{} -> {:ok, :confirmation_required} nil -> {:error, changeset} end else {:error, changeset} end end end defp email_taken?(changeset) do Enum.any?(changeset.errors, fn {:email, {_message, opts}} -> opts[:constraint] == :unique _other -> false end) end end