revenue-tracking-wip
Vinicius Brasil 4 years ago
parent d57240d3d7
commit a2b630150f

@ -10,13 +10,12 @@ function barWidth(count, all, plot) {
return count / maxVal * 100
}
export default function Bar({count, all, bg, maxWidthDeduction, children, plot = "visitors"}) {
export default function Bar({count, all, bg, children, plot = "visitors"}) {
const width = barWidth(count, all, plot)
return (
<div
className="w-full relative"
style={{maxWidth: `calc(100% - ${maxWidthDeduction})`}}
className="flex-grow relative"
>
<div
className={`absolute top-0 left-0 h-full ${bg || ''}`}

@ -56,17 +56,12 @@ export default class Conversions extends React.Component {
}
}
getBarMaxWidth() {
const { viewport } = this.state;
return viewport > MOBILE_UPPER_WIDTH ? "16rem" : "10rem";
}
fetchConversions() {
api.get(`/api/stats/${encodeURIComponent(this.props.site.domain)}/conversions`, this.props.query)
.then((res) => this.setState({loading: false, goals: res, prevHeight: null}))
}
renderGoal(goal) {
renderGoal(goal, renderRevenueColumn) {
const { viewport } = this.state;
const renderProps = this.props.query.filters['goal'] == goal.name && goal.prop_names
@ -77,7 +72,6 @@ export default class Conversions extends React.Component {
count={goal.unique_conversions}
all={this.state.goals}
bg="bg-red-50 dark:bg-gray-500 dark:bg-opacity-15"
maxWidthDeduction={this.getBarMaxWidth()}
plot="unique_conversions"
>
<Link to={url.setQuery('goal', escapeFilterValue(goal.name))} className="block px-2 py-1.5 hover:underline relative z-9 break-all lg:truncate dark:text-gray-200">{goal.name}</Link>
@ -86,18 +80,33 @@ export default class Conversions extends React.Component {
<span className="inline-block w-20 font-medium text-right">{numberFormatter(goal.unique_conversions)}</span>
{viewport > MOBILE_UPPER_WIDTH && <span className="inline-block w-20 font-medium text-right">{numberFormatter(goal.total_conversions)}</span>}
<span className="inline-block w-20 font-medium text-right">{goal.conversion_rate}%</span>
{viewport > MOBILE_UPPER_WIDTH && renderRevenueColumn && <span className="inline-block w-20 font-medium text-right">{this.renderMoney(goal.average_revenue)}</span>}
{viewport > MOBILE_UPPER_WIDTH && renderRevenueColumn && <span className="inline-block w-20 font-medium text-right">{this.renderMoney(goal.total_revenue)}</span>}
</div>
</div>
{ renderProps && <PropBreakdown site={this.props.site} query={this.props.query} goal={goal} /> }
{ renderProps && !goal.total_revenue && <PropBreakdown site={this.props.site} query={this.props.query} goal={goal} /> }
</div>
)
}
renderMoney(moneyObject) {
if (moneyObject) {
return (
<span tooltip={moneyObject.long}>{moneyObject.short}</span>
)
} else {
return '-'
}
}
renderInner() {
const { viewport } = this.state;
if (this.state.loading) {
return <div className="mx-auto my-2 loading"><div></div></div>
} else if (this.state.goals) {
const hasRevenue = this.state.goals.some((goal) => goal.total_revenue)
return (
<React.Fragment>
<h3 className="font-bold dark:text-gray-100">{this.props.title || "Goal Conversions"}</h3>
@ -107,10 +116,12 @@ export default class Conversions extends React.Component {
<span className="inline-block w-20">Uniques</span>
{viewport > MOBILE_UPPER_WIDTH && <span className="inline-block w-20">Total</span>}
<span className="inline-block w-20">CR</span>
{viewport > MOBILE_UPPER_WIDTH && hasRevenue && <span className="inline-block w-20">Average</span>}
{viewport > MOBILE_UPPER_WIDTH && hasRevenue && <span className="inline-block w-20">Total</span>}
</div>
</div>
<FlipMove>
{ this.state.goals.map(this.renderGoal.bind(this)) }
{ this.state.goals.map((goal) => this.renderGoal.bind(this)(goal, hasRevenue) ) }
</FlipMove>
</React.Fragment>
)

@ -17,3 +17,5 @@ GOOGLE_CLIENT_SECRET=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
PROMEX_DISABLED=false
SITE_DEFAULT_INGEST_THRESHOLD=1000000
OPEN_EXCHANGE_RATES_APP_ID=31b49b5eca3845e0bee848b84a93b848

@ -25,7 +25,9 @@ defmodule Mix.Tasks.SendPageview do
referrer: :string,
host: :string,
event: :string,
props: :string
props: :string,
revenue_currency: :string,
revenue_amount: :string
]
def run(opts) do
@ -85,12 +87,21 @@ defmodule Mix.Tasks.SendPageview do
event = Keyword.get(opts, :event, @default_event)
props = Keyword.get(opts, :props, @default_props)
revenue =
if Keyword.get(opts, :revenue_currency) do
%{
currency: Keyword.get(opts, :revenue_currency),
amount: Keyword.get(opts, :revenue_amount)
}
end
%{
name: event,
url: "http://#{domain}#{page}",
domain: domain,
referrer: referrer,
props: props
props: props,
revenue: revenue
}
end

@ -36,6 +36,12 @@ defmodule Plausible.ClickhouseEventV2 do
field :"meta.key", {:array, :string}
field :"meta.value", {:array, :string}
field :revenue_source_amount, Ch.Types.Decimal64, scale: 4
field :revenue_source_currency, Ch.Types.FixedString, size: 3
field :revenue_reporting_amount, Ch.Types.Decimal64, scale: 4
field :revenue_reporting_currency, Ch.Types.FixedString, size: 3
field :transferred_from, :string
end
@ -67,7 +73,11 @@ defmodule Plausible.ClickhouseEventV2 do
:city_geoname_id,
:screen_size,
:"meta.key",
:"meta.value"
:"meta.value",
:revenue_source_amount,
:revenue_source_currency,
:revenue_reporting_amount,
:revenue_reporting_currency
],
empty_values: [nil, ""]
)

@ -98,6 +98,7 @@ defmodule Plausible.Ingestion.Event do
&put_utm_tags/1,
&put_geolocation/1,
&put_props/1,
&put_revenue/1,
&put_salts/1,
&put_user_id/1,
&validate_clickhouse_event/1,
@ -206,6 +207,29 @@ defmodule Plausible.Ingestion.Event do
defp put_props(%__MODULE__{} = event), do: event
defp put_revenue(%__MODULE__{request: %{revenue_source: %Money{} = revenue_source}} = event) do
matching_goal =
event.domain
|> Plausible.Site.Cache.get()
|> Map.get(:revenue_goals)
|> Kernel.||([])
|> Enum.find(&(&1.event_name == event.clickhouse_event_attrs.name))
with %Plausible.Goal{currency: currency} <- matching_goal,
{:ok, %Money{} = revenue_reporting} <- Money.to_currency(revenue_source, currency) do
update_attrs(event, %{
revenue_source_amount: revenue_source.amount,
revenue_source_currency: to_string(revenue_source.currency),
revenue_reporting_amount: revenue_reporting.amount,
revenue_reporting_currency: to_string(revenue_reporting.currency)
})
else
_ -> event
end
end
defp put_revenue(event), do: event
defp put_salts(%__MODULE__{} = event) do
%{event | salts: Plausible.Session.Salts.fetch()}
end

@ -21,6 +21,7 @@ defmodule Plausible.Ingestion.Request do
field :hash_mode, :string
field :pathname, :string
field :props, :map
field :revenue_source, :map
field :query_params, :map
field :timestamp, :naive_datetime
@ -53,6 +54,7 @@ defmodule Plausible.Ingestion.Request do
|> put_props(request_body)
|> put_pathname()
|> put_query_params()
|> put_revenue_source(request_body)
|> map_domains(request_body)
|> Changeset.validate_required([
:event_name,
@ -166,7 +168,7 @@ defmodule Plausible.Ingestion.Request do
defp put_props(changeset, %{} = request_body) do
props =
(request_body["m"] || request_body["meta"] || request_body["p"] || request_body["props"])
|> decode_props_or_fallback()
|> decode_json_or_fallback()
|> Enum.reject(fn {_k, v} -> is_nil(v) || is_list(v) || is_map(v) || v == "" end)
|> Map.new()
@ -175,18 +177,6 @@ defmodule Plausible.Ingestion.Request do
|> validate_props()
end
defp decode_props_or_fallback(raw) do
with raw when is_binary(raw) <- raw,
{:ok, %{} = decoded} <- Jason.decode(raw) do
decoded
else
already_a_map when is_map(already_a_map) -> already_a_map
{:ok, _list_or_other} -> %{}
{:error, _decode_error} -> %{}
_any -> %{}
end
end
@max_prop_key_length 300
@max_prop_value_length 2000
defp validate_props(changeset) do
@ -209,6 +199,52 @@ defmodule Plausible.Ingestion.Request do
end
end
defp put_revenue_source(%Ecto.Changeset{} = changeset, %{} = request_body) do
with revenue_source <- request_body["revenue"] || request_body["$"],
%{"amount" => _, "currency" => _} = revenue_source <-
decode_json_or_fallback(revenue_source) do
parse_revenue_source(changeset, revenue_source)
else
_any -> changeset
end
end
@valid_currencies Plausible.Goal.valid_currencies()
defp parse_revenue_source(changeset, %{"amount" => amount, "currency" => currency}) do
with true <- currency in @valid_currencies,
{%Decimal{} = amount, _rest} <- parse_decimal(amount),
%Money{} = amount <- Money.new(currency, amount) do
Changeset.put_change(changeset, :revenue_source, amount)
else
false ->
Changeset.add_error(changeset, :revenue_source, "currency is not supported or invalid")
_parse_error ->
Changeset.add_error(changeset, :revenue_source, "must be a valid number")
end
end
defp decode_json_or_fallback(raw) do
with raw when is_binary(raw) <- raw,
{:ok, %{} = decoded} <- Jason.decode(raw) do
decoded
else
already_a_map when is_map(already_a_map) -> already_a_map
{:ok, _list_or_other} -> %{}
{:error, _decode_error} -> %{}
_any -> %{}
end
end
defp parse_decimal(value) do
case value do
value when is_binary(value) -> Decimal.parse(value)
value when is_float(value) -> {Decimal.from_float(value), nil}
value when is_integer(value) -> {Decimal.new(value), nil}
_any -> :error
end
end
defp put_query_params(changeset) do
case Changeset.get_field(changeset, :uri) do
%{query: query} when is_binary(query) ->

@ -277,6 +277,31 @@ defmodule Plausible.Stats.Base do
|> select_event_metrics(rest)
end
def select_event_metrics(q, [:total_revenue | rest]) do
from(e in q,
select_merge: %{
total_revenue: fragment("sum(?) * any(_sample_factor)", e.revenue_reporting_amount)
}
)
|> select_event_metrics(rest)
end
def select_event_metrics(q, [:average_revenue | rest]) do
from(e in q,
select_merge: %{
average_revenue:
fragment(
"if(isNaN(avgIf(?, ? > 0.0)), 0.0, avgIf(?, ? > 0.0)) * any(_sample_factor)",
e.revenue_reporting_amount,
e.revenue_reporting_amount,
e.revenue_reporting_amount,
e.revenue_reporting_amount
)
}
)
|> select_event_metrics(rest)
end
def select_event_metrics(q, [:sample_percent | rest]) do
from(e in q,
select_merge: %{

@ -17,11 +17,20 @@ defmodule Plausible.Stats.Breakdown do
|> Goals.for_site()
|> Enum.split_with(fn goal -> goal.event_name end)
revenue_goals = Enum.filter(event_goals, &Plausible.Goal.revenue?/1)
events = Enum.map(event_goals, & &1.event_name)
event_query = %Query{query | filters: Map.put(query.filters, "event:name", {:member, events})}
trace(query, property, metrics)
metrics =
if Enum.empty?(revenue_goals) do
metrics
else
metrics ++ [:average_revenue, :total_revenue]
end
event_results =
if Enum.any?(event_goals) do
breakdown(site, event_query, "event:name", metrics, pagination)
@ -30,6 +39,13 @@ defmodule Plausible.Stats.Breakdown do
[]
end
event_results =
if Enum.empty?(revenue_goals) do
event_results
else
cast_revenue_metrics_to_money(event_results, revenue_goals)
end
{limit, page} = pagination
offset = (page - 1) * limit
@ -156,6 +172,22 @@ defmodule Plausible.Stats.Breakdown do
breakdown_sessions(site, query, property, metrics, pagination)
end
defp cast_revenue_metrics_to_money(event_results, revenue_goals) do
for result <- event_results do
if matching_goal = Enum.find(revenue_goals, &(&1.event_name == result.goal)) do
total_revenue =
Money.new!(matching_goal.currency, Decimal.from_float(result.total_revenue))
average_revenue =
Money.new!(matching_goal.currency, Decimal.from_float(result.average_revenue))
%{result | total_revenue: total_revenue, average_revenue: average_revenue}
else
%{result | average_revenue: nil, total_revenue: nil}
end
end
end
defp zip_results(event_result, session_result, property, metrics) do
null_row = Enum.map(metrics, fn metric -> {metric, nil} end) |> Enum.into(%{})

@ -8,7 +8,7 @@ defmodule Plausible.Stats.Timeseries do
@typep value :: nil | integer() | float()
@type results :: nonempty_list(%{required(:date) => Date.t(), required(metric()) => value()})
@event_metrics [:visitors, :pageviews]
@event_metrics [:visitors, :pageviews, :average_revenue, :total_revenue]
@session_metrics [:visits, :bounce_rate, :visit_duration, :views_per_visit]
def timeseries(site, query, metrics) do
steps = buckets(query)
@ -217,6 +217,8 @@ defmodule Plausible.Stats.Timeseries do
:views_per_visit -> Map.merge(row, %{views_per_visit: 0.0})
:bounce_rate -> Map.merge(row, %{bounce_rate: nil})
:visit_duration -> Map.merge(row, %{:visit_duration => nil})
:average_revenue -> Map.merge(row, %{average_revenue: 0.0})
:total_revenue -> Map.merge(row, %{total_revenue: 0.0})
end
end)
end

@ -1058,6 +1058,7 @@ defmodule PlausibleWeb.Api.StatsController do
goal
|> Map.put(:prop_names, CustomProps.props_for_goal(site, query))
|> Map.put(:conversion_rate, calculate_cr(total_visitors, goal[:unique_conversions]))
|> format_revenue_metrics()
end)
if params["csv"] do
@ -1067,6 +1068,22 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
defp format_revenue_metrics(%{average_revenue: %Money{}, total_revenue: %Money{}} = results) do
%{
results
| average_revenue: %{
short: Money.to_string!(results.average_revenue, format: :short, fractional_digits: 1),
long: Money.to_string!(results.average_revenue)
},
total_revenue: %{
short: Money.to_string!(results.total_revenue, format: :short, fractional_digits: 1),
long: Money.to_string!(results.total_revenue)
}
}
end
defp format_revenue_metrics(results), do: results
def prop_breakdown(conn, params) do
site = conn.assigns[:site]
query = Query.from(site, params) |> Filters.add_prefix()

@ -0,0 +1,13 @@
defmodule Plausible.IngestRepo.Migrations.AddRevenueToEvents do
use Ecto.Migration
def change do
alter table(:events_v2) do
add :revenue_reporting_amount, :"Decimal64(4)"
add :revenue_reporting_currency, :"LowCardinality(FixedString(3))"
add :revenue_source_amount, :"Decimal64(4)"
add :revenue_source_currency, :"LowCardinality(FixedString(3))"
end
end
end

@ -158,6 +158,91 @@ defmodule Plausible.Ingestion.RequestTest do
assert request.props["custom2"] == "property2"
end
test "parses revenue source field from a json string" do
payload = %{
name: "pageview",
domain: "dummy.site",
url: "http://dummy.site/index.html",
revenue: "{\"amount\":20.2,\"currency\":\"EUR\"}"
}
conn = build_conn(:post, "/api/events", payload)
assert {:ok, request} = Request.build(conn)
assert %Money{amount: amount, currency: :EUR} = request.revenue_source
assert Decimal.new("20.2") == amount
end
test "sets revenue source with integer amount" do
payload = %{
name: "pageview",
domain: "dummy.site",
url: "http://dummy.site/index.html",
revenue: %{
"amount" => 20,
"currency" => "USD"
}
}
conn = build_conn(:post, "/api/events", payload)
assert {:ok, request} = Request.build(conn)
assert %Money{amount: amount, currency: :USD} = request.revenue_source
assert Decimal.equal?(amount, Decimal.new("20.0"))
end
test "sets revenue source with float amount" do
payload = %{
name: "pageview",
domain: "dummy.site",
url: "http://dummy.site/index.html",
revenue: %{
"amount" => 20.1,
"currency" => "USD"
}
}
conn = build_conn(:post, "/api/events", payload)
assert {:ok, request} = Request.build(conn)
assert %Money{amount: amount, currency: :USD} = request.revenue_source
assert Decimal.equal?(amount, Decimal.new("20.1"))
end
test "parses string amounts into money structs" do
payload = %{
name: "pageview",
domain: "dummy.site",
url: "http://dummy.site/index.html",
revenue: %{
"amount" => "12.3",
"currency" => "USD"
}
}
conn = build_conn(:post, "/api/events", payload)
assert {:ok, request} = Request.build(conn)
assert %Money{amount: amount, currency: :USD} = request.revenue_source
assert Decimal.equal?(amount, Decimal.new("12.3"))
end
test "rejects the event when currency is invalid" do
payload = %{
name: "pageview",
domain: "dummy.site",
url: "http://dummy.site/index.html",
revenue: %{
"amount" => 1233.2,
"currency" => "EEEE"
}
}
conn = build_conn(:post, "/api/events", payload)
assert {:error, changeset} = Request.build(conn)
assert {"currency is not supported or invalid", _} = changeset.errors[:revenue_source]
end
test "pathname is set" do
payload = %{
name: "pageview",

@ -671,6 +671,91 @@ defmodule PlausibleWeb.Api.ExternalControllerTest do
assert Map.get(event, :"meta.value") == ["true"]
end
test "converts revenue values into the goal currency", %{conn: conn, site: site} do
params = %{
name: "Payment",
url: "http://gigride.live/",
domain: site.domain,
revenue: %{amount: 10.2, currency: "USD"}
}
insert(:goal, event_name: "Payment", currency: "BRL", site: site)
assert %{status: 202} = post(conn, "/api/event", params)
assert %{revenue_reporting_amount: amount} = get_event(site)
assert Decimal.equal?(Decimal.new("7.14"), amount)
end
test "revenue values can be sent with minified keys", %{conn: conn, site: site} do
params = %{
"n" => "Payment",
"u" => "http://gigride.live/",
"d" => site.domain,
"$" => Jason.encode!(%{amount: 10.2, currency: "USD"})
}
insert(:goal, event_name: "Payment", currency: "BRL", site: site)
assert %{status: 202} = post(conn, "/api/event", params)
assert %{revenue_reporting_amount: amount} = get_event(site)
assert Decimal.equal?(Decimal.new("7.14"), amount)
end
test "saves the exact same amount when goal currency is the same as the event", %{
conn: conn,
site: site
} do
params = %{
name: "Payment",
url: "http://gigride.live/",
domain: site.domain,
revenue: %{amount: 10, currency: "BRL"}
}
insert(:goal, event_name: "Payment", currency: "BRL", site: site)
assert %{status: 202} = post(conn, "/api/event", params)
assert %{revenue_reporting_amount: amount} = get_event(site)
assert Decimal.equal?(Decimal.new("10.0"), amount)
end
test "fails when revenue value is invalid", %{conn: conn, site: site} do
params = %{
name: "Payment",
url: "http://gigride.live/",
domain: site.domain,
revenue: %{amount: "1831d", currency: "ADSIE"}
}
insert(:goal, event_name: "Payment", currency: "BRL", site: site)
conn = post(conn, "/api/event", params)
assert json_response(conn, 400) == %{
"errors" => %{"revenue_source" => ["currency is not supported or invalid"]}
}
end
test "does not save revenue value if no goal matches", %{conn: conn, site: site} do
params = %{
name: "Add to Cart",
url: "http://gigride.live/",
domain: site.domain,
revenue: %{amount: 10.2, currency: "USD"}
}
insert(:goal, event_name: "Checkout", currency: "BRL", site: site)
insert(:goal, event_name: "Payment", currency: "USD", site: site)
assert %{status: 202} = post(conn, "/api/event", params)
assert %{revenue_reporting_amount: amount} = get_event(site)
assert Decimal.equal?(Decimal.new("0.0"), amount)
end
test "ignores a malformed referrer URL", %{conn: conn, site: site} do
params = %{
name: "pageview",

@ -224,6 +224,93 @@ defmodule PlausibleWeb.Api.StatsController.ConversionsTest do
assert resp == []
end
test "returns formatted average and total values for a conversion with revenue value", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event, name: "Payment", revenue_reporting_amount: Decimal.new("200100300.123")),
build(:event, name: "Payment", revenue_reporting_amount: Decimal.new("300100400.123")),
build(:event, name: "Payment")
])
insert(:goal, %{site: site, event_name: "Payment", currency: :EUR})
conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
assert json_response(conn, 200) == [
%{
"name" => "Payment",
"unique_conversions" => 3,
"total_conversions" => 3,
"prop_names" => [],
"conversion_rate" => 100.0,
"average_revenue" => %{"short" => "€250.1M", "long" => "€250,100,350.12"},
"total_revenue" => %{"short" => "€500.2M", "long" => "€500,200,700.25"}
}
]
end
test "returns revenue metrics as nil for non-revenue goals", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event, name: "Signup"),
build(:event, name: "Signup"),
build(:event, name: "Payment")
])
insert(:goal, %{site: site, event_name: "Signup"})
insert(:goal, %{site: site, event_name: "Payment", currency: :EUR})
conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
assert json_response(conn, 200) == [
%{
"name" => "Signup",
"unique_conversions" => 2,
"total_conversions" => 2,
"prop_names" => [],
"conversion_rate" => 66.7,
"average_revenue" => nil,
"total_revenue" => nil
},
%{
"name" => "Payment",
"unique_conversions" => 1,
"total_conversions" => 1,
"prop_names" => [],
"conversion_rate" => 33.3,
"average_revenue" => %{"long" => "€0.00", "short" => "€0.0"},
"total_revenue" => %{"long" => "€0.00", "short" => "€0.0"}
}
]
end
test "does not return revenue metrics if no revenue goals are returned", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event, name: "Signup")
])
insert(:goal, %{site: site, event_name: "Signup"})
conn = get(conn, "/api/stats/#{site.domain}/conversions?period=day")
assert json_response(conn, 200) == [
%{
"name" => "Signup",
"unique_conversions" => 1,
"total_conversions" => 1,
"prop_names" => [],
"conversion_rate" => 100.0
}
]
end
end
describe "GET /api/stats/:domain/conversions - with goal filter" do

