You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
228 lines
6.5 KiB
Elixir
228 lines
6.5 KiB
Elixir
defimpl Bamboo.Formatter, for: Plausible.Auth.User do
|
|
def format_email_address(user, _opts) do
|
|
{user.name, user.email}
|
|
end
|
|
end
|
|
|
|
defimpl FunWithFlags.Actor, for: Plausible.Auth.User do
|
|
def id(%{id: id}) do
|
|
"user:#{id}"
|
|
end
|
|
end
|
|
|
|
defmodule Plausible.Auth.User do
|
|
use Plausible
|
|
use Ecto.Schema
|
|
import Ecto.Changeset
|
|
|
|
@type t() :: %__MODULE__{}
|
|
|
|
@required [:email, :name, :password]
|
|
|
|
schema "users" do
|
|
field :email, :string
|
|
field :password_hash
|
|
field :password, :string, virtual: true
|
|
field :password_confirmation, :string, virtual: true
|
|
field :name, :string
|
|
field :last_seen, :naive_datetime
|
|
field :trial_expiry_date, :date
|
|
field :theme, Ecto.Enum, values: [:system, :light, :dark]
|
|
field :email_verified, :boolean
|
|
field :previous_email, :string
|
|
|
|
# Fields for TOTP authentication. See `Plausible.Auth.TOTP`.
|
|
field :totp_enabled, :boolean, default: false
|
|
field :totp_secret, Plausible.Auth.TOTP.EncryptedBinary
|
|
field :totp_last_used_at, :naive_datetime
|
|
|
|
embeds_one :grace_period, Plausible.Auth.GracePeriod, on_replace: :update
|
|
|
|
has_many :site_memberships, Plausible.Site.Membership
|
|
has_many :sites, through: [:site_memberships, :site]
|
|
has_many :api_keys, Plausible.Auth.ApiKey
|
|
has_one :google_auth, Plausible.Site.GoogleAuth
|
|
has_one :subscription, Plausible.Billing.Subscription
|
|
has_one :enterprise_plan, Plausible.Billing.EnterprisePlan
|
|
|
|
timestamps()
|
|
end
|
|
|
|
def new(attrs \\ %{}) do
|
|
%Plausible.Auth.User{}
|
|
|> cast(attrs, @required)
|
|
|> validate_required(@required)
|
|
|> validate_length(:password, min: 12, message: "has to be at least 12 characters")
|
|
|> validate_length(:password, max: 128, message: "cannot be longer than 128 characters")
|
|
|> validate_confirmation(:password, required: true)
|
|
|> validate_password_strength()
|
|
|> hash_password()
|
|
|> start_trial
|
|
|> set_email_verified
|
|
|> unique_constraint(:email)
|
|
end
|
|
|
|
def settings_changeset(user, attrs \\ %{}) do
|
|
user
|
|
|> cast(attrs, [:email, :name, :theme])
|
|
|> validate_required([:email, :name, :theme])
|
|
|> unique_constraint(:email)
|
|
end
|
|
|
|
def email_changeset(user, attrs \\ %{}) do
|
|
user
|
|
|> cast(attrs, [:email, :password])
|
|
|> validate_required([:email, :password])
|
|
|> validate_email_changed()
|
|
|> check_password()
|
|
|> unique_constraint(:email)
|
|
|> set_email_verified()
|
|
|> put_change(:previous_email, user.email)
|
|
end
|
|
|
|
def cancel_email_changeset(user) do
|
|
if user.previous_email do
|
|
user
|
|
|> change()
|
|
|> unique_constraint(:email)
|
|
|> put_change(:email_verified, true)
|
|
|> put_change(:email, user.previous_email)
|
|
|> put_change(:previous_email, nil)
|
|
else
|
|
# It shouldn't happen under normal circumstances
|
|
raise "Previous email is empty for user #{user.id} (#{user.email}) when it shouldn't."
|
|
end
|
|
end
|
|
|
|
def changeset(user, attrs \\ %{}) do
|
|
user
|
|
|> cast(attrs, [:email, :name, :email_verified, :theme, :trial_expiry_date])
|
|
|> validate_required([:email, :name, :email_verified])
|
|
|> unique_constraint(:email)
|
|
end
|
|
|
|
def set_password(user, password) do
|
|
user
|
|
|> cast(%{password: password}, [:password])
|
|
|> validate_required([:password])
|
|
|> validate_length(:password, min: 12, message: "has to be at least 12 characters")
|
|
|> validate_length(:password, max: 128, message: "cannot be longer than 128 characters")
|
|
|> validate_password_strength()
|
|
|> hash_password()
|
|
end
|
|
|
|
def hash_password(%{errors: [], changes: changes} = changeset) do
|
|
hash = Plausible.Auth.Password.hash(changes[:password])
|
|
change(changeset, password_hash: hash)
|
|
end
|
|
|
|
def hash_password(changeset), do: changeset
|
|
|
|
def remove_trial_expiry(user) do
|
|
change(user, trial_expiry_date: nil)
|
|
end
|
|
|
|
def start_trial(user) do
|
|
change(user, trial_expiry_date: trial_expiry())
|
|
end
|
|
|
|
def end_trial(user) do
|
|
change(user, trial_expiry_date: Timex.today() |> Timex.shift(days: -1))
|
|
end
|
|
|
|
def password_strength(changeset) do
|
|
case get_field(changeset, :password) do
|
|
nil ->
|
|
%{suggestions: [], warning: "", score: 0}
|
|
|
|
# Passwords past (approximately) 32 characters are treated
|
|
# as strong, despite what they contain, to avoid unnecessarily
|
|
# expensive computation.
|
|
password when byte_size(password) > 32 ->
|
|
%{suggestions: [], warning: "", score: 4}
|
|
|
|
password ->
|
|
existing_phrases =
|
|
[]
|
|
|> maybe_add_phrase(get_field(changeset, :name))
|
|
|> maybe_add_phrase(get_field(changeset, :email))
|
|
|
|
case ZXCVBN.zxcvbn(password, existing_phrases) do
|
|
%{score: score, feedback: feedback} ->
|
|
%{suggestions: feedback.suggestions, warning: feedback.warning, score: score}
|
|
|
|
:error ->
|
|
%{suggestions: [], warning: "", score: 3}
|
|
end
|
|
end
|
|
catch
|
|
_kind, _value ->
|
|
%{suggestions: [], warning: "", score: 3}
|
|
end
|
|
|
|
def profile_img_url(%__MODULE__{email: email}) do
|
|
hash =
|
|
email
|
|
|> String.trim()
|
|
|> String.downcase()
|
|
|> :erlang.md5()
|
|
|> Base.encode16(case: :lower)
|
|
|
|
Path.join(PlausibleWeb.Endpoint.url(), ["avatar/", hash])
|
|
end
|
|
|
|
defp validate_email_changed(changeset) do
|
|
if !get_change(changeset, :email) && !changeset.errors[:email] do
|
|
add_error(changeset, :email, "can't be the same", validation: :different_email)
|
|
else
|
|
changeset
|
|
end
|
|
end
|
|
|
|
defp check_password(changeset) do
|
|
if password = get_change(changeset, :password) do
|
|
if Plausible.Auth.Password.match?(password, changeset.data.password_hash) do
|
|
changeset
|
|
else
|
|
add_error(changeset, :password, "is invalid", validation: :check_password)
|
|
end
|
|
else
|
|
changeset
|
|
end
|
|
end
|
|
|
|
defp validate_password_strength(changeset) do
|
|
if get_change(changeset, :password) != nil and password_strength(changeset).score <= 2 do
|
|
add_error(changeset, :password, "is too weak", validation: :strength)
|
|
else
|
|
changeset
|
|
end
|
|
end
|
|
|
|
defp maybe_add_phrase(phrases, nil), do: phrases
|
|
|
|
defp maybe_add_phrase(phrases, phrase) do
|
|
parts = String.split(phrase)
|
|
|
|
[phrase, parts]
|
|
|> List.flatten(phrases)
|
|
|> Enum.uniq()
|
|
end
|
|
|
|
defp trial_expiry() do
|
|
on_full_build do
|
|
Timex.today() |> Timex.shift(days: 30)
|
|
else
|
|
Timex.today() |> Timex.shift(years: 100)
|
|
end
|
|
end
|
|
|
|
defp set_email_verified(user) do
|
|
if Keyword.fetch!(Application.get_env(:plausible, :selfhost), :enable_email_verification) do
|
|
change(user, email_verified: false)
|
|
else
|
|
change(user, email_verified: true)
|
|
end
|
|
end
|
|
end
|