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.
analytics/lib/plausible/sites.ex

376 lines
9.9 KiB
Elixir

defmodule Plausible.Sites do
@moduledoc """
Sites context functions.
"""
import Ecto.Query
alias Plausible.Auth
alias Plausible.Billing.Quota
alias Plausible.Repo
alias Plausible.Site
alias Plausible.Site.SharedLink
require Plausible.Site.UserPreference
@type list_opt() :: {:filter_by_domain, String.t()}
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
@spec toggle_pin(Auth.User.t(), Site.t()) ::
{:ok, Site.UserPreference.t()} | {:error, :too_many_pins}
def toggle_pin(user, site) do
pinned_at =
if site.pinned_at do
nil
else
NaiveDateTime.utc_now()
end
with :ok <- check_user_pin_limit(user, pinned_at) do
{:ok, set_option(user, site, :pinned_at, pinned_at)}
end
end
@pins_limit 9
defp check_user_pin_limit(_user, nil), do: :ok
defp check_user_pin_limit(user, _) do
pins_count =
from(up in Site.UserPreference,
where: up.user_id == ^user.id and not is_nil(up.pinned_at)
)
|> Repo.aggregate(:count)
if pins_count + 1 > @pins_limit do
{:error, :too_many_pins}
else
:ok
end
end
@spec set_option(Auth.User.t(), Site.t(), atom(), any()) :: Site.UserPreference.t()
def set_option(user, site, option, value) when option in Site.UserPreference.options() do
get_for_user!(user.id, site.domain)
user
|> Site.UserPreference.changeset(site, %{option => value})
|> Repo.insert!(
conflict_target: [:user_id, :site_id],
# This way of conflict handling enables doing upserts of options leaving
# existing, unrelated values intact.
on_conflict: from(p in Site.UserPreference, update: [set: [{^option, ^value}]]),
returning: true
)
end
@spec list(Auth.User.t(), map(), [list_opt()]) :: Scrivener.Page.t()
def list(user, pagination_params, opts \\ []) do
domain_filter = Keyword.get(opts, :filter_by_domain)
from(s in Site,
left_join: up in Site.UserPreference,
on: up.site_id == s.id and up.user_id == ^user.id,
inner_join: sm in assoc(s, :memberships),
on: sm.user_id == ^user.id,
select: %{
s
| pinned_at: selected_as(up.pinned_at, :pinned_at),
entry_type:
selected_as(
fragment(
"""
CASE
WHEN ? IS NOT NULL THEN 'pinned_site'
ELSE 'site'
END
""",
up.pinned_at
),
:entry_type
)
},
order_by: [asc: selected_as(:entry_type), desc: selected_as(:pinned_at), asc: s.domain],
preload: [memberships: sm]
)
|> maybe_filter_by_domain(domain_filter)
|> Repo.paginate(pagination_params)
end
@spec list_with_invitations(Auth.User.t(), map(), [list_opt()]) :: Scrivener.Page.t()
def list_with_invitations(user, pagination_params, opts \\ []) do
domain_filter = Keyword.get(opts, :filter_by_domain)
result =
from(s in Site,
left_join: up in Site.UserPreference,
on: up.site_id == s.id and up.user_id == ^user.id,
left_join: i in assoc(s, :invitations),
on: i.email == ^user.email,
left_join: sm in assoc(s, :memberships),
on: sm.user_id == ^user.id,
where: not is_nil(sm.id) or not is_nil(i.id),
select: %{
s
| pinned_at: selected_as(up.pinned_at, :pinned_at),
entry_type:
selected_as(
fragment(
"""
CASE
WHEN ? IS NOT NULL THEN 'invitation'
WHEN ? IS NOT NULL THEN 'pinned_site'
ELSE 'site'
END
""",
i.id,
up.pinned_at
),
:entry_type
)
},
order_by: [asc: selected_as(:entry_type), desc: selected_as(:pinned_at), asc: s.domain],
preload: [memberships: sm, invitations: i]
)
|> maybe_filter_by_domain(domain_filter)
|> Repo.paginate(pagination_params)
# Populating `site` preload on `invitation`
# without requesting it from database.
# Necessary for invitation modals logic.
entries =
Enum.map(result.entries, fn
%{invitations: [invitation]} = site ->
site = %{site | invitations: [], memberships: []}
invitation = %{invitation | site: site}
%{site | invitations: [invitation]}
site ->
site
end)
%{result | entries: entries}
end
defp maybe_filter_by_domain(query, domain)
when byte_size(domain) >= 1 and byte_size(domain) <= 64 do
where(query, [s], ilike(s.domain, ^"%#{domain}%"))
end
defp maybe_filter_by_domain(query, _), do: query
def create(user, params) do
with :ok <- Quota.ensure_can_add_new_site(user) do
Ecto.Multi.new()
|> Ecto.Multi.insert(:site, Site.new(params))
|> Ecto.Multi.insert(:site_membership, fn %{site: site} ->
Site.Membership.new(site, user)
end)
|> maybe_start_trial(user)
|> Repo.transaction()
end
end
defp maybe_start_trial(multi, user) do
case user.trial_expiry_date do
nil ->
changeset = Auth.User.start_trial(user)
Ecto.Multi.update(multi, :user, changeset)
_ ->
multi
end
end
@spec clear_stats_start_date!(Site.t()) :: Site.t()
def clear_stats_start_date!(site) do
site
|> Ecto.Changeset.change(stats_start_date: nil)
|> Plausible.Repo.update!()
end
@doc """
Returns the date of the first recorded stat in the timezone configured by the user.
This function does 2 transformations:
UTC %NaiveDateTime{} -> Local %DateTime{} -> Local %Date
## Examples
iex> Plausible.Site.local_start_date(%Plausible.Site{stats_start_date: nil})
nil
iex> utc_start = ~N[2022-09-28 00:00:00]
iex> tz = "Europe/Helsinki"
iex> site = %Plausible.Site{stats_start_date: utc_start, timezone: tz}
iex> Plausible.Site.local_start_date(site)
~D[2022-09-28]
iex> utc_start = ~N[2022-09-28 00:00:00]
iex> tz = "America/Los_Angeles"
iex> site = %Plausible.Site{stats_start_date: utc_start, timezone: tz}
iex> Plausible.Site.local_start_date(site)
~D[2022-09-27]
"""
@spec local_start_date(Site.t()) :: Date.t() | nil
def local_start_date(site) do
if stats_start_date = stats_start_date(site) do
Plausible.Timezones.to_date_in_timezone(stats_start_date, site.timezone)
end
end
@spec stats_start_date(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
imported stats and Clickhouse, choosing the earliest start date and saves
it 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
site = Plausible.Imported.load_import_data(site)
start_date =
[
site.earliest_import_start_date,
Plausible.Stats.Clickhouse.pageview_start_date_local(site)
]
|> Enum.reject(&is_nil/1)
|> Enum.min(Date, fn -> nil end)
if start_date 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 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 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
end