feat: Use currencyConvert function when calculating WA revenue

posthog/hogql/database/schema/exchange_rate.py

@@ -1,3 +1,7 @@
+from typing import Union
+
+from posthog.hogql import ast
+from posthog.schema import CurrencyCode, RevenueTrackingConfig, RevenueTrackingEventItem
 from posthog.hogql.database.models import (
     StringDatabaseField,
     DateDatabaseField,
@@ -19,3 +23,154 @@ def to_printed_clickhouse(self, context):
 
     def to_printed_hogql(self):
         return "exchange_rate"
+
+
+def convert_currency_call(
+    amount: ast.Expr, currency_from: ast.Expr, currency_to: ast.Expr, timestamp: ast.Expr | None = None
+) -> ast.Expr:
+    args = [currency_from, currency_to, amount]
+    if timestamp:
+        args.append(timestamp)
+
+    return ast.Call(name="convertCurrency", args=args)
+
+
+def revenue_currency_expression(config: RevenueTrackingConfig) -> ast.Expr:
+    exprs = []
+    for event in config.events:
+        exprs.extend(
+            [
+                ast.CompareOperation(
+                    left=ast.Field(chain=["event"]),
+                    op=ast.CompareOperationOp.Eq,
+                    right=ast.Constant(value=event.eventName),
+                ),
+                ast.Field(chain=["events", "properties", event.revenueCurrencyProperty])
+                if event.revenueCurrencyProperty
+                else ast.Constant(value=None),
+            ]
+        )
+
+    if len(exprs) == 0:
+        return ast.Constant(value=None)
+
+    # Else clause, make sure there's a None at the end
+    exprs.append(ast.Constant(value=None))
+
+    return ast.Call(name="multiIf", args=exprs)
+
+
+def revenue_comparison_and_value_exprs(
+    event: RevenueTrackingEventItem,
+    config: RevenueTrackingConfig,
+    do_currency_conversion: bool = False,
+) -> tuple[ast.Expr, ast.Expr]:
+    # Check whether the event is the one we're looking for
+    comparison_expr = ast.CompareOperation(
+        left=ast.Field(chain=["event"]),
+        op=ast.CompareOperationOp.Eq,
+        right=ast.Constant(value=event.eventName),
+    )
+
+    # If there's a revenueCurrencyProperty, convert the revenue to the base currency from that property
+    # Otherwise, assume we're already in the base currency
+    # Also, assume that `base_currency` is USD by default, it'll be empty for most customers
+    if event.revenueCurrencyProperty and do_currency_conversion:
+        value_expr = ast.Call(
+            name="if",
+            args=[
+                ast.Call(
+                    name="isNull", args=[ast.Field(chain=["events", "properties", event.revenueCurrencyProperty])]
+                ),
+                ast.Call(
+                    name="toDecimal",
+                    args=[
+                        ast.Field(chain=["events", "properties", event.revenueProperty]),
+                        ast.Constant(value=10),
+                    ],
+                ),
+                convert_currency_call(
+                    ast.Field(chain=["events", "properties", event.revenueProperty]),
+                    ast.Field(chain=["events", "properties", event.revenueCurrencyProperty]),
+                    ast.Constant(value=(config.baseCurrency or CurrencyCode.USD).value),
+                    ast.Call(name="DATE", args=[ast.Field(chain=["events", "timestamp"])]),
+                ),
+            ],
+        )
+    else:
+        value_expr = ast.Call(
+            name="toDecimal",
+            args=[ast.Field(chain=["events", "properties", event.revenueProperty]), ast.Constant(value=10)],
+        )
+
+    return (comparison_expr, value_expr)
+
+
+def revenue_expression(
+    config: Union[RevenueTrackingConfig, dict, None],
+    do_currency_conversion: bool = False,
+) -> ast.Expr:
+    if isinstance(config, dict):
+        config = RevenueTrackingConfig.model_validate(config)
+
+    if not config or not config.events:
+        return ast.Constant(value=None)
+
+    exprs: list[ast.Expr] = []
+    for event in config.events:
+        comparison_expr, value_expr = revenue_comparison_and_value_exprs(event, config, do_currency_conversion)
+        exprs.extend([comparison_expr, value_expr])
+
+    # Else clause, make sure there's a None at the end
+    exprs.append(ast.Constant(value=None))
+
+    return ast.Call(name="multiIf", args=exprs)
+
+
+def revenue_sum_expression(
+    config: Union[RevenueTrackingConfig, dict, None],
+    do_currency_conversion: bool = False,
+) -> ast.Expr:
+    if isinstance(config, dict):
+        config = RevenueTrackingConfig.model_validate(config)
+
+    if not config or not config.events:
+        return ast.Constant(value=None)
+
+    exprs: list[ast.Expr] = []
+    for event in config.events:
+        comparison_expr, value_expr = revenue_comparison_and_value_exprs(event, config, do_currency_conversion)
+
+        exprs.append(
+            ast.Call(
+                name="sumIf",
+                args=[
+                    ast.Call(name="ifNull", args=[value_expr, ast.Constant(value=0)]),
+                    comparison_expr,
+                ],
+            )
+        )
+
+    if len(exprs) == 1:
+        return exprs[0]
+
+    return ast.Call(name="plus", args=exprs)
+
+
+def revenue_events_where_expr(config: Union[RevenueTrackingConfig, dict, None]) -> ast.Expr:
+    if isinstance(config, dict):
+        config = RevenueTrackingConfig.model_validate(config)
+
+    if not config or not config.events:
+        return ast.Constant(value=False)
+
+    exprs: list[ast.Expr] = []
+    for event in config.events:
+        # NOTE: Dont care about conversion, only care about comparison which is independent of conversion
+        comparison_expr, _value_expr = revenue_comparison_and_value_exprs(event, config, do_currency_conversion=False)
+        exprs.append(comparison_expr)
+
+    if len(exprs) == 1:
+        return exprs[0]
+
+    return ast.Or(exprs=exprs)

posthog/hogql_queries/web_analytics/revenue_example_events.py

@@ -1,12 +1,18 @@
 import json
+import posthoganalytics
 
 from posthog.hogql import ast
 from posthog.hogql.ast import CompareOperationOp
 from posthog.hogql.constants import LimitContext
 from posthog.hogql_queries.insights.paginators import HogQLHasMorePaginator
 from posthog.hogql_queries.query_runner import QueryRunner
-from posthog.hogql_queries.utils.revenue import revenue_expression, revenue_events_expr
+from posthog.hogql.database.schema.exchange_rate import (
+    revenue_expression,
+    revenue_events_where_expr,
+    revenue_currency_expression,
+)
 from posthog.schema import (
+    CurrencyCode,
     RevenueExampleEventsQuery,
     RevenueExampleEventsQueryResponse,
     CachedRevenueExampleEventsQueryResponse,
@@ -18,13 +24,21 @@ class RevenueExampleEventsQueryRunner(QueryRunner):
     response: RevenueExampleEventsQueryResponse
     cached_response: CachedRevenueExampleEventsQueryResponse
     paginator: HogQLHasMorePaginator
+    do_currency_conversion: bool = False
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.paginator = HogQLHasMorePaginator.from_limit_context(
             limit_context=LimitContext.QUERY, limit=self.query.limit if self.query.limit else None
         )
 
+        self.do_currency_conversion = posthoganalytics.feature_enabled(
+            "web-analytics-revenue-tracking-conversion",
+            str(self.team.organization_id),
+            groups={"organization": str(self.team.organization_id)},
+            group_properties={"organization": {"id": str(self.team.organization_id)}},
+        )
+
     def to_query(self) -> ast.SelectQuery:
         tracking_config = self.query.revenueTrackingConfig
 
@@ -40,7 +54,14 @@ def to_query(self) -> ast.SelectQuery:
                     ],
                 ),
                 ast.Field(chain=["event"]),
