Skip to content

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

Live.Dashboard.Pages continued (#5975)

RobertJoonasbf1971ea6dc5
diff --git a/assets/js/liveview/dashboard_tabs.js b/assets/js/liveview/dashboard_tabs.js
index 006cf52c38..476fbc9ebf 100644
--- a/assets/js/liveview/dashboard_tabs.js
+++ b/assets/js/liveview/dashboard_tabs.js
@@ -16,19 +16,19 @@ export default buildHook({
this.addListener('click', this.el, (e) => {
const button = e.target.closest('button')
- const tab = button && button.dataset.tab
+ const tabKey = button && button.dataset.tabKey
const span = button && button.querySelector('span')
if (span && span.dataset.active === 'false') {
- const label = button.dataset.label
+ const reportLabel = button.dataset.reportLabel
const storageKey = button.dataset.storageKey
const target = button.dataset.target
const tile = this.el.closest('[data-tile]')
const title = tile.querySelector('[data-title]')
- title.innerText = label
+ title.innerText = reportLabel
- this.el.querySelectorAll(`button[data-tab] span`).forEach((s) => {
+ this.el.querySelectorAll(`button[data-tab-key] span`).forEach((s) => {
this.js().setAttribute(s, 'data-active', 'false')
})
@@ -39,10 +39,10 @@ export default buildHook({
)
if (storageKey) {
- localStorage.setItem(`${storageKey}__${domain}`, tab)
+ localStorage.setItem(`${storageKey}__${domain}`, tabKey)
}
- this.pushEventTo(target, 'set-tab', { tab: tab })
+ this.pushEventTo(target, 'set-tab', { tab: tabKey })
}
})
}
diff --git a/assets/js/liveview/live_socket.js b/assets/js/liveview/live_socket.js
index 627eaff7a4..60ae66a0cd 100644
--- a/assets/js/liveview/live_socket.js
+++ b/assets/js/liveview/live_socket.js
@@ -79,7 +79,12 @@ if (csrfToken && websocketUrl) {
// The prefs are used by dashboard LiveView to persist
// user preferences across the reloads.
user_prefs: {
- pages_tab: localStorage.getItem(`pageTab__${domainName}`)
+ pages_tab: localStorage.getItem(`pageTab__${domainName}`),
+ period: localStorage.getItem(`period__${domainName}`),
+ comparison: localStorage.getItem(`comparison_mode__${domainName}`),
+ match_day_of_week: localStorage.getItem(
+ `comparison_match_day_of_week__${domainName}`
+ )
},
_csrf_token: token
}
diff --git a/lib/plausible/stats/api_query_parser.ex b/lib/plausible/stats/api_query_parser.ex
index f285a5749e..e16dccf190 100644
--- a/lib/plausible/stats/api_query_parser.ex
+++ b/lib/plausible/stats/api_query_parser.ex
@@ -13,7 +13,8 @@ defmodule Plausible.Stats.ApiQueryParser do
trim_relative_date_range: false,
compare: nil,
compare_match_day_of_week: false,
- legacy_time_on_page_cutoff: nil
+ legacy_time_on_page_cutoff: nil,
+ dashboard_metric_labels: false
}
def default_include(), do: @default_include
diff --git a/lib/plausible/stats/dashboard_query_parser.ex b/lib/plausible/stats/dashboard_query_parser.ex
index 75875287f7..4b95d9fe91 100644
--- a/lib/plausible/stats/dashboard_query_parser.ex
+++ b/lib/plausible/stats/dashboard_query_parser.ex
@@ -14,12 +14,13 @@ defmodule Plausible.Stats.DashboardQueryParser do
# might still want to know whether imported data can be toggled
# on/off on the dashboard.
imports_meta: true,
- time_labels: true,
+ time_labels: false,
total_rows: false,
trim_relative_date_range: true,
compare: nil,
compare_match_day_of_week: true,
- legacy_time_on_page_cutoff: nil
+ legacy_time_on_page_cutoff: nil,
+ dashboard_metric_labels: true
}
def default_include(), do: @default_include
@@ -28,22 +29,47 @@ defmodule Plausible.Stats.DashboardQueryParser do
def default_pagination(), do: @default_pagination
- def parse(query_string, defaults \\ %{}) when is_binary(query_string) do
+ @valid_period_shorthands %{
+ "realtime" => :realtime,
+ "day" => :day,
+ "month" => :month,
+ "year" => :year,
+ "all" => :all,
+ "7d" => {:last_n_days, 7},
+ "28d" => {:last_n_days, 28},
+ "30d" => {:last_n_days, 30},
+ "91d" => {:last_n_days, 91},
+ "6mo" => {:last_n_months, 6},
+ "12mo" => {:last_n_months, 12}
+ }
+
+ @valid_period_shorthand_keys Map.keys(@valid_period_shorthands)
+
+ @valid_comparison_shorthands %{
+ "previous_period" => :previous_period,
+ "year_over_year" => :year_over_year
+ }
+
+ @valid_comparison_shorthand_keys Map.keys(@valid_comparison_shorthands)
+
+ def parse(query_string, site, user_prefs) when is_binary(query_string) do
query_string = String.trim_leading(query_string, "?")
- params_map = Map.merge(defaults, URI.decode_query(query_string))
+ params_map = URI.decode_query(query_string)
with {:ok, filters} <- parse_filters(query_string),
{:ok, relative_date} <- parse_relative_date(params_map) do
+ input_date_range = parse_input_date_range(params_map, site, user_prefs)
+
include =
Map.merge(@default_include, %{
imports: parse_include_imports(params_map),
- compare: parse_include_compare(params_map),
- compare_match_day_of_week: parse_include_compare_match_day_of_week(params_map)
+ compare: parse_include_compare(params_map, user_prefs),
+ compare_match_day_of_week: parse_match_day_of_week(params_map, user_prefs)
})
{:ok,
ParsedQueryParams.new!(%{
- input_date_range: parse_input_date_range(params_map),
+ input_date_range: input_date_range,
relative_date: relative_date,
filters: filters,
include: include
@@ -51,25 +77,29 @@ defmodule Plausible.Stats.DashboardQueryParser do
end
end
- defp parse_input_date_range(%{"period" => "realtime"}), do: :realtime
- defp parse_input_date_range(%{"period" => "day"}), do: :day
- defp parse_input_date_range(%{"period" => "month"}), do: :month
- defp parse_input_date_range(%{"period" => "year"}), do: :year
- defp parse_input_date_range(%{"period" => "all"}), do: :all
- defp parse_input_date_range(%{"period" => "7d"}), do: {:last_n_days, 7}
- defp parse_input_date_range(%{"period" => "28d"}), do: {:last_n_days, 28}
- defp parse_input_date_range(%{"period" => "30d"}), do: {:last_n_days, 30}
- defp parse_input_date_range(%{"period" => "91d"}), do: {:last_n_days, 91}
- defp parse_input_date_range(%{"period" => "6mo"}), do: {:last_n_months, 6}
- defp parse_input_date_range(%{"period" => "12mo"}), do: {:last_n_months, 12}
+ defp parse_input_date_range(%{"period" => period}, _site, _user_prefs)
+ when period in @valid_period_shorthand_keys do
+ @valid_period_shorthands[period]
+ end
- defp parse_input_date_range(%{"period" => "custom", "from" => from, "to" => to}) do
+ defp parse_input_date_range(
+ %{"period" => "custom", "from" => from, "to" => to},
+ _site,
+ _user_prefs
+ ) do
from_date = Date.from_iso8601!(String.trim(from))
to_date = Date.from_iso8601!(String.trim(to))
{:date_range, from_date, to_date}
end
- defp parse_input_date_range(_), do: nil
+ defp parse_input_date_range(_params, _site, %{"period" => period})
+ when period in @valid_period_shorthand_keys do
+ @valid_period_shorthands[period]
+ end
+
+ defp parse_input_date_range(_params, site, _user_prefs) do
+ if recently_created?(site), do: :day, else: {:last_n_days, 28}
+ end
defp parse_relative_date(%{"date" => date}) do
case Date.from_iso8601(date) do
@@ -83,19 +113,30 @@ defmodule Plausible.Stats.DashboardQueryParser do
defp parse_include_imports(%{"with_imported" => "false"}), do: false
defp parse_include_imports(_), do: true
- defp parse_include_compare(%{"comparison" => "previous_period"}), do: :previous_period
- defp parse_include_compare(%{"comparison" => "year_over_year"}), do: :year_over_year
+ defp parse_include_compare(%{"comparison" => "off"}, _user_prefs), do: nil
+
+ defp parse_include_compare(%{"comparison" => comparison}, _user_prefs)
+ when comparison in @valid_comparison_shorthand_keys do
+ @valid_comparison_shorthands[comparison]
+ end
- defp parse_include_compare(%{"comparison" => "custom"} = params) do
+ defp parse_include_compare(%{"comparison" => "custom"} = params, _user_prefs) do
from_date = Date.from_iso8601!(params["compare_from"])
to_date = Date.from_iso8601!(params["compare_to"])
{:date_range, from_date, to_date}
end
- defp parse_include_compare(_options), do: nil
+ defp parse_include_compare(_params, %{"comparison" => comparison})
+ when comparison in @valid_comparison_shorthand_keys do
+ @valid_comparison_shorthands[comparison]
+ end
+
+ defp parse_include_compare(_params, _user_prefs), do: nil
- defp parse_include_compare_match_day_of_week(%{"match_day_of_week" => "false"}), do: false
- defp parse_include_compare_match_day_of_week(_), do: true
+ defp parse_match_day_of_week(%{"match_day_of_week" => "false"}, _user_prefs), do: false
+ defp parse_match_day_of_week(%{"match_day_of_week" => "true"}, _user_prefs), do: true
+ defp parse_match_day_of_week(_params, %{"match_day_of_week" => "false"}), do: false
+ defp parse_match_day_of_week(_params, _user_prefs), do: true
defp parse_filters(query_string) do
with {:ok, filters} <- decode_filters(query_string) do
@@ -155,4 +196,9 @@ defmodule Plausible.Stats.DashboardQueryParser do
defp event_dimension?(dimension) do
dimension in @event_dimensions or String.starts_with?(dimension, @event_props_prefix)
end
+
+ defp recently_created?(site) do
+ stats_start_date = NaiveDateTime.to_date(site.native_stats_start_at)
+ Date.diff(stats_start_date, Date.utc_today()) >= -1
+ end
end
diff --git a/lib/plausible/stats/filters/filters.ex b/lib/plausible/stats/filters/filters.ex
index 3d1eb43899..9bcfa2f545 100644
--- a/lib/plausible/stats/filters/filters.ex
+++ b/lib/plausible/stats/filters/filters.ex
@@ -114,9 +114,9 @@ defmodule Plausible.Stats.Filters do
|> Enum.map(fn {[_operator, dimension | _rest], _depth} -> dimension end)
end
- def filtering_on_dimension?(query, dimension, opts \\ []) do
+ def filtering_on_dimension?(query_or_filters, dimension, opts \\ []) do
filters =
- case query do
+ case query_or_filters do
%Query{filters: filters} -> filters
%{filters: filters} -> filters
filters when is_list(filters) -> filters
diff --git a/lib/plausible/stats/metrics.ex b/lib/plausible/stats/metrics.ex
index c4673ae738..d835c11418 100644
--- a/lib/plausible/stats/metrics.ex
+++ b/lib/plausible/stats/metrics.ex
@@ -55,4 +55,17 @@ defmodule Plausible.Stats.Metrics do
def from_string(str) do
Map.fetch(@metric_mappings, str)
end
+
+ def dashboard_metric_label(:visitors, %{realtime?: true}), do: "Current visitors"
+ def dashboard_metric_label(:visitors, %{goal_filter?: true}), do: "Conversions"
+
+ def dashboard_metric_label(:visitors, %{dimensions: ["visit:entry_page"]}),
+ do: "Unique entrances"
+
+ def dashboard_metric_label(:visitors, %{dimensions: ["visit:exit_page"]}), do: "Unique exits"
+ def dashboard_metric_label(:visitors, _context), do: "Visitors"
+
+ def dashboard_metric_label(:conversion_rate, _context), do: "CR"
+
+ def dashboard_metric_label(metric, _context), do: "#{metric}"
end
diff --git a/lib/plausible/stats/parsed_query_params.ex b/lib/plausible/stats/parsed_query_params.ex
index 0c473db7a8..f596be2a51 100644
--- a/lib/plausible/stats/parsed_query_params.ex
+++ b/lib/plausible/stats/parsed_query_params.ex
@@ -44,4 +44,11 @@ defmodule Plausible.Stats.ParsedQueryParams do
struct!(parsed_query_params, filters: new_filters)
end
+
+ def conversion_goal_filter?(%__MODULE__{filters: filters}) do
+ Plausible.Stats.Filters.filtering_on_dimension?(filters, "event:goal",
+ max_depth: 0,
+ behavioral_filters: :ignore
+ )
+ end
end
diff --git a/lib/plausible/stats/query_include.ex b/lib/plausible/stats/query_include.ex
index 1a128e5ea0..12a559e222 100644
--- a/lib/plausible/stats/query_include.ex
+++ b/lib/plausible/stats/query_include.ex
@@ -8,7 +8,8 @@ defmodule Plausible.Stats.QueryInclude do
trim_relative_date_range: false,
compare: nil,
compare_match_day_of_week: false,
- legacy_time_on_page_cutoff: nil
+ legacy_time_on_page_cutoff: nil,
+ dashboard_metric_labels: false
@type date_range_tuple() :: {:date_range, Date.t(), Date.t()}
@type datetime_range_tuple() :: {:datetime_range, DateTime.t(), DateTime.t()}
@@ -22,6 +23,7 @@ defmodule Plausible.Stats.QueryInclude do
compare:
nil | :previous_period | :year_over_year | date_range_tuple() | datetime_range_tuple(),
compare_match_day_of_week: boolean(),
- legacy_time_on_page_cutoff: any()
+ legacy_time_on_page_cutoff: any(),
+ dashboard_metric_labels: boolean()
}
end
diff --git a/lib/plausible/stats/query_result.ex b/lib/plausible/stats/query_result.ex
index 64c7c4f593..46b8088421 100644
--- a/lib/plausible/stats/query_result.ex
+++ b/lib/plausible/stats/query_result.ex
@@ -8,7 +8,7 @@ defmodule Plausible.Stats.QueryResult do
"""
use Plausible
- alias Plausible.Stats.{Query, QueryRunner}
+ alias Plausible.Stats.{Query, QueryRunner, QueryInclude}
defstruct results: [],
meta: %{},
@@ -62,6 +62,7 @@ defmodule Plausible.Stats.QueryResult do
%{}
|> add_imports_meta(runner.main_query)
|> add_metric_warnings_meta(runner.main_query)
+ |> add_dashboard_metric_labels(runner.main_query)
|> add_time_labels_meta(runner.main_query)
|> add_total_rows_meta(runner.main_query, runner.total_rows)
end
@@ -90,6 +91,32 @@ defmodule Plausible.Stats.QueryResult do
end
end
+ defp add_dashboard_metric_labels(meta, %Query{
+ include: %QueryInclude{dashboard_metric_labels: false}
+ }) do
+ meta
+ end
+
+ defp add_dashboard_metric_labels(meta, query) do
+ context = %{
+ goal_filter?:
+ Plausible.Stats.Filters.filtering_on_dimension?(query, "event:goal",
+ max_depth: 0,
+ behavioral_filters: :ignore
+ ),
+ realtime?: query.input_date_range in [:realtime, :realtime_30m],
+ dimensions: query.dimensions
+ }
+
+ metric_labels =
+ query.metrics
+ |> Enum.map(fn metric ->
+ Plausible.Stats.Metrics.dashboard_metric_label(metric, context)
+ end)
+
+ Map.put(meta, :metric_labels, metric_labels)
+ end
+
defp add_time_labels_meta(meta, query) do
if query.include.time_labels do
Map.put(meta, :time_labels, Plausible.Stats.Time.time_labels(query))
diff --git a/lib/plausible_web/live/components/dashboard/base.ex b/lib/plausible_web/live/components/dashboard/base.ex
index e57201ff4d..b44167d25b 100644
--- a/lib/plausible_web/live/components/dashboard/base.ex
+++ b/lib/plausible_web/live/components/dashboard/base.ex
@@ -77,6 +77,7 @@ defmodule PlausibleWeb.Components.Dashboard.Base do
<div class="w-full h-full relative" style={@style}>
<div
class={"absolute top-0 left-0 h-full rounded-sm transition-colors duration-150 #{@background_class || ""}"}
+ data-test-id="bar-indicator"
style={"width: #{@width_percent}%"}
>
</div>
diff --git a/lib/plausible_web/live/components/dashboard/report_list.ex b/lib/plausible_web/live/components/dashboard/report_list.ex
index 649c177a71..474748c207 100644
--- a/lib/plausible_web/live/components/dashboard/report_list.ex
+++ b/lib/plausible_web/live/components/dashboard/report_list.ex
@@ -7,6 +7,7 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
alias PlausibleWeb.Components.Dashboard.Base
alias PlausibleWeb.Components.Dashboard.Metric
+ alias Plausible.Stats.QueryResult
@max_items 9
@min_height 380
@@ -28,49 +29,44 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
col_min_width: @col_min_width
)
- if assigns.results.loading || !assigns.results.ok? do
+ if assigns.query_result.loading || !assigns.query_result.ok? do
~H"""
"""
else
- results = assigns.results.result
- metrics = assigns.metrics.result
- meta = assigns.meta.result
- skip_imported_reason = assigns.skip_imported_reason.result
-
- max_value =
- results
- |> Enum.map(& &1.visitors)
- |> Enum.max(&>=/2, fn -> 0 end)
+ %QueryResult{results: results, meta: meta, query: query} = assigns.query_result.result
assigns =
assign(assigns,
- max_value: max_value,
results: results,
- metrics: metrics,
- meta: meta,
- skip_imported_reason: skip_imported_reason,
+ metric_keys: query[:metrics],
+ metric_labels: meta[:metric_labels],
empty?: Enum.empty?(results)
)
~H"""
<.no_data :if={@empty?} min_height={@min_height} />
- <div :if={not @empty?} class="h-full flex flex-col">
+ <div :if={not @empty?} class="h-full flex flex-col" data-test-id={@data_test_id}>
<div style={"row-height: #{@row_height}px;"}>
- <.report_header key_label={@key_label} metrics={@metrics} col_min_width={@col_min_width} />
+ <.report_header
+ key_label={@key_label}
+ metric_labels={@metric_labels}
+ col_min_width={@col_min_width}
+ />
</div>
<div class="grow" style={"min-height: #{@data_container_height}px;"}>
<.report_row
- :for={item <- @results}
+ :for={{item, item_index} <- Enum.with_index(@results)}
link_fn={assigns[:external_link_fn]}
item={item}
- metrics={@metrics}
- bar_value={item.visitors}
- bar_max_value={@max_value}
+ item_index={item_index}
+ item_name={List.first(item.dimensions)}
+ metrics={Enum.zip(@metric_keys, item.metrics)}
+ bar_max_value={bar_max_value(@results, @metric_keys)}
site={@site}
params={@params}
- filter_dimension={@filter_dimension}
+ dimension={@dimension}
row_height={@row_height}
row_gap_height={@row_gap_height}
col_min_width={@col_min_width}
@@ -132,13 +128,14 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
defp report_header(assigns) do
~H"""
<div class="pt-3 w-full text-xs font-bold tracking-wide text-gray-500 flex items-center dark:text-gray-400">
- <span class="grow truncate">{@key_label}</span>
+ <span data-test-id="report-list-0-0" class="grow truncate">{@key_label}</span>
<div
- :for={metric <- @metrics}
- class={[metric.key, "text-right"]}
+ :for={{metric_label, index} <- Enum.with_index(@metric_labels)}
+ class="text-right"
style={"min-width: #{@col_min_width}px;"}
+ data-test-id={"report-list-0-#{1 + index}"}
>
- {metric.label}
+ {metric_label}
</div>
</div>
"""
@@ -151,9 +148,9 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
class="group flex w-full items-center hover:bg-gray-100/60 dark:hover:bg-gray-850 rounded-sm transition-colors duration-150"
style={"margin-top: #{@row_gap_height}px;"}
>
- <div class="grow w-full overflow-hidden">
+ <div class="grow w-full overflow-hidden" data-test-id={"report-list-#{1 + @item_index}-0"}>
<Base.bar
- width={@bar_value}
+ width={@metrics[:visitors]}
max_width={@bar_max_value}
background_class="bg-green-50 group-hover:bg-green-100 dark:bg-gray-500/15 dark:group-hover:bg-gray-500/30"
>
@@ -163,9 +160,9 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
class="max-w-max w-full flex items-center md:overflow-hidden hover:underline"
site={@site}
params={@params}
- filter={[:is, @filter_dimension, [@item.name]]}
+ filter={[:is, @dimension, [@item_name]]}
>
- {trim_name(@item.name, @col_min_width)}
+ {trim_name(@item_name, @col_min_width)}
</Base.filter_link>
</span>
<.external_link item={@item} link_fn={assigns[:link_fn]} />
@@ -173,12 +170,15 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
</Base.bar>
</div>
<div
- :for={metric <- @metrics}
+ :for={{{metric_key, metric_value}, metric_index} <- Enum.with_index(@metrics)}
class="text-right"
style={"width: #{@col_min_width}px; min-width: #{@col_min_width}px;"}
>
- <span class="font-medium text-sm dark:text-gray-200 text-right">
- <Metric.value name={metric.key} value={@item[metric.key]} />
+ <span
+ class="font-medium text-sm dark:text-gray-200 text-right"
+ data-test-id={"report-list-#{1 + @item_index}-#{1 + metric_index}"}
+ >
+ <Metric.value name={metric_key} value={metric_value} />
</span>
</div>
</div>
@@ -212,6 +212,15 @@ defmodule PlausibleWeb.Components.Dashboard.ReportList do
"""
end
+ @bar_metric :visitors
+ defp bar_max_value(results, metrics) do
+ index = Enum.find_index(metrics, &(&1 == @bar_metric))
+
+ results
+ |> Enum.map(&Enum.at(&1.metrics, index))
+ |> Enum.max(&>=/2, fn -> 0 end)
+ end
+
defp trim_name(name, max_length) do
if String.length(name) <= max_length do
name
diff --git a/lib/plausible_web/live/components/dashboard/tile.ex b/lib/plausible_web/live/components/dashboard/tile.ex
index 7561a5abc5..e8b7145fa2 100644
--- a/lib/plausible_web/live/components/dashboard/tile.ex
+++ b/lib/plausible_web/live/components/dashboard/tile.ex
@@ -10,6 +10,7 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
attr :title, :string, required: true
attr :height, :integer, required: true
attr :connected?, :boolean, required: true
+ attr :target, :any, required: true
slot :tabs
slot :inner_block, required: true
@@ -26,6 +27,7 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
:if={@tabs != []}
id={@id <> "-tabs"}
phx-hook="DashboardTabs"
+ phx-target={@target}
class="tile-tabs flex text-xs font-medium text-gray-500 dark:text-gray-400 space-x-2 items-baseline"
>
{render_slot(@tabs)}
@@ -48,9 +50,9 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
"""
end
- attr :label, :string, required: true
- attr :value, :string, required: true
- attr :active, :string, required: true
+ attr :report_label, :string, required: true
+ attr :tab_key, :string, required: true
+ attr :active_tab, :string, required: true
attr :target, :any, required: true
def tab(assigns) do
@@ -58,7 +60,7 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
assign(
assigns,
data_attrs:
- if(assigns.value == assigns.active,
+ if(assigns.tab_key == assigns.active_tab,
do: %{"data-active": "true"},
else: %{"data-active": "false"}
)
@@ -67,8 +69,8 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
~H"""
<button
class="rounded-sm truncate text-left transition-colors duration-150"
- data-tab={@value}
- data-label={@label}
+ data-tab-key={@tab_key}
+ data-report-label={@report_label}
data-storage-key="pageTab"
data-target={@target}
>
@@ -76,7 +78,7 @@ defmodule PlausibleWeb.Components.Dashboard.Tile do
{@data_attrs}
class="data-[active=true]:text-indigo-600 data-[active=true]:dark:text-indigo-500 data-[active=true]:font-bold data-[active=true]:underline data-[active=true]:decoration-2 data-[active=true]:decoration-indigo-600 data-[active=true]:dark:decoration-indigo-500 data-[active=false]:hover:text-indigo-700 data-[active=false]:dark:hover:text-indigo-400 data-[active=false]:cursor-pointer"
>
- {@label}
+ {@report_label}
</span>
</button>
"""
diff --git a/lib/plausible_web/live/dashboard.ex b/lib/plausible_web/live/dashboard.ex
index 5a7cd197d8..6e1360bbfa 100644
--- a/lib/plausible_web/live/dashboard.ex
+++ b/lib/plausible_web/live/dashboard.ex
@@ -9,10 +9,6 @@ defmodule PlausibleWeb.Live.Dashboard do
alias Plausible.Stats.DashboardQueryParser
alias Plausible.Teams
- @default_prefs %{
- "period" => "28d"
- }
-
@spec enabled?(Plausible.Site.t() | nil) :: boolean()
def enabled?(nil), do: false
@@ -21,8 +17,7 @@ defmodule PlausibleWeb.Live.Dashboard do
end
def mount(_params, %{"domain" => domain, "url" => url}, socket) do
- # NOTE: implement a dedicated, permissive params fallback.
- user_prefs = Map.merge(@default_prefs, get_connect_params(socket)["user_prefs"] || %{})
+ user_prefs = get_connect_params(socket)["user_prefs"] || %{}
# As domain is passed via session, the associated site has already passed
# validation logic on plug level.
@@ -49,7 +44,13 @@ defmodule PlausibleWeb.Live.Dashboard do
def handle_params_internal(_params, url, socket) do
uri = URI.parse(url)
path = uri.path |> String.split("/") |> Enum.drop(2)
- {:ok, params} = DashboardQueryParser.parse(uri.query || "", socket.assigns.user_prefs)
+
+ {:ok, params} =
+ DashboardQueryParser.parse(
+ uri.query || "",
+ socket.assigns.site,
+ socket.assigns.user_prefs
+ )
socket =
assign(socket,
diff --git a/lib/plausible_web/live/dashboard/pages.ex b/lib/plausible_web/live/dashboard/pages.ex
index ffb9c89e7e..b711db1af2 100644
--- a/lib/plausible_web/live/dashboard/pages.ex
+++ b/lib/plausible_web/live/dashboard/pages.ex
@@ -9,78 +9,30 @@ defmodule PlausibleWeb.Live.Dashboard.Pages do
alias PlausibleWeb.Components.Dashboard.Tile
alias Plausible.Stats
- alias Plausible.Stats.Filters
- alias Plausible.Stats.ParsedQueryParams
- alias Plausible.Stats.QueryBuilder
+ alias Plausible.Stats.{ParsedQueryParams, QueryBuilder, QueryResult}
@tabs [
- {"pages", "Top Pages"},
- {"entry-pages", "Entry Pages"},
- {"exit-pages", "Exit Pages"}
- ]
-
- @key_labels %{
- "pages" => "Page",
- "entry-pages" => "Entry page",
- "exit-pages" => "Exit page"
- }
-
- @max_items 9
- @pagination_params {@max_items, 1}
-
- @metrics %{
- "pages" => %{
- visitors: %{
- width: "w-24",
- key: :visitors,
- label: "Visitors",
- sortable: true,
- plot: true
- },
- conversion_rate: %{
- width: "w-24",
- key: :conversion_rate,
- label: "CR",
- sortable: true
- }
+ %{
+ tab_key: "pages",
+ report_label: "Top pages",
+ key_label: "Page",
+ dimension: "event:page"
},
- "entry-pages" => %{
- visitors: %{
- width: "w-24",
- key: :visitors,
- label: "Unique Entrances",
- sortable: true,
- plot: true
- },
- conversion_rate: %{
- width: "w-24",
- key: :conversion_rate,
- label: "CR",
- sortable: true
- }
+ %{
+ tab_key: "entry-pages",
+ report_label: "Entry pages",
+ key_label: "Entry page",
+ dimension: "visit:entry_page"
},
- "exit-pages" => %{
- visitors: %{
- width: "w-24",
- key: :visitors,
- label: "Unique Exits",
- sortable: true,
- plot: true
- },
- conversion_rate: %{
- width: "w-24",
- key: :conversion_rate,
- label: "CR",
- sortable: true
- }
+ %{
+ tab_key: "exit-pages",
+ report_label: "Exit pages",
+ key_label: "Exit page",
+ dimension: "visit:exit_page"
}
- }
+ ]
- @filter_dimensions %{
- "pages" => "event:page",
- "entry-pages" => "visit:entry_page",
- "exit-pages" => "visit:exit_page"
- }
+ @pagination %{limit: 9, offset: 0}
def update(assigns, socket) do
active_tab = assigns.user_prefs["pages_tab"] || "pages"
@@ -90,12 +42,10 @@ defmodule PlausibleWeb.Live.Dashboard.Pages do
site: assigns.site,
params: assigns.params,
tabs: @tabs,
- key_labels: @key_labels,
- filter_dimensions: @filter_dimensions,
active_tab: active_tab,
connected?: assigns.connected?
)
- |> load_metrics()
+ |> load_stats()
{:ok, socket}
end
@@ -108,29 +58,28 @@ defmodule PlausibleWeb.Live.Dashboard.Pages do
<Tile.tile
id="breakdown-tile-pages"
class="group/report"
- title={@key_labels[@active_tab]}
+ title={get_tab_info(@active_tab, :report_label)}
connected?={@connected?}
+ target={@myself}
height={ReportList.height()}
>
<:tabs>
<Tile.tab
- :for={{value, label} <- @tabs}
- label={label}
- value={value}
- active={@active_tab}
+ :for={%{tab_key: tab_key, report_label: report_label} <- @tabs}
+ report_label={report_label}
+ tab_key={tab_key}
+ active_tab={@active_tab}
target={@myself}
/>
</:tabs>
<ReportList.report
site={@site}
- key_label={@key_labels[@active_tab]}
- filter_dimension={@filter_dimensions[@active_tab]}
+ data_test_id={"#{@active_tab}-report-list"}
+ key_label={get_tab_info(@active_tab, :key_label)}
+ dimension={get_tab_info(@active_tab, :dimension)}
params={@params}
- results={@results}
- meta={@meta}
- metrics={@metrics}
- skip_imported_reason={@skip_imported_reason}
+ query_result={@query_result}
external_link_fn={@external_link_fn}
/>
</Tile.tile>
@@ -143,7 +92,7 @@ defmodule PlausibleWeb.Live.Dashboard.Pages do
socket =
socket
|> assign(:active_tab, tab)
- |> load_metrics()
+ |> load_stats()
{:noreply, socket}
else
@@ -155,97 +104,40 @@ defmodule PlausibleWeb.Live.Dashboard.Pages do
"https://example.com"
end
- defp load_metrics(socket) do
+ defp load_stats(socket) do
%{active_tab: active_tab, site: site, params: params} = socket.assigns
- assign_async(socket, [:metrics, :results, :meta, :skip_imported_reason], fn ->
- %{results: pages, meta: meta, query: query, metrics: metrics} =
- metrics_for_tab(active_tab, site, params)
-
- {:ok,
- %{
- metrics: Enum.map(metrics, &Map.fetch!(@metrics[active_tab], &1)),
- results: Enum.take(pages, @max_items),
- meta: Map.merge(meta, Stats.Breakdown.formatted_date_ranges(query)),
- skip_imported_reason: meta[:imports_skip_reason]
- }}
- end)
- end
-
- defp metrics_for_tab("pages", site, params) do
- params =
- params
- |> ParsedQueryParams.set(dimensions: ["event:page"])
- |> ParsedQueryParams.set_include(:time_labels, false)
-
- {:ok, query} = QueryBuilder.build(site, params, %{})
- metrics = breakdown_metrics(query)
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, @pagination_params)
-
- pages =
- results
- |> transform_keys(%{page: :name})
-
- %{query: query, results: pages, meta: meta, metrics: metrics}
- end
-
- defp metrics_for_tab("entry-pages", site, params) do
- params =
- params
- |> ParsedQueryParams.set(dimensions: ["visit:entry_page"])
- |> ParsedQueryParams.set_include(:time_labels, false)
+ assign_async(socket, :query_result, fn ->
+ metrics = choose_metrics(params)
+ dimension = get_tab_info(active_tab, :dimension)
- {:ok, query} = QueryBuilder.build(site, params, %{})
- metrics = breakdown_metrics(query)
+ params =
+ params
+ |> ParsedQueryParams.set(
+ metrics: metrics,
+ dimensions: [dimension],
+ pagination: @pagination
+ )
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, @pagination_params)
+ query = QueryBuilder.build!(site, params)
- pages =
- results
- |> transform_keys(%{entry_page: :name})
+ %QueryResult{} = query_result = Stats.query(site, query)
- %{query: query, results: pages, meta: meta, metrics: metrics}
- end
-
- defp metrics_for_tab("exit-pages", site, params) do
- params =
- params
- |> ParsedQueryParams.set(dimensions: ["visit:exit_page"])
- |> ParsedQueryParams.set_include(:time_labels, false)
-
- {:ok, query} = QueryBuilder.build(site, params, %{})
- metrics = breakdown_metrics(query)
-
- %{results: results, meta: meta} = Stats.breakdown(site, query, metrics, @pagination_params)
-
- pages =
- results
- |> transform_keys(%{exit_page: :name})
-
- %{query: query, results: pages, meta: meta, metrics: metrics}
+ {:ok, %{query_result: query_result}}
+ end)
end
- defp breakdown_metrics(query) do
- if toplevel_goal_filter?(query) do
+ defp choose_metrics(%ParsedQueryParams{} = params) do
+ if ParsedQueryParams.conversion_goal_filter?(params) do
[:visitors, :conversion_rate]
else
[:visitors]
end
end
- defp transform_keys(result, keys_to_replace) when is_map(result) do
- for {key, val} <- result, do: {Map.get(keys_to_replace, key, key), val}, into: %{}
- end
-
- defp transform_keys(results, keys_to_replace) when is_list(results) do
- Enum.map(results, &transform_keys(&1, keys_to_replace))
- end
-
- defp toplevel_goal_filter?(query) do
- Filters.filtering_on_dimension?(query, "event:goal",
- max_depth: 0,
- behavioral_filters: :ignore
- )
+ defp get_tab_info(tab_key, field) do
+ @tabs
+ |> Enum.find(&(&1.tab_key == tab_key))
+ |> Map.fetch!(field)
end
end
diff --git a/test/plausible/stats/query/dashboard_query_parser_test.exs b/test/plausible/stats/query/dashboard_query_parser_test.exs
index c63c8ebefb..b0906eb633 100644
--- a/test/plausible/stats/query/dashboard_query_parser_test.exs
+++ b/test/plausible/stats/query/dashboard_query_parser_test.exs
@@ -5,11 +5,14 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
@default_include default_include()
+ @yesterday NaiveDateTime.utc_now(:second) |> NaiveDateTime.add(-1, :day)
+ @before_yesterday @yesterday |> NaiveDateTime.add(-1, :day)
+
test "parses an empty query string" do
- {:ok, parsed} = parse("")
+ {:ok, parsed} = parse("", build(:site), %{})
expected = %Plausible.Stats.ParsedQueryParams{
- input_date_range: nil,
+ input_date_range: {:last_n_days, 28},
relative_date: nil,
metrics: [],
filters: [],
@@ -25,81 +28,120 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
describe "period -> input_date_range" do
for period <- [:realtime, :day, :month, :year, :all] do
test "parses #{period} period" do
- {:ok, parsed} = parse("?period=#{Atom.to_string(unquote(period))}")
+ {:ok, parsed} = parse("?period=#{Atom.to_string(unquote(period))}", build(:site), %{})
+ assert_matches %ParsedQueryParams{input_date_range: ^unquote(period)} = parsed
+ end
- assert_matches %ParsedQueryParams{
- input_date_range: ^unquote(period),
- include: ^@default_include
- } = parsed
+ test "parses #{period} period from user prefs" do
+ {:ok, parsed} = parse("", build(:site), %{"period" => Atom.to_string(unquote(period))})
+ assert_matches %ParsedQueryParams{input_date_range: ^unquote(period)} = parsed
end
end
for i <- [7, 28, 30, 91] do
test "parses #{i}d period" do
- {:ok, parsed} = parse("?period=#{unquote(i)}d")
+ {:ok, parsed} = parse("?period=#{unquote(i)}d", build(:site), %{})
+
+ assert_matches %ParsedQueryParams{
+ input_date_range: {:last_n_days, ^unquote(i)}
+ } = parsed
+ end
+
+ test "parses #{i}d period from user_prefs" do
+ {:ok, parsed} = parse("", build(:site), %{"period" => "#{unquote(i)}d"})
assert_matches %ParsedQueryParams{
- input_date_range: {:last_n_days, ^unquote(i)},
- include: ^@default_include
+ input_date_range: {:last_n_days, ^unquote(i)}
} = parsed
end
end
for i <- [6, 12] do
test "parses #{i}mo period" do
- {:ok, parsed} = parse("?period=#{unquote(i)}mo")
+ {:ok, parsed} = parse("?period=#{unquote(i)}mo", build(:site), %{})
+
+ assert_matches %ParsedQueryParams{
+ input_date_range: {:last_n_months, ^unquote(i)}
+ } =
+ parsed
+ end
+
+ test "parses #{i}mo period from user prefs" do
+ {:ok, parsed} = parse("", build(:site), %{"period" => "#{unquote(i)}mo"})
assert_matches %ParsedQueryParams{
- input_date_range: {:last_n_months, ^unquote(i)},
- include: ^@default_include
+ input_date_range: {:last_n_months, ^unquote(i)}
} =
parsed
end
end
test "parses custom period" do
- {:ok, parsed} = parse("?period=custom&from=2021-01-01&to=2021-03-05")
+ {:ok, parsed} = parse("?period=custom&from=2021-01-01&to=2021-03-05", build(:site), %{})
assert %ParsedQueryParams{
- input_date_range: {:date_range, ~D[2021-01-01], ~D[2021-03-05]},
- include: @default_include
+ input_date_range: {:date_range, ~D[2021-01-01], ~D[2021-03-05]}
} = parsed
end
- test "defaults to nil when period param is invalid" do
- {:ok, parsed} = parse("?period=abcde")
+ test "falls back to last 28 days when site created before yesterday" do
+ site = build(:site, native_stats_start_at: @before_yesterday)
+ {:ok, parsed} = parse("", site, %{})
+ assert %ParsedQueryParams{input_date_range: {:last_n_days, 28}} = parsed
+ end
- assert %ParsedQueryParams{
- input_date_range: nil,
- include: @default_include
- } = parsed
+ test "falls back to :day for a recently created site" do
+ site = build(:site, native_stats_start_at: @yesterday)
+ {:ok, parsed} = parse("", site, %{})
+ assert %ParsedQueryParams{input_date_range: :day} = parsed
+ end
+
+ test "falls back to valid user preference" do
+ {:ok, parsed} = parse("", build(:site), %{"period" => "year"})
+ assert %ParsedQueryParams{input_date_range: :year} = parsed
+ end
+
+ test "falls back to valid user preference when period in query string is invalid" do
+ {:ok, parsed} = parse("?period=invalid", build(:site), %{"period" => "month"})
+ assert %ParsedQueryParams{input_date_range: :month} = parsed
+ end
+
+ test "valid period param in query string takes precedence over valid user preference" do
+ {:ok, parsed} = parse("?period=all", build(:site), %{"period" => "month"})
+ assert %ParsedQueryParams{input_date_range: :all} = parsed
+ end
+
+ test "falls back to site default when both query string and user preference period are invalid" do
+ site = build(:site, native_stats_start_at: @yesterday)
+ {:ok, parsed} = parse("?period=invalid", site, %{"period" => "invalid"})
+ assert %ParsedQueryParams{input_date_range: :day} = parsed
end
end
describe "date -> relative_date" do
test "parses a valid iso8601 date string" do
- {:ok, parsed} = parse("?date=2021-05-05")
+ {:ok, parsed} = parse("?date=2021-05-05", build(:site), %{})
assert %ParsedQueryParams{relative_date: ~D[2021-05-05], include: @default_include} = parsed
end
test "errors when invalid date" do
- {:error, :invalid_date} = parse("?date=2021-13-32")
+ {:error, :invalid_date} = parse("?date=2021-13-32", build(:site), %{})
end
end
describe "with_imported -> include.imports" do
test "true -> true" do
- {:ok, parsed} = parse("?with_imported=true")
+ {:ok, parsed} = parse("?with_imported=true", build(:site), %{})
assert %ParsedQueryParams{include: @default_include} = parsed
end
test "invalid -> true" do
- {:ok, parsed} = parse("?with_imported=foo")
+ {:ok, parsed} = parse("?with_imported=foo", build(:site), %{})
assert %ParsedQueryParams{include: @default_include} = parsed
end
test "false -> false" do
- {:ok, parsed} = parse("?with_imported=false")
+ {:ok, parsed} = parse("?with_imported=false", build(:site), %{})
expected_include = Map.put(@default_include, :imports, false)
assert %ParsedQueryParams{include: ^expected_include} = parsed
end
@@ -108,14 +150,25 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
describe "comparison -> include.compare" do
for mode <- [:previous_period, :year_over_year] do
test "parses #{mode} mode" do
- {:ok, parsed} = parse("?comparison=#{unquote(mode)}")
+ {:ok, parsed} = parse("?comparison=#{unquote(mode)}", build(:site), %{})
+ expected_include = Map.put(@default_include, :compare, unquote(mode))
+ assert_matches %ParsedQueryParams{include: ^expected_include} = parsed
+ end
+
+ test "parses #{mode} mode from user prefs" do
+ {:ok, parsed} = parse("", build(:site), %{"comparison" => "#{unquote(mode)}"})
expected_include = Map.put(@default_include, :compare, unquote(mode))
assert_matches %ParsedQueryParams{include: ^expected_include} = parsed
end
end
test "parses custom date range mode" do
- {:ok, parsed} = parse("?comparison=custom&compare_from=2021-01-01&compare_to=2021-04-30")
+ {:ok, parsed} =
+ parse(
+ "?comparison=custom&compare_from=2021-01-01&compare_to=2021-04-30",
+ build(:site),
+ %{}
+ )
expected_include =
Map.put(@default_include, :compare, {:date_range, ~D[2021-01-01], ~D[2021-04-30]})
@@ -123,34 +176,101 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
assert_matches %ParsedQueryParams{include: ^expected_include} = parsed
end
- test "invalid -> nil" do
- {:ok, parsed} = parse("?comparison=invalid_mode")
+ test "custom comparison in query string takes precedence over user prefs" do
+ {:ok, parsed} =
+ parse(
+ "?comparison=custom&compare_from=2021-01-01&compare_to=2021-04-30",
+ build(:site),
+ %{"comparison" => "year_over_year"}
+ )
+
+ expected_include =
+ Map.put(@default_include, :compare, {:date_range, ~D[2021-01-01], ~D[2021-04-30]})
+
+ assert_matches %ParsedQueryParams{include: ^expected_include} = parsed
+ end
+
+ test "falls back to user preference when query string comparison param is invalid" do
+ {:ok, parsed} =
+ parse("?comparison=invalid_mode", build(:site), %{"comparison" => "previous_period"})
+
+ expected_include =
+ Map.put(@default_include, :compare, :previous_period)
+
+ assert_matches %ParsedQueryParams{include: ^expected_include} = parsed
+ end
+
+ test "comparison=off in query string skips stored comparison mode" do
+ {:ok, parsed} =
+ parse("?comparison=off", build(:site), %{"comparison" => "previous_period"})
+
+ assert %ParsedQueryParams{include: @default_include} = parsed
+ end
+
+ test "falls back to nil when comparison param in both query string and user prefs is invalid" do
+ {:ok, parsed} =
+ parse("?comparison=invalid_mode", build(:site), %{"comparison" => "invalid_mode"})
+
assert %ParsedQueryParams{include: @default_include} = parsed
end
end
describe "match_day_of_week -> include.compare_match_day_of_week" do
test "true -> true" do
- {:ok, parsed} = parse("?match_day_of_week=true")
+ {:ok, parsed} = parse("?match_day_of_week=true", build(:site), %{})
assert %ParsedQueryParams{include: @default_include} = parsed
end
test "invalid -> true" do
- {:ok, parsed} = parse("?match_day_of_week=foo")
+ {:ok, parsed} = parse("?match_day_of_week=foo", build(:site), %{})
assert %ParsedQueryParams{include: @default_include} = parsed
end
test "false -> false" do
- {:ok, parsed} = parse("?match_day_of_week=false")
+ {:ok, parsed} = parse("?match_day_of_week=false", build(:site), %{})
+ expected_include = Map.put(@default_include, :compare_match_day_of_week, false)
+ assert %ParsedQueryParams{include: ^expected_include} = parsed
+ end
+
+ test "'true' in query string takes precedence over 'false' in user prefs" do
+ {:ok, parsed} =
+ parse("?match_day_of_week=true", build(:site), %{"match_day_of_week" => "false"})
+
+ assert %ParsedQueryParams{include: @default_include} = parsed
+ end
+
+ test "'false' in query string takes precedence over 'true' in user prefs" do
+ {:ok, parsed} =
+ parse("?match_day_of_week=false", build(:site), %{"match_day_of_week" => "true"})
+
expected_include = Map.put(@default_include, :compare_match_day_of_week, false)
assert %ParsedQueryParams{include: ^expected_include} = parsed
end
+
+ test "falls back to user pref when value in query string is invalid" do
+ {:ok, parsed} =
+ parse("?match_day_of_week=foo", build(:site), %{"match_day_of_week" => "false"})
+
+ expected_include = Map.put(@default_include, :compare_match_day_of_week, false)
+ assert %ParsedQueryParams{include: ^expected_include} = parsed
+ end
+
+ test "falls back to 'true' when invalid values in both query string and user prefs" do
+ {:ok, parsed} =
+ parse("?match_day_of_week=foo", build(:site), %{"match_day_of_week" => "bar"})
+
+ assert %ParsedQueryParams{include: @default_include} = parsed
+ end
end
describe "filters" do
test "parses valid filters" do
{:ok, parsed} =
- parse("?f=is,exit_page,/:dashboard&f=is,source,Bing&f=is,props:theme,system")
+ parse(
+ "?f=is,exit_page,/:dashboard&f=is,source,Bing&f=is,props:theme,system",
+ build(:site),
+ %{}
+ )
assert %ParsedQueryParams{
filters: [
@@ -164,7 +284,7 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
test "parses city filter with multiple clauses" do
{:ok, parsed} =
- parse("?f=is,city,2988507,2950159")
+ parse("?f=is,city,2988507,2950159", build(:site), %{})
assert %ParsedQueryParams{
filters: [[:is, "visit:city", [2_988_507, 2_950_159]]],
@@ -173,7 +293,7 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
end
test "parses a segment filter" do
- {:ok, parsed} = parse("?f=is,segment,123")
+ {:ok, parsed} = parse("?f=is,segment,123", build(:site), %{})
assert %ParsedQueryParams{
filters: [[:is, "segment", [123]]],
@@ -182,15 +302,15 @@ defmodule Plausible.Stats.DashboardQueryParserTest do
end
test "errors when filter structure is wrong" do
- assert {:error, :invalid_filters} = parse("?f=is,page,/&f=what")
+ assert {:error, :invalid_filters} = parse("?f=is,page,/&f=what", build(:site), %{})
end
test "errors when city filter cannot be parsed to integer" do
- assert {:error, :invalid_filters} = parse("?f=is,city,Berlin")
+ assert {:error, :invalid_filters} = parse("?f=is,city,Berlin", build(:site), %{})
end
test "errors when segment filter cannot be parsed to integer" do
- assert {:error, :invalid_filters} = parse("?f=is,segment,MySegment")
+ assert {:error, :invalid_filters} = parse("?f=is,segment,MySegment", build(:site), %{})
end
end
end
diff --git a/test/plausible/stats/query/dashboard_query_serializer_test.exs b/test/plausible/stats/query/dashboard_query_serializer_test.exs
index 727ac00fdc..ca925c94b6 100644
--- a/test/plausible/stats/query/dashboard_query_serializer_test.exs
+++ b/test/plausible/stats/query/dashboard_query_serializer_test.exs
@@ -6,25 +6,25 @@ defmodule Plausible.Stats.DashboardQuerySerializerTest do
@default_include default_include()
describe "parse -> serialize is a reversible transformation" do
- for query_string <- ["", "date=2021-07-07&f=is,browser,Chrome,Firefox&period=day"] do
+ for query_string <- ["period=month", "date=2021-07-07&f=is,browser,Chrome,Firefox&period=day"] do
test "with query string being '#{query_string}'" do
- {:ok, parsed} = parse(unquote(query_string))
+ {:ok, parsed} = parse(unquote(query_string), build(:site), %{})
assert serialize(parsed) == unquote(query_string)
end
end
test "but alphabetical ordering by key is enforced" do
- {:ok, parsed} = parse("period=day&date=2021-07-07")
+ {:ok, parsed} = parse("period=day&date=2021-07-07", build(:site), %{})
assert serialize(parsed) == "date=2021-07-07&period=day"
end
test "but redundant values get removed" do
- {:ok, parsed} = parse("with_imported=true")
- assert serialize(parsed) == ""
+ {:ok, parsed} = parse("period=all&with_imported=true", build(:site), %{})
+ assert serialize(parsed) == "period=all"
end
test "but leading ? gets removed" do
- {:ok, parsed} = parse("?period=day")
+ {:ok, parsed} = parse("?period=day", build(:site), %{})
assert serialize(parsed) == "period=day"
end
end
diff --git a/test/plausible/stats/query/query_test.exs b/test/plausible/stats/query/query_test.exs
index 85fb3c6ba5..7afa30451e 100644
--- a/test/plausible/stats/query/query_test.exs
+++ b/test/plausible/stats/query/query_test.exs
@@ -126,4 +126,114 @@ defmodule Plausible.Stats.QueryTest do
]
end
end
+
+ describe "include.dashboard_metric_labels" do
+ test "visitors -> Visitors (default)", %{site: site} do
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :all,
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Visitors"] = meta[:metric_labels]
+ end
+
+ test "visitors -> Current visitors (realtime)", %{site: site} do
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :realtime,
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Current visitors"] = meta[:metric_labels]
+ end
+
+ test "visitors -> Current visitors (realtime and goal filtered)", %{site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :realtime,
+ filters: [[:is, "event:goal", ["Signup"]]],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Current visitors"] = meta[:metric_labels]
+ end
+
+ test "visitors -> Conversions (goal filtered)", %{site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :all,
+ filters: [[:is, "event:goal", ["Signup"]]],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Conversions"] = meta[:metric_labels]
+ end
+
+ test "visitors -> Unique entrances (visit:entry_page dimension)", %{site: site} do
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :all,
+ dimensions: ["visit:entry_page"],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Unique entrances"] = meta[:metric_labels]
+ end
+
+ test "visitors -> Unique exits (visit:exit_page dimension)", %{site: site} do
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:visitors],
+ input_date_range: :all,
+ dimensions: ["visit:exit_page"],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["Unique exits"] = meta[:metric_labels]
+ end
+
+ test "conversion_rate -> CR (default)", %{site: site} do
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:conversion_rate],
+ input_date_range: :all,
+ dimensions: ["event:goal"],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["CR"] = meta[:metric_labels]
+ end
+
+ test "maintains order with multiple metrics", %{site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ {:ok, query} =
+ QueryBuilder.build(site,
+ metrics: [:conversion_rate, :visitors],
+ input_date_range: :all,
+ filters: [[:is, "event:goal", ["Signup"]]],
+ include: [dashboard_metric_labels: true]
+ )
+
+ %Stats.QueryResult{meta: meta} = Stats.query(site, query)
+ assert ["CR", "Conversions"] = meta[:metric_labels]
+ end
+ end
end
diff --git a/test/plausible_web/live/components/dashboard/report_list_test.exs b/test/plausible_web/live/components/dashboard/report_list_test.exs
new file mode 100644
index 0000000000..e3c06c9c04
--- /dev/null
+++ b/test/plausible_web/live/components/dashboard/report_list_test.exs
@@ -0,0 +1,65 @@
+defmodule PlausibleWeb.Components.Dashboard.ReportListTest do
+ use PlausibleWeb.ConnCase, async: true
+ import Phoenix.LiveViewTest, only: [render_component: 2]
+
+ alias PlausibleWeb.Components.Dashboard.ReportList
+ alias Plausible.Stats.{ParsedQueryParams, QueryResult}
+ alias Phoenix.LiveView.AsyncResult
+ import Plausible.DashboardTestUtils
+
+ @report_list_selector ~s|[data-test-id="pages-report-list"]|
+ @bar_indicator_selector ~s|[data-test-id="bar-indicator"]|
+
+ setup do
+ assigns = [
+ site: build(:site),
+ data_test_id: "pages-report-list",
+ key_label: "Page",
+ dimension: "event:page",
+ params: %ParsedQueryParams{},
+ external_link_fn: fn _ -> "" end
+ ]
+
+ {:ok, %{assigns: assigns}}
+ end
+
+ test "renders empty when loading", %{assigns: assigns} do
+ assigns = Keyword.put(assigns, :query_result, AsyncResult.loading())
+ assert render_component(&ReportList.report/1, assigns) == ""
+ end
+
+ test "renders empty when result not ok", %{assigns: assigns} do
+ assigns =
+ Keyword.put(assigns, :query_result, AsyncResult.failed(AsyncResult.loading(), :some_error))
+
+ assert render_component(&ReportList.report/1, assigns) == ""
+ end
+
+ test "item bar width depends on visitors metric", %{assigns: assigns} do
+ successful_async_result =
+ AsyncResult.ok(%QueryResult{
+ results: [
+ %{metrics: [100, 60.0], dimensions: ["/a"]},
+ %{metrics: [70, 40.0], dimensions: ["/b"]},
+ %{metrics: [30, 20.0], dimensions: ["/c"]}
+ ],
+ meta: Jason.OrderedObject.new(metric_labels: ["Conversions", "CR"]),
+ query: Jason.OrderedObject.new(metrics: [:visitors, :conversion_rate])
+ })
+
+ assigns = Keyword.put(assigns, :query_result, successful_async_result)
+
+ html = render_component(&ReportList.report/1, assigns)
+
+ report_list = find(html, @report_list_selector)
+
+ [{1, "100.0%"}, {2, "70.0%"}, {3, "30.0%"}]
+ |> Enum.each(fn {item, expected_width} ->
+ bar =
+ get_in_report_list(report_list, item, 0, text?: false)
+ |> find(@bar_indicator_selector)
+
+ assert text_of_attr(bar, "style") =~ "width: #{expected_width}"
+ end)
+ end
+end
diff --git a/test/plausible_web/live/dashboard_test.exs b/test/plausible_web/live/dashboard/dashboard_test.exs
similarity index 100%
rename from test/plausible_web/live/dashboard_test.exs
rename to test/plausible_web/live/dashboard/dashboard_test.exs
diff --git a/test/plausible_web/live/dashboard/pages_test.exs b/test/plausible_web/live/dashboard/pages_test.exs
new file mode 100644
index 0000000000..3a69f783e2
--- /dev/null
+++ b/test/plausible_web/live/dashboard/pages_test.exs
@@ -0,0 +1,228 @@
+defmodule PlausibleWeb.Live.Dashboard.PagesTest do
+ use PlausibleWeb.ConnCase, async: false
+
+ import Phoenix.LiveViewTest
+ import Plausible.DashboardTestUtils
+
+ setup [:create_user, :log_in, :create_site]
+
+ @top_pages_report_list ~s|[data-test-id="pages-report-list"]|
+ @entry_pages_report_list ~s|[data-test-id="entry-pages-report-list"]|
+ @exit_pages_report_list ~s|[data-test-id="exit-pages-report-list"]|
+
+ describe "Top Pages" do
+ test "eventually renders and orders items by visitor counts", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three")
+ ])
+
+ assert report_list = get_liveview(conn, site) |> get_report_list(@top_pages_report_list)
+
+ assert report_list_as_table(report_list, 4, 2) == [
+ ["Page", "Visitors"],
+ ["/three", "3"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders current visitors", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=realtime")
+ |> get_report_list(@top_pages_report_list)
+
+ assert report_list_as_table(report_list, 3, 2) == [
+ ["Page", "Current visitors"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders conversions with conversion rate", %{conn: conn, site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:event, name: "Signup", pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=day&f=is,goal,Signup")
+ |> get_report_list(@top_pages_report_list)
+
+ assert report_list_as_table(report_list, 2, 3) == [
+ ["Page", "Conversions", "CR"],
+ ["/two", "1", "33.33%"]
+ ]
+
+ refute get_in_report_list(report_list, 2, 0)
+ end
+ end
+
+ describe "Entry Pages" do
+ test "eventually renders and orders items by visitor counts", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site)
+ |> change_tab("entry-pages")
+ |> get_report_list(@entry_pages_report_list)
+
+ assert report_list_as_table(report_list, 4, 2) == [
+ ["Entry page", "Unique entrances"],
+ ["/three", "3"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders current visitors", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=realtime")
+ |> change_tab("entry-pages")
+ |> get_report_list(@entry_pages_report_list)
+
+ assert report_list_as_table(report_list, 3, 2) == [
+ ["Entry page", "Current visitors"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders conversions with conversion rate", %{conn: conn, site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, user_id: 1, pathname: "/two"),
+ build(:event, user_id: 1, name: "Signup", pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=day&f=is,goal,Signup")
+ |> change_tab("entry-pages")
+ |> get_report_list(@entry_pages_report_list)
+
+ assert report_list_as_table(report_list, 2, 3) == [
+ ["Entry page", "Conversions", "CR"],
+ ["/two", "1", "33.33%"]
+ ]
+
+ refute get_in_report_list(report_list, 2, 0)
+ end
+ end
+
+ describe "Exit Pages" do
+ test "eventually renders and orders items by visitor counts", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three"),
+ build(:pageview, pathname: "/three")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site)
+ |> change_tab("exit-pages")
+ |> get_report_list(@exit_pages_report_list)
+
+ assert report_list_as_table(report_list, 4, 2) == [
+ ["Exit page", "Unique exits"],
+ ["/three", "3"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders current visitors", %{conn: conn, site: site} do
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:pageview, pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=realtime")
+ |> change_tab("exit-pages")
+ |> get_report_list(@exit_pages_report_list)
+
+ assert report_list_as_table(report_list, 3, 2) == [
+ ["Exit page", "Current visitors"],
+ ["/two", "2"],
+ ["/one", "1"]
+ ]
+ end
+
+ test "renders conversions with conversion rate", %{conn: conn, site: site} do
+ insert(:goal, site: site, event_name: "Signup")
+
+ populate_stats(site, [
+ build(:pageview, pathname: "/one"),
+ build(:event, user_id: 1, name: "Signup", pathname: "/two"),
+ build(:pageview, user_id: 1, pathname: "/two"),
+ build(:pageview, pathname: "/two")
+ ])
+
+ assert report_list =
+ get_liveview(conn, site, "period=day&f=is,goal,Signup")
+ |> change_tab("exit-pages")
+ |> get_report_list(@exit_pages_report_list)
+
+ assert report_list_as_table(report_list, 2, 3) == [
+ ["Exit page", "Conversions", "CR"],
+ ["/two", "1", "33.33%"]
+ ]
+
+ refute get_in_report_list(report_list, 2, 0)
+ end
+ end
+
+ defp get_report_list(lv, selector) do
+ eventually(fn ->
+ html = render(lv)
+ {element_exists?(html, selector), find(html, selector)}
+ end)
+ end
+
+ defp get_liveview(conn, site, search_params \\ "period=day") do
+ conn = assign(conn, :live_module, PlausibleWeb.Live.Dashboard)
+ {:ok, lv, _html} = live(conn, "/#{site.domain}?#{search_params}")
+ lv
+ end
+
+ defp change_tab(lv, tab) do
+ lv
+ |> element("#breakdown-tile-pages-tabs")
+ |> render_hook("set-tab", %{"tab" => tab})
+
+ lv
+ end
+end
diff --git a/test/support/dashboard_test_utils.ex b/test/support/dashboard_test_utils.ex
new file mode 100644
index 0000000000..e1f83a1060
--- /dev/null
+++ b/test/support/dashboard_test_utils.ex
@@ -0,0 +1,33 @@
+defmodule Plausible.DashboardTestUtils do
+ @moduledoc false
+
+ import Plausible.Test.Support.HTML
+
+ @doc """
+ Takes a LazyHTML rendered ReportList component argument with the number of
+ rows and columns it's supposed to have, and returns a table-like, 2D list
+ with all its data (including headers as the first row).
+ """
+ def report_list_as_table(%LazyHTML{} = report_list, rows, columns) do
+ for row_index <- 0..(rows - 1) do
+ for column_index <- 0..(columns - 1) do
+ get_in_report_list(report_list, row_index, column_index)
+ end
+ end
+ end
+
+ def get_in_report_list(%LazyHTML{} = report_list, row_index, column_index, opts \\ []) do
+ selector = ~s|[data-test-id="report-list-#{row_index}-#{column_index}"]|
+
+ cond do
+ not element_exists?(report_list, selector) ->
+ nil
+
+ Keyword.get(opts, :text?, true) ->
+ text_of_element(report_list, selector)
+
+ true ->
+ find(report_list, selector)
+ end
+ end
+end
diff --git a/test/support/html.ex b/test/support/html.ex
index 792d173f3a..50b2db81bc 100644
--- a/test/support/html.ex
+++ b/test/support/html.ex
@@ -10,10 +10,15 @@ defmodule Plausible.Test.Support.HTML do
|> Kernel.not()
end
+ def find(%LazyHTML{} = html, selector) do
+ html
+ |> LazyHTML.query(selector)
+ end
+
def find(html, selector) do
html
|> lazy_parse()
- |> LazyHTML.query(selector)
+ |> find(selector)
end
def submit_button(html, form) do