Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

24h sort by traffic in CRM (#6124)

Adam Rutkowskib75d6781b01b
diff --git a/assets/js/liveview/live_socket.js b/assets/js/liveview/live_socket.js
index 0551a8ccec..7df1ef9984 100644
--- a/assets/js/liveview/live_socket.js
+++ b/assets/js/liveview/live_socket.js
@@ -71,6 +71,7 @@ if (csrfToken && websocketUrl) {
})
window.addEventListener('phx:page-loading-start', (_info) => topbar.show())
window.addEventListener('phx:page-loading-stop', (_info) => topbar.hide())
+ window.addEventListener('scroll-to-top', () => window.scrollTo(0, 0))
liveSocket.connect()
window.liveSocket = liveSocket
diff --git a/extra/lib/plausible_web/live/customer_support/team.ex b/extra/lib/plausible_web/live/customer_support/team.ex
index bc6e4752b5..d2ca34d135 100644
--- a/extra/lib/plausible_web/live/customer_support/team.ex
+++ b/extra/lib/plausible_web/live/customer_support/team.ex
@@ -25,10 +25,13 @@ defmodule PlausibleWeb.Live.CustomerSupport.Team do
team = Resource.Team.get(team_id)
if team do
+ tab_params = Map.drop(params, ["id", "tab"])
+
socket =
socket
|> assign(:team, team)
|> assign(:tab, tab)
+ |> assign(:tab_params, tab_params)
{:noreply, go_to_tab(socket, tab, params, :team, tab_component(tab))}
else
@@ -85,6 +88,7 @@ defmodule PlausibleWeb.Live.CustomerSupport.Team do
module={tab_component(@tab)}
team={@team}
tab={@tab}
+ tab_params={@tab_params}
id={"team-#{@team.id}-#{@tab}"}
/>
</Layout.layout>
diff --git a/extra/lib/plausible_web/live/customer_support/team/components/sites.ex b/extra/lib/plausible_web/live/customer_support/team/components/sites.ex
index 39af4de21e..5cadca725b 100644
--- a/extra/lib/plausible_web/live/customer_support/team/components/sites.ex
+++ b/extra/lib/plausible_web/live/customer_support/team/components/sites.ex
@@ -3,51 +3,114 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Sites do
Team sites component - handles team sites listing
"""
use PlausibleWeb, :live_component
- alias Plausible.Teams
- def update(%{team: team}, socket) do
- sites = Teams.owned_sites(team, 100)
- sites_count = Teams.owned_sites_count(team)
-
- hourly_stats =
- if connected?(socket) do
- Plausible.Stats.Sparkline.parallel_overview(sites)
- else
- sites
- |> Enum.map(fn site ->
- {site.domain,
- %{
- intervals: Plausible.Stats.Sparkline.empty_24h_intervals(),
- visitors: 0,
- visitors_change: 0
- }}
- end)
- |> Enum.into(%{})
- end
+ import Ecto.Query, except: [update: 2, update: 3]
+ import PlausibleWeb.Live.Components.Pagination
+
+ alias Plausible.Repo
+ alias Plausible.Site
+ alias Plausible.Sites.Index
+
+ @page_size 24
+
+ def update(%{team: team, tab_params: tab_params}, socket) do
+ team = Repo.preload(team, :owners)
+ owner = List.first(team.owners)
+
+ index_state =
+ Index.build(owner, team: team, sort_by: :traffic, sort_direction: :desc)
+
+ page = Index.paginate(index_state, tab_params["page"], @page_size)
+
+ sites = fetch_sites(page.entries)
+
+ hourly_stats = build_hourly_stats(sites, socket)
+
+ uri =
+ Routes.customer_support_team_path(PlausibleWeb.Endpoint, :show, team.id, tab: "sites")
+ |> URI.parse()
{:ok,
assign(socket,
team: team,
sites: sites,
- sites_count: sites_count,
- hourly_stats: hourly_stats
+ hourly_stats: hourly_stats,
+ index_state: index_state,
+ page_number: page.page_number,
+ total_pages: page.total_pages,
+ total_entries: page.total_entries,
+ uri: uri
+ )}
+ end
+
+ def update(%{team: team}, socket) do
+ update(%{team: team, tab_params: %{}}, socket)
+ end
+
+ def handle_event("sort", %{"by" => by}, socket) do
+ sort_by = parse_sort_by(by)
+ current_state = socket.assigns.index_state
+ current_sort_by = current_state.sort_by
+
+ sort_direction =
+ case sort_by do
+ ^current_sort_by ->
+ flip_direction(current_state.sort_direction)
+
+ :traffic ->
+ :desc
+
+ :alnum ->
+ :asc
+ end
+
+ new_state = Index.sort(current_state, sort_by: sort_by, sort_direction: sort_direction)
+ page = Index.paginate(new_state, 1, @page_size)
+ sites = fetch_sites(page.entries)
+
+ {:noreply,
+ assign(socket,
+ index_state: new_state,
+ sites: sites,
+ page_number: page.page_number,
+ total_pages: page.total_pages,
+ total_entries: page.total_entries
)}
end
def render(assigns) do
+ assigns =
+ assign(assigns,
+ sort_by: assigns.index_state.sort_by,
+ sort_direction: assigns.index_state.sort_direction
+ )
+
~H"""
<div class="mt-2">
- <.notice :if={@sites_count > 100} class="mt-4 mb-4">
- This team owns more than 100 sites. Displaying first 100 below.
- </.notice>
<.table rows={@sites}>
<:thead>
- <.th>Domain</.th>
+ <th
+ scope="col"
+ class="px-6 first:pl-0 last:pr-0 py-3 text-left text-sm font-semibold cursor-pointer select-none"
+ phx-click="sort"
+ phx-value-by="alnum"
+ phx-target={@myself}
+ >
+ Domain <.sort_arrow active={@sort_by == :alnum} direction={@sort_direction} />
+ </th>
<.th>Previous Domain</.th>
<.th>Timezone</.th>
<.th invisible>Settings</.th>
<.th invisible>Dashboard</.th>
- <.th invisible>24H</.th>
+ <th
+ scope="col"
+ class="px-6 first:pl-0 last:pr-0 py-3 text-left text-sm font-semibold cursor-pointer select-none"
+ phx-click="sort"
+ phx-value-by="traffic"
+ phx-target={@myself}
+ >
+ Traffic <.sort_arrow active={@sort_by == :traffic} direction={@sort_direction} />
+ </th>
</:thead>
<:tbody :let={site}>
<.td>
@@ -82,19 +145,88 @@ defmodule PlausibleWeb.CustomerSupport.Team.Components.Sites do
>
Settings
</.styled_link>
- <.td>
- <span class="h-[24px] text-indigo-500">
- <PlausibleWeb.Live.Components.Visitors.chart
- :if={is_map(@hourly_stats[site.domain])}
- intervals={@hourly_stats[site.domain].intervals}
- height={20}
- />
- </span>
- </.td>
+ </.td>
+ <.td>
+ <span class="h-[24px] text-indigo-500">
+ <PlausibleWeb.Live.Components.Visitors.chart
+ :if={is_map(@hourly_stats[site.domain])}
+ intervals={@hourly_stats[site.domain].intervals}
+ height={20}
+ />
+ </span>
+ <span class="text-[10px]">Unique visitors: {@hourly_stats[site.domain].visitors}</span>
</.td>
</:tbody>
</.table>
+ <.pagination
+ :if={@total_pages > 1}
+ id="sites-pagination"
+ uri={@uri}
+ page_number={@page_number}
+ total_pages={@total_pages}
+ >
+ Total of <span class="font-medium">{@total_entries}</span>
+ sites. Page {@page_number} of {@total_pages}
+ </.pagination>
</div>
"""
end
+
+ defp fetch_sites([]), do: []
+
+ defp fetch_sites(site_ids) do
+ by_id =
+ from(s in Site.regular(),
+ where: s.id in ^site_ids,
+ select: {s.id, s}
+ )
+ |> Repo.all()
+ |> Map.new()
+
+ Enum.map(site_ids, fn id -> Map.get(by_id, id) end)
+ end
+
+ defp build_hourly_stats(sites, socket) do
+ if connected?(socket) do
+ Plausible.Stats.Sparkline.parallel_overview(sites)
+ else
+ sites
+ |> Enum.map(fn site ->
+ {site.domain,
+ %{
+ intervals: Plausible.Stats.Sparkline.empty_24h_intervals(),
+ visitors: 0,
+ visitors_change: 0
+ }}
+ end)
+ |> Map.new()
+ end
+ end
+
+ defp parse_sort_by("alnum"), do: :alnum
+ defp parse_sort_by(_), do: :traffic
+
+ defp flip_direction(:asc), do: :desc
+ defp flip_direction(:desc), do: :asc
+
+ attr :active, :boolean, required: true
+ attr :direction, :atom, required: true
+
+ defp sort_arrow(%{active: false} = assigns) do
+ ~H"""
+ <span class="opacity-30">↕</span>
+ """
+ end
+
+ defp sort_arrow(%{direction: :asc} = assigns) do
+ ~H"""
+ <span>↑</span>
+ """
+ end
+
+ defp sort_arrow(assigns) do
+ ~H"""
+ <span>↓</span>
+ """
+ end
end
diff --git a/lib/plausible/sites/index.ex b/lib/plausible/sites/index.ex
new file mode 100644
index 0000000000..06d2962e83
--- /dev/null
+++ b/lib/plausible/sites/index.ex
@@ -0,0 +1,393 @@
+defmodule Plausible.Sites.Index do
+ @moduledoc """
+ Site index query module: fetches a sorted, paginated list of site IDs for a
+ user, supporting alphanumeric or traffic-based sorting over the last 24 hours.
+ """
+
+ import Ecto.Query
+
+ alias Plausible.Auth
+ alias Plausible.Repo
+ alias Plausible.ClickhouseRepo
+ alias Plausible.Site
+ alias Plausible.Teams
+ alias Plausible.Teams.Sites
+
+ @type sort_by() :: :alnum | :traffic
+ @type sort_direction() :: :asc | :desc
+
+ @type list_opt() ::
+ {:filter_by_domain, String.t()}
+ | {:team, Teams.Team.t() | nil}
+ | {:sort_by, sort_by()}
+ | {:sort_direction, sort_direction()}
+
+ defmodule Page do
+ @moduledoc """
+ A single page of results, drop-in replacement for Scrivener.Page
+ """
+
+ @type t() :: %__MODULE__{
+ entries: [pos_integer()],
+ page_number: pos_integer(),
+ page_size: pos_integer(),
+ total_entries: non_neg_integer(),
+ total_pages: pos_integer()
+ }
+
+ @enforce_keys [:entries, :page_number, :page_size, :total_entries, :total_pages]
+ defstruct [:entries, :page_number, :page_size, :total_entries, :total_pages]
+ end
+
+ defmodule State do
+ @moduledoc """
+ In-memory representation of a fully-sorted site index for one user
+ """
+
+ @type t() :: %__MODULE__{
+ user: Auth.User.t(),
+ opts: %{filter_by_domain: String.t() | nil, team: Plausible.Teams.Team.t() | nil},
+ ordered_ids: [pos_integer()],
+ pins: %{pos_integer() => NaiveDateTime.t() | nil},
+ domains: %{pos_integer() => String.t()},
+ traffic: %{pos_integer() => non_neg_integer()},
+ sort_by: Plausible.Sites.Index.sort_by(),
+ sort_direction: Plausible.Sites.Index.sort_direction()
+ }
+
+ @enforce_keys [:user, :opts, :ordered_ids, :pins, :sort_by, :sort_direction]
+ defstruct [
+ :user,
+ :opts,
+ :ordered_ids,
+ :pins,
+ :sort_by,
+ :sort_direction,
+ domains: %{},
+ traffic: %{}
+ ]
+ end
+
+ @doc """
+ Builds an `Index.State` for `user` by running all necessary queries
+ """
+ @spec build(Auth.User.t(), [list_opt()]) :: State.t()
+ def build(user, opts \\ []) do
+ sort_by = Keyword.get(opts, :sort_by, :alnum)
+ sort_direction = Keyword.get(opts, :sort_direction, :asc)
+
+ # Fetch the full unfiltered set for the team; domain filtering is applied
+ # locally from here on so filter/2 never needs to hit the database.
+ site_ids = fetch_site_ids(user, Keyword.delete(opts, :filter_by_domain))
+ pins = fetch_pins(user, site_ids)
+ domains = fetch_domains(site_ids)
+
+ %State{
+ user: user,
+ opts: %{
+ filter_by_domain: Keyword.get(opts, :filter_by_domain),
+ team: Keyword.get(opts, :team)
+ },
+ ordered_ids: site_ids,
+ pins: pins,
+ domains: domains,
+ traffic: %{},
+ sort_by: sort_by,
+ sort_direction: sort_direction
+ }
+ |> sort(opts)
+ end
+
+ @spec paginate(
+ State.t(),
+ page :: pos_integer() | String.t() | nil,
+ page_size :: pos_integer() | String.t() | nil
+ ) :: Page.t()
+ def paginate(%State{ordered_ids: ordered_ids} = state, raw_page_number, raw_page_size) do
+ page_number = cast_int(raw_page_number, min: 1, max: :unlimited, default: 1)
+ page_size = cast_int(raw_page_size, min: 1, max: 100, default: 24)
+
+ filtered_ids = apply_domain_filter(ordered_ids, state.domains, state.opts.filter_by_domain)
+
+ total_entries = length(filtered_ids)
+ total_pages = max(1, ceil(total_entries / page_size))
+ page_number = min(page_number, total_pages)
+
+ entries =
+ filtered_ids
+ |> Enum.drop((page_number - 1) * page_size)
+ |> Enum.take(page_size)
+
+ %Page{
+ entries: entries,
+ page_number: page_number,
+ page_size: page_size,
+ total_entries: total_entries,
+ total_pages: total_pages
+ }
+ end
+
+ @spec refresh_pins(State.t()) :: State.t()
+ def refresh_pins(
+ %State{
+ user: user,
+ ordered_ids: ordered_ids,
+ domains: domains,
+ traffic: traffic,
+ sort_by: sort_by,
+ sort_direction: sort_direction
+ } = state
+ ) do
+ new_pins = fetch_pins(user, ordered_ids)
+
+ new_ordered_ids =
+ if sort_by == :traffic do
+ sort_by_traffic(ordered_ids, new_pins, traffic, sort_direction)
+ else
+ sort_alnum(ordered_ids, new_pins, domains, sort_direction)
+ end
+
+ %State{state | pins: new_pins, ordered_ids: new_ordered_ids}
+ end
+
+ @spec update_state(State.t(), :filter_by_domain, String.t() | nil) :: State.t()
+ def update_state(%State{} = state, :filter_by_domain, value) do
+ %State{state | opts: %{state.opts | filter_by_domain: value}}
+ end
+
+ @spec sort(State.t(), [list_opt()]) :: State.t()
+ def sort(%State{} = state, opts) do
+ sort_by = Keyword.get(opts, :sort_by, state.sort_by)
+ sort_direction = Keyword.get(opts, :sort_direction, state.sort_direction)
+
+ apply_order(state, sort_by, sort_direction)
+ end
+
+ # no traffic data yet, fetch
+ defp apply_order(%State{traffic: t} = state, :traffic, sort_direction)
+ when map_size(t) == 0 do
+ fetch_traffic_and_sort(state, sort_direction)
+ end
+
+ # same sort_by, flip direction
+ defp apply_order(
+ %State{sort_by: :traffic, sort_direction: old_direction} = state,
+ :traffic,
+ new_direction
+ )
+ when old_direction != new_direction do
+ ordered_ids = flip_order(state.ordered_ids, state.pins)
+
+ %State{
+ state
+ | sort_direction: new_direction,
+ ordered_ids: ordered_ids
+ }
+ end
+
+ # alnum flip
+ defp apply_order(
+ %State{sort_by: :alnum, sort_direction: old_direction} = state,
+ :alnum,
+ sort_direction
+ )
+ when old_direction != sort_direction do
+ ordered_ids = flip_order(state.ordered_ids, state.pins)
+
+ %State{
+ state
+ | sort_direction: sort_direction,
+ traffic: %{},
+ ordered_ids: ordered_ids
+ }
+ end
+
+ # alnum
+ defp apply_order(%State{} = state, :alnum, sort_direction) do
+ ordered_ids = sort_alnum(state.ordered_ids, state.pins, state.domains, sort_direction)
+
+ %State{
+ state
+ | sort_by: :alnum,
+ sort_direction: sort_direction,
+ traffic: %{},
+ ordered_ids: ordered_ids
+ }
+ end
+
+ # no-op
+ defp apply_order(
+ %State{
+ sort_by: sort_by,
+ sort_direction: sort_direction
+ } = state,
+ sort_by,
+ sort_direction
+ ) do
+ state
+ end
+
+ defp fetch_traffic_and_sort(%State{} = state, sort_direction) do
+ traffic_list = traffic_for_site_ids(state.ordered_ids)
+ traffic_map = Map.new(traffic_list)
+ ordered_ids = sort_by_traffic(state.ordered_ids, state.pins, traffic_map, sort_direction)
+
+ %State{
+ state
+ | sort_by: :traffic,
+ sort_direction: sort_direction,
+ traffic: traffic_map,
+ ordered_ids: ordered_ids
+ }
+ end
+
+ defp flip_order(site_ids, pins) do
+ {pinned, unpinned} = split_pinned(site_ids, pins)
+ pinned ++ Enum.reverse(unpinned)
+ end
+
+ @spec fetch_site_ids(Auth.User.t(), [list_opt()]) :: [pos_integer()]
+ def fetch_site_ids(user, opts \\ []) do
+ team = Keyword.get(opts, :team)
+ domain_filter = Keyword.get(opts, :filter_by_domain)
+
+ from(u in subquery(Sites.accessible_by(user, team)),
+ inner_join: s in ^Site.regular(),
+ on: u.site_id == s.id,
+ select: s.id
+ )
+ |> maybe_filter_by_domain_on_site(domain_filter)
+ |> Repo.all()
+ end
+
+ @spec traffic_for_site_ids([pos_integer()]) :: [{pos_integer(), non_neg_integer()}]
+ def traffic_for_site_ids([]), do: []
+
+ def traffic_for_site_ids(site_ids) do
+ now = DateTime.utc_now()
+ utc_first_dt = DateTime.shift(now, hour: -24)
+
+ utc_first = DateTime.to_naive(utc_first_dt)
+ utc_last = DateTime.to_naive(now)
+ utc_first_minus_7d = NaiveDateTime.add(utc_first, -7, :day)
+
+ site_ids
+ |> Enum.chunk_every(1_000)
+ |> Task.async_stream(
+ fn batch ->
+ try do
+ ClickhouseRepo.all(
+ from(s in "sessions_v2",
+ where: s.site_id in ^batch,
+ where: s.sign == 1,
+ where: s.start >= ^utc_first_minus_7d,
+ where: s.timestamp >= ^utc_first,
+ where: s.start <= ^utc_last,
+ group_by: s.site_id,
+ select:
+ {s.site_id, fragment("toUInt64(round(uniq(?) * any(_sample_factor)))", s.user_id)}
+ )
+ )
+ rescue
+ e ->
+ Sentry.capture_message("traffic_for_site_ids: batch query failed",
+ extra: %{
+ first_site_id: List.first(batch),
+ last_site_id: List.last(batch),
+ batch_size: length(batch),
+ error: Exception.message(e)
+ }
+ )
+
+ []
+ end
+ end,
+ max_concurrency: 4,
+ ordered: false
+ )
+ |> Enum.flat_map(fn {:ok, rows} -> rows end)
+ end
+
+ defp fetch_pins(_user, []), do: %{}
+
+ defp fetch_pins(user, site_ids) do
+ pinned =
+ from(up in Site.UserPreference,
+ where: up.user_id == ^user.id and up.site_id in ^site_ids and not is_nil(up.pinned_at),
+ select: {up.site_id, up.pinned_at}
+ )
+ |> Repo.all()
+ |> Map.new()
+
+ Map.new(site_ids, fn id -> {id, Map.get(pinned, id)} end)
+ end
+
+ defp sort_by_traffic(site_ids, pins, traffic_map, sort_direction) do
+ sort_ids(site_ids, pins, &Map.get(traffic_map, &1, 0), sort_direction)
+ end
+
+ defp sort_alnum(site_ids, pins, domains, sort_direction) do
+ sort_ids(site_ids, pins, &Map.get(domains, &1, ""), sort_direction)
+ end
+
+ defp sort_ids(site_ids, pins, key_fn, direction) do
+ {pinned, unpinned} = split_pinned(site_ids, pins)
+ pinned ++ Enum.sort_by(unpinned, key_fn, direction)
+ end
+
+ defp split_pinned(site_ids, pins) do
+ {pinned_pairs, unpinned} =
+ Enum.split_with(site_ids, fn id -> not is_nil(Map.get(pins, id)) end)
+
+ pinned =
+ pinned_pairs
+ |> Enum.sort_by(fn id -> pins[id] end, {:desc, NaiveDateTime})
+
+ {pinned, unpinned}
+ end
+
+ defp fetch_domains([]), do: %{}
+
+ defp fetch_domains(site_ids) do
+ from(s in Site.regular(),
+ where: s.id in ^site_ids,
+ select: {s.id, s.domain}
+ )
+ |> Repo.all()
+ |> Map.new()
+ end
+
+ defp apply_domain_filter(site_ids, _domains, filter)
+ when filter in [nil, ""] do
+ site_ids
+ end
+
+ defp apply_domain_filter(site_ids, domains, filter) when is_binary(filter) do
+ needle = String.downcase(filter)
+
+ Enum.filter(site_ids, fn id ->
+ String.contains?(String.downcase(Map.get(domains, id, "")), needle)
+ end)
+ end
+
+ defp maybe_filter_by_domain_on_site(query, domain)
+ when byte_size(domain) >= 1 and byte_size(domain) <= 64 do
+ from([_u, s] in query, where: ilike(s.domain, ^"%#{domain}%"))
+ end
+
+ defp maybe_filter_by_domain_on_site(query, _), do: query
+
+ defp cast_int(value, min: min, max: max, default: default) when is_binary(value) do
+ case Integer.parse(value) do
+ {int, ""} when int >= min and int <= max -> int
+ _ -> default
+ end
+ end
+
+ defp cast_int(value, min: min, max: max, default: _default)
+ when is_integer(value) and value >= min and value <= max do
+ value
+ end
+
+ defp cast_int(_value, min: _min, max: _max, default: default), do: default
+end
diff --git a/lib/plausible/teams/sites.ex b/lib/plausible/teams/sites.ex
index 3ffe7136e9..1aabfc20c6 100644
--- a/lib/plausible/teams/sites.ex
+++ b/lib/plausible/teams/sites.ex
@@ -109,4 +109,50 @@ defmodule Plausible.Teams.Sites do
end
defp maybe_filter_by_domain(query, _), do: query
+
+ @spec accessible_by(Auth.User.t(), Teams.Team.t() | nil) :: Ecto.Query.t()
+ def accessible_by(user, team) do
+ if Teams.setup?(team) do
+ from(tm in Teams.Membership,
+ inner_join: t in assoc(tm, :team),
+ inner_join: s in assoc(t, :sites),
+ where: tm.user_id == ^user.id and tm.role != :guest,
+ where: tm.team_id == ^team.id,
+ select: %{site_id: s.id, role: tm.role}
+ )
+ else
+ my_team_query =
+ from(tm in Teams.Membership,
+ inner_join: t in assoc(tm, :team),
+ inner_join: s in assoc(t, :sites),
+ where: tm.user_id == ^user.id and tm.role != :guest,
+ where: tm.is_autocreated == true,
+ where: t.setup_complete == false,
+ select: %{site_id: s.id, role: tm.role}
+ )
+
+ guest_membership_query =
+ from(tm in Teams.Membership,
+ inner_join: gm in assoc(tm, :guest_memberships),
+ inner_join: s in assoc(gm, :site),
+ where: tm.user_id == ^user.id and tm.role == :guest,
+ select: %{
+ site_id: s.id,
+ role:
+ fragment(
+ """
+ CASE
+ WHEN ? = 'editor' THEN 'admin'
+ ELSE ?
+ END
+ """,
+ gm.role,
+ gm.role
+ )
+ }
+ )
+
+ from(s in my_team_query, union_all: ^guest_membership_query)
+ end
+ end
end
diff --git a/lib/plausible_web/live/components/pagination.ex b/lib/plausible_web/live/components/pagination.ex
index 966b7b5411..8142d02b7b 100644
--- a/lib/plausible_web/live/components/pagination.ex
+++ b/lib/plausible_web/live/components/pagination.ex
@@ -3,6 +3,7 @@ defmodule PlausibleWeb.Live.Components.Pagination do
Pagination components for LiveViews.
"""
use Phoenix.Component
+ alias Phoenix.LiveView.JS
def pagination(assigns) do
~H"""
@@ -59,7 +60,8 @@ defmodule PlausibleWeb.Live.Components.Pagination do
~H"""
<.link
- navigate={@uri}
+ patch={@uri}
+ phx-click={@active? && JS.dispatch("scroll-to-top")}
class={[
"pagination-link relative inline-flex items-center px-4 py-2 border text-sm font-medium rounded-md",
if @active? do
diff --git a/test/plausible/sites/index_test.exs b/test/plausible/sites/index_test.exs
new file mode 100644
index 0000000000..0d49e813ca
--- /dev/null
+++ b/test/plausible/sites/index_test.exs
@@ -0,0 +1,987 @@
+defmodule Plausible.Sites.IndexTest do
+ use Plausible.DataCase, async: true
+
+ alias Plausible.Sites.Index
+ alias Plausible.Sites.Index.State
+
+ describe "fetch_site_ids/2" do
+ test "returns empty list when user has no sites" do
+ user = new_user()
+ _rogue_site = new_site()
+
+ assert Index.fetch_site_ids(user) == []
+ end
+
+ test "returns IDs for owned sites on personal (non-setup) team" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ ids = Index.fetch_site_ids(user)
+ assert site.id in ids
+ end
+
+ test "returns IDs for guest sites when no team set" do
+ owner = new_user()
+ user = new_user()
+ site = new_site(owner: owner)
+ add_guest(site, user: user, role: :editor)
+
+ ids = Index.fetch_site_ids(user)
+ assert site.id in ids
+ end
+
+ on_ee do
+ test "does not include consolidated views" do
+ user = new_user()
+ {:ok, team} = Plausible.Teams.get_or_create(user)
+ regular1 = new_site(team: team)
+ regular2 = new_site(team: team)
+
+ new_consolidated_view(team)
+
+ team = Plausible.Teams.complete_setup(team)
+
+ assert Index.fetch_site_ids(user, team: team) == [regular1.id, regular2.id]
+ end
+ end
+
+ test "scopes to team when team is set and setup" do
+ user = new_user()
+ site1 = new_site(owner: user)
+ other_user = new_user()
+ site2 = new_site(owner: other_user)
+ team2 = Plausible.Teams.complete_setup(site2.team)
+ add_member(site2.team, user: user, role: :admin)
+
+ ids = Index.fetch_site_ids(user, team: team2)
+ assert site2.id in ids
+ refute site1.id in ids
+ end
+
+ test "filters by domain substring" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ site_b = new_site(owner: user, domain: "beta.example.com")
+
+ ids = Index.fetch_site_ids(user, filter_by_domain: "alpha")
+ assert site_a.id in ids
+ refute site_b.id in ids
+ end
+
+ test "non-setup team: own sites and guest sites both included" do
+ user = new_user()
+ own_site = new_site(owner: user)
+ other_owner = new_user()
+ guest_site = new_site(owner: other_owner)
+ add_guest(guest_site, user: user, role: :editor)
+
+ personal_team = team_of(user)
+
+ ids = Index.fetch_site_ids(user, team: personal_team)
+ assert own_site.id in ids
+ assert guest_site.id in ids
+ end
+
+ test "setup team: guest memberships on other sites are excluded" do
+ user = new_user()
+ guest_owner = new_user()
+ guest_site = new_site(owner: guest_owner)
+ add_guest(guest_site, user: user, role: :editor)
+
+ team_owner = new_user()
+ team_site = new_site(owner: team_owner)
+ setup_team = Plausible.Teams.complete_setup(team_site.team)
+ add_member(team_site.team, user: user, role: :admin)
+
+ ids = Index.fetch_site_ids(user, team: setup_team)
+ assert team_site.id in ids
+ refute guest_site.id in ids
+ end
+ end
+
+ describe "traffic_for_site_ids/1" do
+ test "returns empty list when site_ids is empty" do
+ assert Index.traffic_for_site_ids([]) == []
+ end
+
+ test "returns empty list and captures Sentry report when a batch query fails", %{
+ test_pid: test_pid
+ } do
+ Plausible.Test.Support.Sentry.setup(test_pid)
+
+ assert Index.traffic_for_site_ids([1, :force_the_batch_to_fail, 3]) == []
+
+ assert [report] = Sentry.Test.pop_sentry_reports()
+ assert report.message.formatted == "traffic_for_site_ids: batch query failed"
+ assert report.extra.batch_size == 3
+ assert report.extra.first_site_id == 1
+ assert report.extra.last_site_id == 3
+ assert is_binary(report.extra.error)
+ end
+
+ test "returns visitor counts for sites with events in 24h window" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -2, :hour), user_id: 2),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -2, :hour), user_id: 2)
+ ])
+
+ results = Index.traffic_for_site_ids([site.id])
+
+ assert length(results) == 1
+ [{returned_id, visitors}] = results
+ assert returned_id == site.id
+ assert visitors == 2
+ end
+
+ test "does not count engagement-only users as visitors" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)
+
+ populate_stats(site, [
+ build(:pageview, timestamp: now, user_id: 1),
+ build(:pageview, timestamp: now, user_id: 2),
+ build(:engagement, timestamp: now, user_id: 2, pathname: "/")
+ ])
+
+ results = Index.traffic_for_site_ids([site.id])
+ [{_id, visitors}] = results
+ assert visitors == 2
+ end
+
+ test "excludes events outside the time window" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -25, :hour), user_id: 1)
+ ])
+
+ results = Index.traffic_for_site_ids([site.id])
+ assert results == []
+ end
+
+ test "returns results for multiple sites" do
+ user = new_user()
+ site_a = new_site(owner: user)
+ site_b = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_a, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2)
+ ])
+
+ populate_stats(site_b, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ results = Index.traffic_for_site_ids([site_a.id, site_b.id])
+ traffic_map = Map.new(results)
+
+ assert Map.get(traffic_map, site_a.id) == 2
+ assert Map.get(traffic_map, site_b.id) == 1
+ end
+
+ test "sites with no events in the window are omitted from results (callers default to 0)" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ results = Index.traffic_for_site_ids([site.id])
+
+ # no matching rows, will be treated as 0
+ assert results == []
+ end
+ end
+
+ describe "build/2" do
+ test "returns a State struct" do
+ user = new_user()
+ state = Index.build(user)
+
+ assert %State{} = state
+ assert state.user == user
+ assert state.sort_by == :alnum
+ assert state.sort_direction == :asc
+ end
+
+ test "ordered_ids is empty when user has no sites" do
+ user = new_user()
+ state = Index.build(user)
+
+ assert state.ordered_ids == []
+ end
+
+ test "ordered_ids contains all visible site IDs" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "a.example.com")
+ site_b = new_site(owner: user, domain: "b.example.com")
+
+ state = Index.build(user)
+
+ assert Enum.sort(state.ordered_ids) == Enum.sort([site_a.id, site_b.id])
+ end
+
+ test "ordered_ids includes sites with no traffic for traffic sort)" do
+ user = new_user()
+ _site = new_site(owner: user)
+
+ state = Index.build(user, sort_by: :traffic)
+
+ assert length(state.ordered_ids) == 1
+ end
+
+ test "alnum sort: ordered_ids ascending by domain" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+
+ assert state.ordered_ids == [site_a.id, site_z.id]
+ end
+
+ test "alnum sort: ordered_ids descending by domain" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :desc)
+
+ assert state.ordered_ids == [site_z.id, site_a.id]
+ end
+
+ test "alnum sort: pinned sites come first regardless of domain" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site_z)
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+
+ assert state.ordered_ids == [site_z.id, site_a.id]
+ end
+
+ test "traffic sort: ordered_ids descending by visitors" do
+ user = new_user()
+ site_low = new_site(owner: user)
+ site_high = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_high, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2)
+ ])
+
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+
+ assert state.ordered_ids == [site_high.id, site_low.id]
+ end
+
+ test "traffic sort: ordered_ids ascending by visitors" do
+ user = new_user()
+ site_low = new_site(owner: user)
+ site_high = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_high, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2)
+ ])
+
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :asc)
+
+ assert state.ordered_ids == [site_low.id, site_high.id]
+ end
+
+ test "traffic sort: zero-traffic sites ordered last in :desc, first in :asc" do
+ user = new_user()
+ site_empty = new_site(owner: user)
+ site_busy = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_busy, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1)
+ ])
+
+ state_desc = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+ assert state_desc.ordered_ids == [site_busy.id, site_empty.id]
+
+ state_asc = Index.build(user, sort_by: :traffic, sort_direction: :asc)
+ assert state_asc.ordered_ids == [site_empty.id, site_busy.id]
+ end
+
+ test "traffic sort: pinned sites come first regardless of traffic" do
+ user = new_user()
+ site_busy = new_site(owner: user)
+ site_pinned = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_busy, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ populate_stats(site_pinned, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 4)
+ ])
+
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site_pinned)
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+
+ assert hd(state.ordered_ids) == site_pinned.id
+ end
+
+ test "traffic map is empty for alnum sort" do
+ user = new_user()
+ _site = new_site(owner: user)
+
+ state = Index.build(user, sort_by: :alnum)
+
+ assert state.traffic == %{}
+ end
+
+ test "traffic map is populated for traffic sort" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1)
+ ])
+
+ state = Index.build(user, sort_by: :traffic)
+
+ assert is_map(state.traffic)
+ assert Map.get(state.traffic, site.id) == 1
+ end
+
+ test "defaults to alnum/asc when no opts given" do
+ user = new_user()
+ state = Index.build(user)
+
+ assert state.sort_by == :alnum
+ assert state.sort_direction == :asc
+ end
+
+ test "stores filter_by_domain and team in opts map" do
+ user = new_user()
+ other_user = new_user()
+ team_site = new_site(owner: other_user)
+ team = Plausible.Teams.complete_setup(team_site.team)
+ add_member(team_site.team, user: user, role: :admin)
+
+ state = Index.build(user, filter_by_domain: "example", team: team)
+
+ assert state.opts == %{filter_by_domain: "example", team: team}
+ end
+
+ test "filter_by_domain is respected at paginate time" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ _site_b = new_site(owner: user, domain: "beta.example.com")
+
+ state = Index.build(user, filter_by_domain: "alpha")
+
+ assert length(state.ordered_ids) == 2
+ assert state.opts.filter_by_domain == "alpha"
+
+ page = Index.paginate(state, 1, 24)
+ assert page.entries == [site_a.id]
+ assert page.total_entries == 1
+ end
+
+ test "scopes to setup team" do
+ user = new_user()
+ personal_site = new_site(owner: user)
+ other_user = new_user()
+ team_site = new_site(owner: other_user)
+ team = Plausible.Teams.complete_setup(team_site.team)
+ add_member(team_site.team, user: user, role: :admin)
+
+ state = Index.build(user, team: team)
+
+ assert team_site.id in state.ordered_ids
+ refute personal_site.id in state.ordered_ids
+ end
+
+ test "revoked guest membership removes site from ordered_ids even when pinned" do
+ owner = new_user()
+ user = new_user()
+ site = new_site(owner: owner, domain: "revoked.example.com")
+ add_guest(site, user: user, role: :editor)
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site)
+
+ state_before = Index.build(user)
+ assert site.id in state_before.ordered_ids
+
+ revoke_membership(site, user)
+
+ state_after = Index.build(user)
+ refute site.id in state_after.ordered_ids
+ end
+
+ test "alnum sort: multiple pinned sites ordered by pinned_at descending" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "a.example.com")
+ site_b = new_site(owner: user, domain: "b.example.com")
+
+ Plausible.Sites.set_option(user, site_a, :pinned_at, ~N[2024-01-01 10:00:00])
+ Plausible.Sites.set_option(user, site_b, :pinned_at, ~N[2024-01-02 10:00:00])
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+
+ # site_b was pinned more recently
+ assert state.ordered_ids == [site_b.id, site_a.id]
+ end
+ end
+
+ describe "paginate/3" do
+ test "returns a Page of site IDs" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ state = Index.build(user)
+ page = Index.paginate(state, 1, 24)
+
+ assert %Index.Page{} = page
+ assert page.entries == [site.id]
+ assert page.total_entries == 1
+ assert page.page_number == 1
+ assert page.total_pages == 1
+ end
+
+ test "returns empty page when user has no sites" do
+ user = new_user()
+ state = Index.build(user)
+ page = Index.paginate(state, 1, 24)
+
+ assert page.entries == []
+ assert page.total_entries == 0
+ assert page.total_pages == 1
+ end
+
+ test "slices correct page window" do
+ user = new_user()
+ sites = for i <- 0..9, do: new_site(owner: user, domain: "slice-#{i}.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+
+ page1 = Index.paginate(state, 1, 3)
+ page2 = Index.paginate(state, 2, 3)
+ page3 = Index.paginate(state, 3, 3)
+ page4 = Index.paginate(state, 4, 3)
+
+ assert page1.total_entries == 10
+ assert page1.total_pages == 4
+ assert length(page1.entries) == 3
+ assert length(page2.entries) == 3
+ assert length(page3.entries) == 3
+ assert length(page4.entries) == 1
+
+ all_ids = page1.entries ++ page2.entries ++ page3.entries ++ page4.entries
+
+ assert Enum.map(sites, & &1.id) == all_ids
+ end
+
+ test "preserves ordering from state" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ state_asc = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+ page_asc = Index.paginate(state_asc, 1, 24)
+ assert page_asc.entries == [site_a.id, site_z.id]
+
+ state_desc = Index.build(user, sort_by: :alnum, sort_direction: :desc)
+ page_desc = Index.paginate(state_desc, 1, 24)
+ assert page_desc.entries == [site_z.id, site_a.id]
+ end
+
+ test "clamps page_number to total_pages when out of range" do
+ user = new_user()
+ _site = new_site(owner: user)
+
+ state = Index.build(user)
+ page = Index.paginate(state, 999, 24)
+
+ assert page.page_number == 1
+ assert length(page.entries) == 1
+ end
+
+ test "page_size larger than total_entries returns all entries on page 1" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "a.example.com")
+ site_b = new_site(owner: user, domain: "b.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+ page = Index.paginate(state, 1, 100)
+
+ assert page.total_pages == 1
+ assert page.entries == [site_a.id, site_b.id]
+ end
+
+ test "accepts string page and page_size (e.g. from query-string params)" do
+ user = new_user()
+ for _ <- 1..5, do: new_site(owner: user)
+
+ state = Index.build(user)
+
+ page1 = Index.paginate(state, "1", "3")
+ page2 = Index.paginate(state, "2", "3")
+
+ assert page1.total_entries == 5
+ assert page1.total_pages == 2
+ assert length(page1.entries) == 3
+ assert length(page2.entries) == 2
+ assert MapSet.disjoint?(MapSet.new(page1.entries), MapSet.new(page2.entries))
+ end
+
+ test "invalid page falls back to page 1" do
+ user = new_user()
+ for _ <- 1..3, do: new_site(owner: user)
+
+ state = Index.build(user)
+
+ assert Index.paginate(state, "abc", 24).page_number == 1
+ assert Index.paginate(state, "0", 24).page_number == 1
+ assert Index.paginate(state, nil, 24).page_number == 1
+ end
+
+ test "page_size out of range falls back to default of 24" do
+ user = new_user()
+ for _ <- 1..5, do: new_site(owner: user)
+
+ state = Index.build(user)
+
+ assert Index.paginate(state, 1, "0").page_size == 24
+ assert Index.paginate(state, 1, "101").page_size == 24
+ end
+
+ test "nil page and page_size fall back to defaults (page 1, page_size 24)" do
+ user = new_user()
+ for _ <- 1..5, do: new_site(owner: user)
+
+ state = Index.build(user)
+ page = Index.paginate(state, nil, nil)
+
+ assert page.page_number == 1
+ assert page.page_size == 24
+ end
+ end
+
+ describe "refresh_pins/1" do
+ test "returns a new State" do
+ user = new_user()
+ _site = new_site(owner: user)
+
+ state = Index.build(user)
+ new_state = Index.refresh_pins(state)
+
+ assert %State{} = new_state
+ end
+
+ test "pinning a site moves it to the front" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+
+ assert state.ordered_ids == [site_a.id, site_z.id]
+
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site_z)
+
+ new_state = Index.refresh_pins(state)
+ assert new_state.ordered_ids == [site_z.id, site_a.id]
+ end
+
+ test "unpinning a site moves it back into sort order" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ {:ok, pref} = Plausible.Sites.toggle_pin(user, site_z)
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+ assert hd(state.ordered_ids) == site_z.id
+
+ site_z_pinned = %{site_z | pinned_at: pref.pinned_at}
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site_z_pinned)
+
+ new_state = Index.refresh_pins(state)
+ assert new_state.ordered_ids == [site_a.id, site_z.id]
+ end
+
+ test "preserves all other State fields" do
+ user = new_user()
+ _site = new_site(owner: user)
+ opts = [sort_by: :alnum, sort_direction: :desc]
+
+ state = Index.build(user, opts)
+ new_state = Index.refresh_pins(state)
+
+ assert new_state.user == state.user
+ assert new_state.opts == state.opts
+ assert new_state.sort_by == state.sort_by
+ assert new_state.sort_direction == state.sort_direction
+ end
+
+ test "does not re-query ClickHouse (traffic preserved)" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1)
+ ])
+
+ state = Index.build(user, sort_by: :traffic)
+ traffic_before = state.traffic
+
+ populate_stats(site, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ new_state = Index.refresh_pins(state)
+ assert new_state.traffic == traffic_before
+ end
+
+ test "traffic sort: pinning a site moves it to front, traffic order preserved for rest" do
+ user = new_user()
+ site_low = new_site(owner: user, domain: "low.example.com")
+ site_mid = new_site(owner: user, domain: "mid.example.com")
+ site_high = new_site(owner: user, domain: "high.example.com")
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_high, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ populate_stats(site_mid, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 4),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 5)
+ ])
+
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 6)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+ assert state.ordered_ids == [site_high.id, site_mid.id, site_low.id]
+
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site_low)
+
+ new_state = Index.refresh_pins(state)
+
+ # site_low is pinned, moves to front
+ assert new_state.ordered_ids == [site_low.id, site_high.id, site_mid.id]
+ end
+ end
+
+ describe "update_state/3" do
+ test "returns a new State with updated filter_by_domain" do
+ user = new_user()
+ _site = new_site(owner: user)
+
+ state = Index.build(user)
+ new_state = Index.update_state(state, :filter_by_domain, "example")
+
+ assert %State{} = new_state
+ assert new_state.opts.filter_by_domain == "example"
+ end
+
+ test "does not hit the database - ordered_ids is unchanged" do
+ user = new_user()
+ _site_a = new_site(owner: user, domain: "alpha.example.com")
+ _site_b = new_site(owner: user, domain: "beta.example.com")
+
+ state = Index.build(user)
+ assert length(state.ordered_ids) == 2
+
+ new_state = Index.update_state(state, :filter_by_domain, "alpha")
+
+ # full list preserved in state
+ assert new_state.ordered_ids == state.ordered_ids
+ end
+
+ test "paginate/3 reflects the new filter" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ _site_b = new_site(owner: user, domain: "beta.example.com")
+
+ page =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "alpha")
+ |> Index.paginate(1, 24)
+
+ assert page.entries == [site_a.id]
+ assert page.total_entries == 1
+ end
+
+ test "filter is case-insensitive" do
+ user = new_user()
+ site = new_site(owner: user, domain: "Alpha.example.com")
+
+ page =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "ALPHA")
+ |> Index.paginate(1, 24)
+
+ assert page.entries == [site.id]
+ end
+
+ test "nil filter clears the filter and returns all sites" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ site_b = new_site(owner: user, domain: "beta.example.com")
+
+ page =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "alpha")
+ |> Index.update_state(:filter_by_domain, nil)
+ |> Index.paginate(1, 24)
+
+ assert length(page.entries) == 2
+ assert site_a.id in page.entries
+ assert site_b.id in page.entries
+ end
+
+ test "empty string filter clears the filter and returns all sites" do
+ user = new_user()
+ _site_a = new_site(owner: user, domain: "alpha.example.com")
+ _site_b = new_site(owner: user, domain: "beta.example.com")
+
+ page =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "alpha")
+ |> Index.update_state(:filter_by_domain, "")
+ |> Index.paginate(1, 24)
+
+ assert page.total_entries == 2
+ end
+
+ test "filter returns empty page when no sites match" do
+ user = new_user()
+ _site = new_site(owner: user, domain: "alpha.example.com")
+
+ page =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "zzz-no-match")
+ |> Index.paginate(1, 24)
+
+ assert page.entries == []
+ assert page.total_entries == 0
+ end
+
+ test "filter preserves sort order within results" do
+ user = new_user()
+ site_az = new_site(owner: user, domain: "az.test.com")
+ site_aa = new_site(owner: user, domain: "aa.test.com")
+ _site_b = new_site(owner: user, domain: "other.com")
+
+ page =
+ user
+ |> Index.build(sort_by: :alnum, sort_direction: :asc)
+ |> Index.update_state(:filter_by_domain, ".test.")
+ |> Index.paginate(1, 24)
+
+ assert page.entries == [site_aa.id, site_az.id]
+ end
+
+ test "changing filter does not require re-sorting - traffic map is preserved" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ site_b = new_site(owner: user, domain: "beta.example.com")
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_a, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -2, :hour), user_id: 1)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+ original_traffic = state.traffic
+
+ populate_stats(site_a, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1)
+ ])
+
+ new_state = Index.update_state(state, :filter_by_domain, "beta")
+
+ assert new_state.traffic == original_traffic
+
+ page = Index.paginate(new_state, 1, 24)
+ assert page.entries == [site_b.id]
+ end
+
+ test "filter applied to build opts is applied consistently with update_state/3" do
+ user = new_user()
+ site_a = new_site(owner: user, domain: "alpha.example.com")
+ _site_b = new_site(owner: user, domain: "beta.example.com")
+
+ page_via_build =
+ user
+ |> Index.build(filter_by_domain: "alpha")
+ |> Index.paginate(1, 24)
+
+ page_via_update =
+ user
+ |> Index.build()
+ |> Index.update_state(:filter_by_domain, "alpha")
+ |> Index.paginate(1, 24)
+
+ assert page_via_build.entries == [site_a.id]
+ assert page_via_update.entries == [site_a.id]
+ end
+ end
+
+ describe "sort/2" do
+ test "alnum asc -> desc flips order, no traffic map, no extra queries" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+ assert state.ordered_ids == [site_a.id, site_z.id]
+
+ new_state = Index.sort(state, sort_direction: :desc)
+ assert new_state.ordered_ids == [site_z.id, site_a.id]
+ assert new_state.sort_by == :alnum
+ assert new_state.sort_direction == :desc
+ assert new_state.traffic == %{}
+ end
+
+ test "alnum -> traffic: fetches traffic from ClickHouse and re-sorts" do
+ user = new_user()
+ site_low = new_site(owner: user)
+ site_high = new_site(owner: user)
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_high, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2)
+ ])
+
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc)
+ assert state.traffic == %{}
+
+ new_state = Index.sort(state, sort_by: :traffic, sort_direction: :desc)
+
+ assert new_state.sort_by == :traffic
+ assert new_state.sort_direction == :desc
+ assert map_size(new_state.traffic) == 2
+ assert new_state.ordered_ids == [site_high.id, site_low.id]
+ end
+
+ test "traffic -> alnum: clears traffic map, re-sorts by domain without querying ClickHouse" do
+ user = new_user()
+ site_z = new_site(owner: user, domain: "z.example.com")
+ site_a = new_site(owner: user, domain: "a.example.com")
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_z, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+ assert map_size(state.traffic) == 1
+
+ new_state = Index.sort(state, sort_by: :alnum, sort_direction: :asc)
+
+ assert new_state.sort_by == :alnum
+ assert new_state.sort_direction == :asc
+ assert new_state.traffic == %{}
+ assert new_state.ordered_ids == [site_a.id, site_z.id]
+ end
+
+ test "traffic desc -> traffic asc: reuses existing traffic map, no CH query" do
+ user = new_user()
+ site_low = new_site(owner: user, domain: "low.example.com")
+ site_high = new_site(owner: user, domain: "high.example.com")
+
+ now = NaiveDateTime.utc_now()
+
+ populate_stats(site_high, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 1),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 2)
+ ])
+
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 3)
+ ])
+
+ state = Index.build(user, sort_by: :traffic, sort_direction: :desc)
+ assert state.ordered_ids == [site_high.id, site_low.id]
+ original_traffic = state.traffic
+
+ # more events, not re-queried
+ populate_stats(site_low, [
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 4),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 5),
+ build(:pageview, timestamp: NaiveDateTime.add(now, -1, :hour), user_id: 6)
+ ])
+
+ new_state = Index.sort(state, sort_direction: :asc)
+
+ assert new_state.sort_direction == :asc
+ assert new_state.traffic == original_traffic
+ assert new_state.ordered_ids == [site_low.id, site_high.id]
+ end
+
+ test "preserves user, pins, and unrelated opts" do
+ user = new_user()
+ site = new_site(owner: user)
+
+ {:ok, _} = Plausible.Sites.toggle_pin(user, site)
+
+ state = Index.build(user, sort_by: :alnum, sort_direction: :asc, filter_by_domain: "")
+ new_state = Index.sort(state, sort_direction: :desc)
+ assert new_state.user == state.user
+ assert new_state.pins == state.pins
+ assert new_state.ordered_ids == [site.id]
+ end
+ end
+end
diff --git a/test/plausible_web/live/customer_support/teams_test.exs b/test/plausible_web/live/customer_support/teams_test.exs
index c045aa2710..88dff7fd67 100644
--- a/test/plausible_web/live/customer_support/teams_test.exs
+++ b/test/plausible_web/live/customer_support/teams_test.exs
@@ -162,6 +162,10 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest do
end
describe "sites" do
+ @arrow_down "↓"
+ @arrow_up "↑"
+ @arrow_up_down "↕"
+
test "lists sites belonging to a team", %{conn: conn, user: user} do
team = team_of(user)
new_site(owner: user, domain: "primary.example.com/test")
@@ -182,6 +186,131 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest do
refute text =~ "condolidated.example.com"
refute text =~ "other.example.com"
end
+
+ test "paginates sites", %{conn: conn, user: user} do
+ team = team_of(user)
+
+ for i <- 1..24 do
+ new_site(owner: user, domain: "site-#{String.pad_leading("#{i}", 2, "0")}.example.com")
+ end
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+ html = render(lv)
+
+ assert element_exists?(html, ~s|nav[aria-label="Pagination"]|)
+ assert text(html) =~ "Total of 25 sites"
+ assert text(html) =~ "Page 1 of 2"
+
+ lv |> render_patch(open_team(team.id, tab: "sites", page: 2))
+ html = render(lv)
+
+ assert text(html) =~ "Page 2 of 2"
+
+ lv |> render_patch(open_team(team.id, tab: "sites", page: 1))
+ html = render(lv)
+
+ assert text(html) =~ "Page 1 of 2"
+ end
+
+ test "shows no pagination when sites fit on one page", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "only-site.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+ html = render(lv)
+
+ refute element_exists?(html, ~s|nav[aria-label="Pagination"]|)
+ assert text(html) =~ "only-site.example.com"
+ end
+
+ test "sorts by domain ascending when Domain header is clicked", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "zebra.example.com")
+ new_site(owner: user, domain: "apple.example.com")
+ new_site(owner: user, domain: "mango.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+
+ lv
+ |> element(~s|th[phx-value-by="alnum"]|)
+ |> render_click()
+
+ html = render(lv)
+ domains = extract_domains(html)
+
+ assert domains == Enum.sort(domains)
+ end
+
+ test "flips to descending when Domain header is clicked twice", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "zebra.example.com")
+ new_site(owner: user, domain: "apple.example.com")
+ new_site(owner: user, domain: "mango.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+
+ lv |> element(~s|th[phx-value-by="alnum"]|) |> render_click()
+ lv |> element(~s|th[phx-value-by="alnum"]|) |> render_click()
+
+ html = render(lv)
+ domains = extract_domains(html)
+
+ assert domains == Enum.sort(domains, :desc)
+ end
+
+ test "flips direction when Traffic header is clicked twice", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "zebra.example.com")
+ new_site(owner: user, domain: "apple.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+
+ # default is traffic desc, click to flip
+ html_after_first = lv |> element(~s|th[phx-value-by="traffic"]|) |> render_click()
+ html_after_second = lv |> element(~s|th[phx-value-by="traffic"]|) |> render_click()
+
+ assert text(html_after_first) =~ @arrow_up
+ assert text(html_after_second) =~ @arrow_down
+ end
+
+ test "switches from traffic sort to domain sort", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "zebra.example.com")
+ new_site(owner: user, domain: "apple.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+
+ # default active column is traffic down
+ assert text(render(lv)) =~ @arrow_down
+
+ lv |> element(~s|th[phx-value-by="alnum"]|) |> render_click()
+
+ html = render(lv)
+ domains = extract_domains(html)
+
+ # now sorted alphabetically
+ assert domains == Enum.sort(domains)
+ end
+
+ test "shows sort arrow only on active column", %{conn: conn, user: user} do
+ team = team_of(user)
+ new_site(owner: user, domain: "apple.example.com")
+
+ {:ok, lv, _html} = live(conn, open_team(team.id, tab: "sites"))
+
+ html = render(lv)
+ traffic_th = text_of_element(html, ~s|th[phx-value-by="traffic"]|)
+ domain_th = text_of_element(html, ~s|th[phx-value-by="alnum"]|)
+
+ # traffic is the default active sort, has a directional arrow
+ assert traffic_th =~ @arrow_down
+ refute traffic_th =~ @arrow_up_down
+
+ # domain sort is inactive
+ assert domain_th =~ @arrow_up_down
+ refute domain_th =~ @arrow_up
+ refute domain_th =~ @arrow_down
+ end
end
@create_consolidated_view_button ~s|button[phx-click="create-consolidated-view"]|
@@ -912,5 +1041,17 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest do
for i <- 1..3, do: assert(text =~ "Entry (#{i})")
end
end
+
+ defp extract_domains(html) do
+ domains =
+ html
+ |> find("tbody tr td:first-child a")
+ |> Enum.map(&text/1)
+ |> Enum.map(&String.trim/1)
+ |> Enum.reject(&(&1 == ""))
+
+ assert [_ | _] = domains
+ domains
+ end
end
end