-                ast.Alias(alias="revenue", expr=revenue_expression(tracking_config)),
+                ast.Alias(
+                    alias="original_revenue", expr=revenue_expression(tracking_config, do_currency_conversion=False)
+                ),
+                ast.Alias(alias="revenue", expr=revenue_expression(tracking_config, self.do_currency_conversion)),
+                ast.Alias(alias="original_currency", expr=revenue_currency_expression(tracking_config)),
+                ast.Alias(
+                    alias="currency", expr=ast.Constant(value=(tracking_config.baseCurrency or CurrencyCode.USD).value)
+                ),
                 ast.Call(
                     name="tuple",
                     args=[
@@ -56,7 +77,7 @@ def to_query(self) -> ast.SelectQuery:
             select_from=ast.JoinExpr(table=ast.Field(chain=["events"])),
             where=ast.And(
                 exprs=[
-                    revenue_events_expr(tracking_config),
+                    revenue_events_where_expr(tracking_config),
                     ast.CompareOperation(
                         op=CompareOperationOp.NotEq,
                         left=ast.Field(chain=["revenue"]),  # refers to the Alias above
@@ -88,14 +109,17 @@ def calculate(self):
                 },
                 row[1],
                 row[2],
-                {
-                    "id": row[3][0],
-                    "created_at": row[3][1],
-                    "distinct_id": row[3][2],
-                    "properties": json.loads(row[3][3]),
-                },
+                row[3],
                 row[4],
                 row[5],
+                {
+                    "id": row[6][0],
+                    "created_at": row[6][1],
+                    "distinct_id": row[6][2],
+                    "properties": json.loads(row[6][3]),
+                },
+                row[7],
+                row[8],
             )
             for row in response.results
         ]
@@ -104,7 +128,10 @@ def calculate(self):
             columns=[
                 "*",
                 "event",
+                "original_revenue",
                 "revenue",
+                "original_revenue_currency",
+                "revenue_currency",
                 "person",
                 "session_id",
                 "timestamp",