@ -912,4 +912,84 @@ defmodule PlausibleWeb.Api.StatsController.MainGraphTest do
assert 0 == Enum.sum(comparison_plot)
end
end
describe "GET /api/stats/main-graph - monetary metrics" do
setup [:create_user, :log_in, :create_new_site]
test "returns a plot of total_revenue for a monetary goal filter", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event,
name: "Purchase",
revenue_reporting_amount: 30.0,
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Purchase",
revenue_reporting_amount: 10.0,
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Purchase",
revenue_reporting_amount: 10.0,
timestamp: ~N[2021-01-02 00:00:00]
)
])
insert(:goal, %{site: site, event_name: "Purchase", currency: :EUR})
filters = Jason.encode!(%{goal: "Purchase"})
conn =
get(
conn,
"/api/stats/#{site.domain}/main-graph?period=custom&from=2021-01-01&to=2021-01-02&interval=date&metric=total_revenue&filters=#{filters}"
)
assert %{"plot" => plot} = json_response(conn, 200)
assert Enum.count(plot) == 2
assert List.first(plot) == 40.0
assert List.last(plot) == 10.0
end
test "returns a plot of average_revenue for a monetary goal filter", %{
conn: conn,
site: site
} do
populate_stats(site, [
build(:event,
name: "Purchase",
revenue_reporting_amount: 30.0,
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Purchase",
revenue_reporting_amount: 10.0,
timestamp: ~N[2021-01-01 00:00:00]
),
build(:event,
name: "Purchase",
revenue_reporting_amount: 10.0,
timestamp: ~N[2021-01-02 00:00:00]
)
])
insert(:goal, %{site: site, event_name: "Purchase", currency: :EUR})
filters = Jason.encode!(%{goal: "Purchase"})
conn =
get(
conn,
"/api/stats/#{site.domain}/main-graph?period=custom&from=2021-01-01&to=2021-01-02&interval=date&metric=average_revenue&filters=#{filters}"
)
assert %{"plot" => plot} = json_response(conn, 200)
assert Enum.count(plot) == 2
assert List.first(plot) == 20.0
assert List.last(plot) == 10.0
end
end
end

@ -76,6 +76,9 @@
if (options && options.props) {
payload.p = options.props
}
if (options && options.revenue) {
payload.$ = { currency: options.revenue.currency, amount: options.revenue.amount }
}
{{#if pageview_props}}
var propAttributes = scriptEl.getAttributeNames().filter(function (name) {

Loading…
Cancel
Save