Compare commits

...

3 Commits

Author SHA1 Message Date
Adam Rutkowski 7f86f6345b WIP: Goal exclusion 3 years ago
Adam Rutkowski 48accb7774 Disallow goal creation starting with `!` 3 years ago
Adam Rutkowski 5bcd7fe814 Allow `is not` filter for goals + lint 3 years ago

@ -27,7 +27,7 @@ export const OPERATION_PREFIX = {
};
export function supportsIsNot(filterName) {
return !['goal', 'prop_key'].includes(filterName)
return !['prop_key'].includes(filterName)
}
export function isFreeChoiceFilter(filterName) {
@ -39,7 +39,7 @@ export function isFreeChoiceFilter(filterName) {
let NON_ESCAPED_PIPE_REGEX;
try {
NON_ESCAPED_PIPE_REGEX = new RegExp("(?<!\\\\)\\|", "g")
} catch(_e) {
} catch (_e) {
NON_ESCAPED_PIPE_REGEX = '|'
}
@ -66,19 +66,19 @@ export function parsePrefix(rawValue) {
.filter((clause) => !!clause)
.map((val) => val.replaceAll(ESCAPED_PIPE, '|'))
return {type, values}
return { type, values }
}
export function parseQueryPropsFilter(query) {
return Object.entries(query.filters['props']).map(([key, propVal]) => {
const {type, values} = parsePrefix(propVal)
const clauses = values.map(val => { return {value: val, label: val}})
const { type, values } = parsePrefix(propVal)
const clauses = values.map(val => { return { value: val, label: val } })
return { propKey: { label: key, value: key }, type, clauses }
})
}
export function parseQueryFilter(query, filter) {
const {type, values} = parsePrefix(query.filters[filter] || '')
const { type, values } = parsePrefix(query.filters[filter] || '')
let labels = values
@ -97,9 +97,9 @@ export function parseQueryFilter(query, filter) {
labels = rawLabel.split('|').filter(label => !!label)
}
const clauses = values.map((value, index) => { return {value, label: labels[index]}})
const clauses = values.map((value, index) => { return { value, label: labels[index] } })
return {type, clauses}
return { type, clauses }
}
export function formatFilterGroup(filterGroup) {

@ -57,23 +57,29 @@ defmodule Plausible.Goal do
end
defp validate_event_name_and_page_path(changeset) do
if validate_page_path(changeset) || validate_event_name(changeset) do
changeset
else
changeset
|> add_error(:event_name, "this field is required and cannot be blank")
|> add_error(:page_path, "this field is required and must start with a /")
end
end
page_path = get_field(changeset, :page_path)
event_name = get_field(changeset, :event_name)
defp validate_page_path(changeset) do
value = get_field(changeset, :page_path)
value && String.match?(value, ~r/^\/.*/)
end
cond do
page_path && String.match?(page_path, ~r/^\/.*/) ->
changeset
defp validate_event_name(changeset) do
value = get_field(changeset, :event_name)
value && String.match?(value, ~r/^.+/)
event_name && String.match?(event_name, ~r/^[^!].+/) ->
changeset
page_path ->
changeset
|> add_error(:page_path, "this field is required and must start with a /")
event_name ->
changeset
|> add_error(:event_name, "this field is required and must not start with a !")
true ->
changeset
|> add_error(:event_name, "this field is required and cannot be blank")
|> add_error(:page_path, "this field is required and cannot be blank")
end
end
defp maybe_drop_currency(changeset) do

@ -7,6 +7,8 @@ defmodule Plausible.Stats.Base do
alias Plausible.Timezones
import Ecto.Query
require Logger
@no_ref "Direct / None"
@not_set "(not set)"
@ -65,6 +67,9 @@ defmodule Plausible.Stats.Base do
{:is, {:page, path}} ->
from(e in q, where: e.pathname == ^path and e.name == "pageview")
{:is_not, {:page, path}} ->
from(e in q, where: e.pathname != ^path)
{:matches, {:page, expr}} ->
regex = page_regex(expr)
@ -72,9 +77,19 @@ defmodule Plausible.Stats.Base do
where: fragment("match(?, ?)", e.pathname, ^regex) and e.name == "pageview"
)
{:does_not_match, {:page, expr}} ->
regex = page_regex(expr)
from(e in q,
where: fragment("not(match(?, ?))", e.pathname, ^regex)
)
{:is, {:event, event}} ->
from(e in q, where: e.name == ^event)
{:is_not, {:event, event}} ->
from(e in q, where: e.name != ^event)
{:member, clauses} ->
{events, pages} = split_goals(clauses)
@ -82,6 +97,13 @@ defmodule Plausible.Stats.Base do
where: (e.pathname in ^pages and e.name == "pageview") or e.name in ^events
)
{:not_member, clauses} ->
{events, pages} = split_goals(clauses)
from(e in q,
where: e.pathname not in ^pages and e.name not in ^events
)
{:matches_member, clauses} ->
{events, pages} = split_goals(clauses, &page_regex/1)
@ -106,8 +128,42 @@ defmodule Plausible.Stats.Base do
from(e in q, where: ^where_clause)
{:not_matches_member, clauses} ->
{events, pages} = split_goals(clauses, &page_regex/1)
event_clause =
if Enum.any?(events) do
dynamic(
[x],
fragment("not(multiMatchAny(?, ?))", x.name, ^events)
)
else
dynamic([x], false)
end
page_clause =
if Enum.any?(pages) do
dynamic(
[x],
fragment("not(multiMatchAny(?, ?))", x.pathname, ^pages)
)
else
dynamic([x], false)
end
where_clause = dynamic([], ^event_clause and ^page_clause)
from(e in q, where: ^where_clause)
nil ->
q
clause ->
Logger.error(
"Unsupported goal filter clause: #{inspect(clause)}. Falling back to unfiltered query."
)
q
end
q =

@ -18,7 +18,8 @@ defmodule Plausible.Stats.Filters.StatsAPIFilterParser do
defp parse_single_filter(str) do
case to_kv(str) do
["event:goal" = key, raw_value] ->
{key, parse_goal_filter(raw_value)}
is_negated? = String.contains?(str, "!=")
{key, parse_goal_filter(raw_value, is_negated?)}
[key, raw_value] ->
is_negated? = String.contains?(str, "!=")
@ -59,7 +60,7 @@ defmodule Plausible.Stats.Filters.StatsAPIFilterParser do
|> Enum.map(&String.trim/1)
end
defp parse_goal_filter(value) do
defp parse_goal_filter(value, is_negated?) do
is_list? = list_expression?(value)
is_wildcard? = wildcard_expression?(value)
@ -72,6 +73,8 @@ defmodule Plausible.Stats.Filters.StatsAPIFilterParser do
|> wrap_goal_value()
cond do
is_negated? && is_list? -> {:not_member, value}
is_negated? -> {:is_not, value}
is_list? && is_wildcard? -> {:matches_member, value}
is_list? -> {:member, value}
is_wildcard? -> {:matches, value}

@ -48,6 +48,14 @@ defmodule Plausible.GoalsTest do
assert {"has already been taken", _} = changeset.errors[:event_name]
end
test "create/2 fails to create goal name starting with !" do
site = insert(:site)
{:error, changeset} = Goals.create(site, %{"event_name" => "!foo bar"})
assert {"this field is required and must not start with a !", _} =
changeset.errors[:event_name]
end
@tag :full_build_only
test "create/2 sets site.updated_at for revenue goal" do
site_1 = insert(:site, updated_at: DateTime.add(DateTime.utc_now(), -3600))

@ -11,9 +11,15 @@ defmodule Plausible.Stats.DashboardFilterParserTest do
%{"page" => "/"}
|> assert_parsed(%{"event:page" => {:is, "/"}})
%{"page" => "!/"}
|> assert_parsed(%{"event:page" => {:is_not, "/"}})
%{"goal" => "Signup"}
|> assert_parsed(%{"event:goal" => {:is, {:event, "Signup"}}})
%{"goal" => "!Signup"}
|> assert_parsed(%{"event:goal" => {:is_not, {:event, "Signup"}}})
%{"goal" => "Visit /blog"}
|> assert_parsed(%{"event:goal" => {:is, {:page, "/blog"}}})
@ -109,6 +115,11 @@ defmodule Plausible.Stats.DashboardFilterParserTest do
%{"goal" => "Visit /thank-you|Signup"}
|> assert_parsed(%{"event:goal" => {:member, [{:page, "/thank-you"}, {:event, "Signup"}]}})
%{"goal" => "!Visit /thank-you|Signup"}
|> assert_parsed(%{
"event:goal" => {:not_member, [{:page, "/thank-you"}, {:event, "Signup"}]}
})
end
end

@ -40,6 +40,14 @@ defmodule Plausible.Stats.FiltersTest do
|> assert_parsed(%{"event:goal" => {:is, {:event, "Signup"}}})
end
test "negative goals" do
"event:goal!=Signup"
|> assert_parsed(%{"event:goal" => {:is_not, {:event, "Signup"}}})
"event:goal!=Signup|Visit /blog"
|> assert_parsed(%{"event:goal" => {:not_member, [event: "Signup", page: "/blog"]}})
end
test "pageview goal" do
"event:goal==Visit /blog"
|> assert_parsed(%{"event:goal" => {:is, {:page, "/blog"}}})

@ -472,6 +472,129 @@ defmodule PlausibleWeb.Api.StatsController.ConversionsTest do
assert get_with_filter.(%{goal: "Visit+/register|Visit+/regi**"}) == expected
end
test "goal filter negations", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:pageview, pathname: "/"),
build(:pageview, pathname: "/register"),
build(:pageview, pathname: "/logout"),
build(:event, pathname: "/register", name: "Signup")
])
insert(:goal, %{site: site, page_path: "/register"})
insert(:goal, %{site: site, page_path: "/logout"})
insert(:goal, %{site: site, page_path: "/regi*"})
insert(:goal, %{site: site, event_name: "Signup"})
get_with_filter = fn filters ->
path = "/api/stats/#{site.domain}/conversions"
query = "?period=day&filters=#{Jason.encode!(filters)}"
get(conn, path <> query)
|> json_response(200)
end
# {:is_not, {:page, path}} filter type
assert get_with_filter.(%{goal: "!Visit /logout"}) == [
%{"conversion_rate" => 25.0, "events" => 1, "name" => "Signup", "visitors" => 1},
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /register",
"visitors" => 1
},
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /regi*",
"visitors" => 1
}
]
# {:is_not, {:event, event}} filter type
assert get_with_filter.(%{goal: "!Signup"}) == [
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /register",
"visitors" => 1
},
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /logout",
"visitors" => 1
},
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /regi*",
"visitors" => 1
}
]
# {:does_not_match, {:page, expr}} filter type
assert get_with_filter.(%{goal: "!Visit /regi*"}) == [
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /logout",
"visitors" => 1
}
]
# {:not_matches_member, clauses} filter type
assert get_with_filter.(%{goal: "!Visit /logout|Signup"}) ==
[
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /register",
"visitors" => 1
},
%{
"conversion_rate" => 25.0,
"events" => 1,
"name" => "Visit /regi*",
"visitors" => 1
}
]
end
test "goal exclusion with single custom event on two different paths", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event, pathname: "/register", name: "Signup"),
build(:event, pathname: "/promo/123/signup", name: "Signup")
])
insert(:goal, %{site: site, page_path: "/regi*"})
insert(:goal, %{site: site, page_path: "/arbitrary"})
insert(:goal, %{site: site, event_name: "Signup"})
get_with_filter = fn filters ->
path = "/api/stats/#{site.domain}/conversions"
query = "?period=day&filters=#{Jason.encode!(filters)}"
get(conn, path <> query)
|> json_response(200)
end
assert get_with_filter.(%{goal: "!Visit /arbitrary"}) == [
%{"conversion_rate" => 100.0, "events" => 2, "name" => "Signup", "visitors" => 2}
]
assert get_with_filter.(%{goal: "!Visit /regi*"}) == [
%{"conversion_rate" => 50.0, "events" => 1, "name" => "Signup", "visitors" => 1}
]
assert get_with_filter.(%{goal: "!Signup"}) == []
end
test "can filter by multiple mixed goals", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, pathname: "/"),

@ -71,7 +71,7 @@ defmodule PlausibleWeb.Live.GoalSettings.FormTest do
assert html =~ "this field is required and cannot be blank"
pageview_tab = lv |> element(~s/a#pageview-tab/) |> render_click()
assert pageview_tab =~ "this field is required and must start with a /"
assert pageview_tab =~ "this field is required and cannot be blank"
end
test "creates a custom event", %{conn: conn, site: site} do

Loading…
Cancel
Save