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.
316 lines
8.3 KiB
Elixir
316 lines
8.3 KiB
Elixir
defmodule Plausible.Sites do
|
|
alias Plausible.{Repo, Site, Site.SharedLink, Auth.User, Billing.Quota}
|
|
alias PlausibleWeb.Email
|
|
import Ecto.Query
|
|
|
|
@type invite_error() ::
|
|
Ecto.Changeset.t()
|
|
| :already_a_member
|
|
| :transfer_to_self
|
|
| {:over_limit, non_neg_integer()}
|
|
| :forbidden
|
|
|
|
def get_by_domain(domain) do
|
|
Repo.get_by(Site, domain: domain)
|
|
end
|
|
|
|
def get_by_domain!(domain) do
|
|
Repo.get_by!(Site, domain: domain)
|
|
end
|
|
|
|
def create(user, params) do
|
|
site_changeset = Site.changeset(%Site{}, params)
|
|
|
|
Ecto.Multi.new()
|
|
|> Ecto.Multi.run(:limit, fn _, _ ->
|
|
limit = Quota.site_limit(user)
|
|
usage = Quota.site_usage(user)
|
|
|
|
if Quota.within_limit?(usage, limit), do: {:ok, usage}, else: {:error, limit}
|
|
end)
|
|
|> Ecto.Multi.insert(:site, site_changeset)
|
|
|> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
|
|
Site.Membership.new(site, user)
|
|
end)
|
|
|> maybe_start_trial(user)
|
|
|> Repo.transaction()
|
|
end
|
|
|
|
defp maybe_start_trial(multi, user) do
|
|
case user.trial_expiry_date do
|
|
nil ->
|
|
changeset = Plausible.Auth.User.start_trial(user)
|
|
Ecto.Multi.update(multi, :user, changeset)
|
|
|
|
_ ->
|
|
multi
|
|
end
|
|
end
|
|
|
|
@spec bulk_transfer_ownership(
|
|
[Site.t()],
|
|
Plausible.Auth.User.t(),
|
|
String.t(),
|
|
Keyword.t()
|
|
) :: {:ok, [Plausible.Auth.Invitation.t()]} | {:error, invite_error()}
|
|
def bulk_transfer_ownership(sites, inviter, invitee_email, opts \\ []) do
|
|
Repo.transaction(fn ->
|
|
for site <- sites do
|
|
do_invite(site, inviter, invitee_email, :owner, opts)
|
|
end
|
|
end)
|
|
end
|
|
|
|
@spec invite(Site.t(), Plausible.Auth.User.t(), String.t(), atom()) ::
|
|
{:ok, Plausible.Auth.Invitation.t()} | {:error, invite_error()}
|
|
@doc """
|
|
Invites a new team member to the given site. Returns a
|
|
%Plausible.Auth.Invitation{} struct and sends the invitee an email to accept
|
|
this invitation.
|
|
|
|
The inviter must have enough permissions to invite the new team member,
|
|
otherwise this function returns `{:error, :forbidden}`.
|
|
|
|
If the new team member role is `:owner`, this function handles the invitation
|
|
as an ownership transfer and requires the inviter to be the owner of the site.
|
|
"""
|
|
def invite(site, inviter, invitee_email, role) do
|
|
Repo.transaction(fn ->
|
|
do_invite(site, inviter, invitee_email, role)
|
|
end)
|
|
end
|
|
|
|
defp do_invite(site, inviter, invitee_email, role, opts \\ []) do
|
|
attrs = %{email: invitee_email, role: role, site_id: site.id, inviter_id: inviter.id}
|
|
|
|
with :ok <- check_invitation_permissions(site, inviter, role, opts),
|
|
:ok <- check_team_member_limit(site, role),
|
|
invitee <- Plausible.Auth.find_user_by(email: invitee_email),
|
|
:ok <- ensure_transfer_valid(site, invitee, role),
|
|
:ok <- ensure_new_membership(site, invitee, role),
|
|
%Ecto.Changeset{} = changeset <- Plausible.Auth.Invitation.new(attrs),
|
|
{:ok, invitation} <- Repo.insert(changeset) do
|
|
send_invitation_email(invitation, invitee)
|
|
invitation
|
|
else
|
|
{:error, cause} -> Repo.rollback(cause)
|
|
end
|
|
end
|
|
|
|
defp check_invitation_permissions(site, inviter, requested_role, opts) do
|
|
check_permissions? = Keyword.get(opts, :check_permissions, true)
|
|
|
|
if check_permissions? do
|
|
required_roles = if requested_role == :owner, do: [:owner], else: [:admin, :owner]
|
|
|
|
membership_query =
|
|
from(m in Plausible.Site.Membership,
|
|
where: m.user_id == ^inviter.id and m.site_id == ^site.id and m.role in ^required_roles
|
|
)
|
|
|
|
if Repo.exists?(membership_query), do: :ok, else: {:error, :forbidden}
|
|
else
|
|
:ok
|
|
end
|
|
end
|
|
|
|
defp send_invitation_email(invitation, invitee) do
|
|
invitation = Repo.preload(invitation, [:site, :inviter])
|
|
|
|
email =
|
|
case {invitee, invitation.role} do
|
|
{invitee, :owner} -> Email.ownership_transfer_request(invitation, invitee)
|
|
{nil, _role} -> Email.new_user_invitation(invitation)
|
|
{%User{}, _role} -> Email.existing_user_invitation(invitation)
|
|
end
|
|
|
|
Plausible.Mailer.send(email)
|
|
end
|
|
|
|
defp ensure_transfer_valid(site, invitee, :owner) do
|
|
if invitee && role(invitee.id, site) == :owner do
|
|
{:error, :transfer_to_self}
|
|
else
|
|
:ok
|
|
end
|
|
end
|
|
|
|
defp ensure_transfer_valid(_site, _invitee, _role) do
|
|
:ok
|
|
end
|
|
|
|
defp ensure_new_membership(_site, _invitee, :owner) do
|
|
:ok
|
|
end
|
|
|
|
defp ensure_new_membership(site, invitee, _role) do
|
|
if invitee && is_member?(invitee.id, site) do
|
|
{:error, :already_a_member}
|
|
else
|
|
:ok
|
|
end
|
|
end
|
|
|
|
defp check_team_member_limit(_site, :owner) do
|
|
:ok
|
|
end
|
|
|
|
defp check_team_member_limit(site, _role) do
|
|
site_owner = owner_for(site)
|
|
limit = Quota.team_member_limit(site_owner)
|
|
usage = Quota.team_member_usage(site_owner)
|
|
|
|
if Quota.within_limit?(usage, limit),
|
|
do: :ok,
|
|
else: {:error, {:over_limit, limit}}
|
|
end
|
|
|
|
@spec stats_start_date(Plausible.Site.t()) :: Date.t() | nil
|
|
@doc """
|
|
Returns the date of the first event of the given site, or `nil` if the site
|
|
does not have stats yet.
|
|
|
|
If this is the first time the function is called for the site, it queries
|
|
Clickhouse and saves the date in the sites table.
|
|
"""
|
|
def stats_start_date(site)
|
|
|
|
def stats_start_date(%Site{stats_start_date: %Date{} = date}) do
|
|
date
|
|
end
|
|
|
|
def stats_start_date(%Site{} = site) do
|
|
if start_date = Plausible.Stats.Clickhouse.pageview_start_date_local(site) do
|
|
updated_site =
|
|
site
|
|
|> Site.set_stats_start_date(start_date)
|
|
|> Repo.update!()
|
|
|
|
updated_site.stats_start_date
|
|
end
|
|
end
|
|
|
|
def has_stats?(site) do
|
|
!!stats_start_date(site)
|
|
end
|
|
|
|
def create_shared_link(site, name, password \\ nil) do
|
|
changes =
|
|
SharedLink.changeset(
|
|
%SharedLink{
|
|
site_id: site.id,
|
|
slug: Nanoid.generate()
|
|
},
|
|
%{name: name, password: password}
|
|
)
|
|
|
|
Repo.insert(changes)
|
|
end
|
|
|
|
def shared_link_url(site, link) do
|
|
base = PlausibleWeb.Endpoint.url()
|
|
domain = "/share/#{URI.encode_www_form(site.domain)}"
|
|
base <> domain <> "?auth=" <> link.slug
|
|
end
|
|
|
|
def get_for_user!(user_id, domain, roles \\ [:owner, :admin, :viewer]) do
|
|
if :super_admin in roles and Plausible.Auth.is_super_admin?(user_id) do
|
|
get_by_domain!(domain)
|
|
else
|
|
user_id
|
|
|> get_for_user_q(domain, List.delete(roles, :super_admin))
|
|
|> Repo.one!()
|
|
end
|
|
end
|
|
|
|
def get_for_user(user_id, domain, roles \\ [:owner, :admin, :viewer]) do
|
|
if :super_admin in roles and Plausible.Auth.is_super_admin?(user_id) do
|
|
get_by_domain(domain)
|
|
else
|
|
user_id
|
|
|> get_for_user_q(domain, List.delete(roles, :super_admin))
|
|
|> Repo.one()
|
|
end
|
|
end
|
|
|
|
defp get_for_user_q(user_id, domain, roles) do
|
|
from(s in Site,
|
|
join: sm in Site.Membership,
|
|
on: sm.site_id == s.id,
|
|
where: sm.user_id == ^user_id,
|
|
where: sm.role in ^roles,
|
|
where: s.domain == ^domain or s.domain_changed_from == ^domain,
|
|
select: s
|
|
)
|
|
end
|
|
|
|
def has_goals?(site) do
|
|
Repo.exists?(
|
|
from(g in Plausible.Goal,
|
|
where: g.site_id == ^site.id
|
|
)
|
|
)
|
|
end
|
|
|
|
def is_member?(user_id, site) do
|
|
role(user_id, site) !== nil
|
|
end
|
|
|
|
def has_admin_access?(user_id, site) do
|
|
role(user_id, site) in [:admin, :owner]
|
|
end
|
|
|
|
def locked?(%Site{locked: locked}) do
|
|
locked
|
|
end
|
|
|
|
def role(user_id, site) do
|
|
Repo.one(
|
|
from(sm in Site.Membership,
|
|
where: sm.user_id == ^user_id and sm.site_id == ^site.id,
|
|
select: sm.role
|
|
)
|
|
)
|
|
end
|
|
|
|
def owned_sites_count(user) do
|
|
user
|
|
|> owned_sites_query()
|
|
|> Repo.aggregate(:count)
|
|
end
|
|
|
|
def owned_sites_domains(user) do
|
|
user
|
|
|> owned_sites_query()
|
|
|> select([site], site.domain)
|
|
|> Repo.all()
|
|
end
|
|
|
|
def owned_site_ids(user) do
|
|
user
|
|
|> owned_sites_query()
|
|
|> select([site], site.id)
|
|
|> Repo.all()
|
|
end
|
|
|
|
defp owned_sites_query(user) do
|
|
from(s in Site,
|
|
join: sm in Site.Membership,
|
|
on: sm.site_id == s.id,
|
|
where: sm.role == :owner,
|
|
where: sm.user_id == ^user.id
|
|
)
|
|
end
|
|
|
|
def owner_for(site) do
|
|
Repo.one(
|
|
from(u in Plausible.Auth.User,
|
|
join: sm in Site.Membership,
|
|
on: sm.user_id == u.id,
|
|
where: sm.site_id == ^site.id,
|
|
where: sm.role == :owner
|
|
)
|
|
)
|
|
end
|
|
end
|