Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
24h sort by traffic in CRM (#6124)
Adam Rutkowskib75d6781b01b
diff --git a/assets/js/liveview/live_socket.js b/assets/js/liveview/live_socket.jsindex 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 = liveSocketdiff --git a/extra/lib/plausible_web/live/customer_support/team.ex b/extra/lib/plausible_web/live/customer_support/team.exindex 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 doteam = 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 domodule={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.exindex 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 doTeam 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)}enddef 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>+ """+ endenddiff --git a/lib/plausible/sites/index.ex b/lib/plausible/sites/index.exnew file mode 100644index 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+enddiff --git a/lib/plausible/teams/sites.ex b/lib/plausible/teams/sites.exindex 3ffe7136e9..1aabfc20c6 100644--- a/lib/plausible/teams/sites.ex+++ b/lib/plausible/teams/sites.ex@@ -109,4 +109,50 @@ defmodule Plausible.Teams.Sites doenddefp 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+ endenddiff --git a/lib/plausible_web/live/components/pagination.ex b/lib/plausible_web/live/components/pagination.exindex 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 doPagination components for LiveViews."""use Phoenix.Component+ alias Phoenix.LiveView.JSdef 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? dodiff --git a/test/plausible/sites/index_test.exs b/test/plausible/sites/index_test.exsnew file mode 100644index 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+enddiff --git a/test/plausible_web/live/customer_support/teams_test.exs b/test/plausible_web/live/customer_support/teams_test.exsindex 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 doenddescribe "sites" do+ @arrow_down "↓"+ @arrow_up "↑"+ @arrow_up_down "↕"+test "lists sites belonging to a team", %{conn: conn, user: user} doteam = team_of(user)new_site(owner: user, domain: "primary.example.com/test")@@ -182,6 +186,131 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest dorefute 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+ endend@create_consolidated_view_button ~s|button[phx-click="create-consolidated-view"]|@@ -912,5 +1041,17 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest dofor i <- 1..3, do: assert(text =~ "Entry (#{i})")endend++ 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+ endendend