defmodule Chesstrainer.Accounts do @moduledoc """ The Accounts context. """ import Ecto.Query, warn: false alias Chesstrainer.Repo alias Chesstrainer.Accounts.{User, UserToken, UserNotifier} alias Chesstrainer.MailingList ## Database getters @doc """ Gets a user by email. ## Examples iex> get_user_by_email("foo@example.com") %User{} iex> get_user_by_email("unknown@example.com") nil """ def get_user_by_email(email) when is_binary(email) do Repo.get_by(User, email: email) end @doc """ Gets a user by email or username. Email and username are both `citext`, so the lookup ignores case. ## Examples iex> get_user_by_login("foo@example.com") %User{} iex> get_user_by_login("unknown") nil """ def get_user_by_login(login) when is_binary(login) do login = String.trim(login) from(u in User, where: u.email == ^login or u.username == ^login, limit: 1) |> Repo.one() end @doc """ Gets a user by email or username and password. ## Examples iex> get_user_by_login_and_password("foo@example.com", "correct_password") %User{} iex> get_user_by_login_and_password("foo@example.com", "invalid_password") nil """ def get_user_by_login_and_password(login, password) when is_binary(login) and is_binary(password) do user = get_user_by_login(login) if User.valid_password?(user, password), do: user end @doc """ Gets a single user. Raises `Ecto.NoResultsError` if the User does not exist. ## Examples iex> get_user!(123) %User{} iex> get_user!(456) ** (Ecto.NoResultsError) """ def get_user!(id), do: Repo.get!(User, id) ## User registration @doc """ Registers a user. ## Examples iex> register_user(%{field: value}) {:ok, %User{}} iex> register_user(%{field: bad_value}) {:error, %Ecto.Changeset{}} """ def register_user(attrs) do %User{} |> User.registration_changeset(attrs) |> Repo.insert() end @doc """ Returns an `%Ecto.Changeset{}` for tracking user registration changes. See `Chesstrainer.Accounts.User.registration_changeset/3`. """ def change_user_registration(user, attrs \\ %{}, opts \\ []) do User.registration_changeset(user, attrs, opts) end @doc ~S""" Delivers the confirmation email instructions to the given user. ## Examples iex> deliver_user_confirmation_instructions(user, &url(~p"/users/confirm/#{&1}")) {:ok, %{to: ..., body: ...}} iex> deliver_user_confirmation_instructions(confirmed_user, &url(~p"/users/confirm/#{&1}")) {:error, :already_confirmed} """ def deliver_user_confirmation_instructions(%User{} = user, confirmation_url_fun) when is_function(confirmation_url_fun, 1) do if user.confirmed_at do {:error, :already_confirmed} else {encoded_token, user_token} = UserToken.build_email_token(user, "confirm") Repo.insert!(user_token) UserNotifier.deliver_confirmation_instructions(user, confirmation_url_fun.(encoded_token)) end end @doc """ Confirms a user by the given token. If the token matches, the user account is marked as confirmed and the token is deleted. The token is valid for one day. """ def confirm_user(token) do with {:ok, query} <- UserToken.verify_confirmation_token_query(token), %UserToken{sent_to: email} <- Repo.one(query), %User{} = user <- Repo.get_by(User, email: email), {:ok, user} <- Repo.update(User.confirm_changeset(user)), {_count, _result} <- Repo.delete_all(from(UserToken, where: [user_id: ^user.id, context: "confirm"])) do {:ok, user} else _ -> :error end end @doc """ Updates a user's authority role. This is the only supported path for changing roles; registration never casts `role`, so a user cannot promote themselves. """ def update_user_role(%User{} = user, role) do user |> User.role_changeset(%{role: role}) |> Repo.update() end ## Settings @doc """ Checks whether the user is in sudo mode. The user is in sudo mode when the last authentication was done no further than 20 minutes ago. The limit can be given as second argument in minutes. """ def sudo_mode?(user, minutes \\ -20) def sudo_mode?(%User{authenticated_at: ts}, minutes) when is_struct(ts, DateTime) do DateTime.after?(ts, DateTime.utc_now() |> DateTime.add(minutes, :minute)) end def sudo_mode?(_user, _minutes), do: false @doc """ Returns an `%Ecto.Changeset{}` for changing the user email. See `Chesstrainer.Accounts.User.email_changeset/3` for a list of supported options. ## Examples iex> change_user_email(user) %Ecto.Changeset{data: %User{}} """ def change_user_email(user, attrs \\ %{}, opts \\ []) do User.email_changeset(user, attrs, opts) end @doc """ Updates the user email using the given token. If the token matches, the user email is updated and the token is deleted. """ def update_user_email(user, token) do context = "change:#{user.email}" Repo.transact(fn -> with {:ok, query} <- UserToken.verify_change_email_token_query(token, context), %UserToken{sent_to: email} <- Repo.one(query), {:ok, user} <- Repo.update(User.email_changeset(user, %{email: email})), {:ok, _subscription} <- MailingList.update_subscriber_email(user, email), {_count, _result} <- Repo.delete_all(from(UserToken, where: [user_id: ^user.id, context: ^context])) do {:ok, user} else _ -> {:error, :transaction_aborted} end end) end @doc """ Returns an `%Ecto.Changeset{}` for changing the user password. See `Chesstrainer.Accounts.User.password_changeset/3` for a list of supported options. ## Examples iex> change_user_password(user) %Ecto.Changeset{data: %User{}} """ def change_user_password(user, attrs \\ %{}, opts \\ []) do User.password_changeset(user, attrs, opts) end @doc """ Updates the user password. Returns a tuple with the updated user, as well as a list of expired tokens. ## Examples iex> update_user_password(user, %{password: ...}) {:ok, {%User{}, [...]}} iex> update_user_password(user, %{password: "too short"}) {:error, %Ecto.Changeset{}} """ def update_user_password(user, attrs) do user |> User.password_changeset(attrs) |> update_user_and_delete_all_tokens() end @doc ~S""" Delivers the reset password email instructions to the given user. ## Examples iex> deliver_user_reset_password_instructions(user, &url(~p"/users/reset-password/#{&1}")) {:ok, %{to: ..., body: ...}} """ def deliver_user_reset_password_instructions(%User{} = user, reset_password_url_fun) when is_function(reset_password_url_fun, 1) do {encoded_token, user_token} = UserToken.build_email_token(user, "reset_password") Repo.insert!(user_token) UserNotifier.deliver_reset_password_instructions(user, reset_password_url_fun.(encoded_token)) end @doc """ Gets the user with the given reset password token. Returns `nil` if the token is invalid or has expired. """ def get_user_by_reset_password_token(token) do with {:ok, query} <- UserToken.verify_reset_password_token_query(token), %UserToken{sent_to: email} <- Repo.one(query), %User{} = user <- Repo.get_by(User, email: email) do user else _ -> nil end end @doc """ Resets the user password. Returns a tuple with the updated user, as well as a list of expired tokens. """ def reset_user_password(user, attrs) do user |> User.password_changeset(attrs) |> update_user_and_delete_all_tokens() end ## Deletion @doc """ Permanently deletes a user and all of their data. Attempts and session tokens are removed by database cascades. There is no soft delete and no way to recover the account. ## Examples iex> delete_user(user) {:ok, %User{}} """ def delete_user(%User{} = user) do Repo.delete(user) end ## Session @doc """ Generates a session token. """ def generate_user_session_token(user) do {token, user_token} = UserToken.build_session_token(user) Repo.insert!(user_token) token end @doc """ Gets the user with the given signed token. If the token is valid `{user, token_inserted_at}` is returned, otherwise `nil` is returned. """ def get_user_by_session_token(token) do {:ok, query} = UserToken.verify_session_token_query(token) Repo.one(query) end @doc """ Returns the number of users with at least one valid session token. Session tokens stay valid for `UserToken.session_validity_in_days/0` days, so this counts users who logged in during that window, not necessarily users who are connected right now. A user with multiple sessions counts once. """ def count_logged_in_users do days = UserToken.session_validity_in_days() UserToken |> where([t], t.context == "session" and t.inserted_at > ago(^days, "day")) |> select([t], count(t.user_id, :distinct)) |> Repo.one() end @doc ~S""" Delivers the update email instructions to the given user. ## Examples iex> deliver_user_update_email_instructions(user, current_email, &url(~p"/users/settings/confirm-email/#{&1}")) {:ok, %{to: ..., body: ...}} """ def deliver_user_update_email_instructions(%User{} = user, current_email, update_email_url_fun) when is_function(update_email_url_fun, 1) do {encoded_token, user_token} = UserToken.build_email_token(user, "change:#{current_email}") Repo.insert!(user_token) UserNotifier.deliver_update_email_instructions(user, update_email_url_fun.(encoded_token)) end @doc """ Deletes the signed token with the given context. """ def delete_user_session_token(token) do Repo.delete_all(from(UserToken, where: [token: ^token, context: "session"])) :ok end ## Token helper defp update_user_and_delete_all_tokens(changeset) do Repo.transact(fn -> with {:ok, user} <- Repo.update(changeset) do tokens_to_expire = Repo.all_by(UserToken, user_id: user.id) Repo.delete_all(from(t in UserToken, where: t.id in ^Enum.map(tokens_to_expire, & &1.id))) {:ok, {user, tokens_to_expire}} end end) end end