BG-753: Implements limit context's payment session support (#195)

* BG-753: Implements limit context's payment session support

* Cleans up auto formatting

* Fixes getting session from overall state

* Fixes missing route for session in limit context

* Updates 'big cascade' testcase w/ invertable limit

* Adds routing candidate limit's assertions for terminal's failures

Author: nanodirijabl

apps/hellgate/include/payment_events.hrl

@@ -4,6 +4,7 @@
 -include_lib("damsel/include/dmsl_domain_thrift.hrl").
 -include_lib("damsel/include/dmsl_user_interaction_thrift.hrl").
 -include_lib("damsel/include/dmsl_payproc_thrift.hrl").
+-include_lib("hellgate/include/payment_events.hrl").
 
 %% Payments
 

apps/hellgate/src/hg_invoice_payment.erl

@@ -2522,14 +2522,15 @@ reject_routes(GroupReason, RejectedRoutes, Ctx) ->
 get_limit_overflow_routes(Routes, VS, Iter, St) ->
     Opts = get_opts(St),
     Revision = get_payment_revision(St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     Invoice = get_invoice(Opts),
     lists:foldl(
         fun(Route, {RoutesNoOverflowIn, RejectedIn, LimitsIn}) ->
             PaymentRoute = hg_route:to_payment_route(Route),
             ProviderTerms = hg_routing:get_payment_terms(PaymentRoute, VS, Revision),
             TurnoverLimits = get_turnover_limits(ProviderTerms, strict),
-            case hg_limiter:check_limits(TurnoverLimits, Invoice, Payment, PaymentRoute, Iter) of
+            case hg_limiter:check_limits(TurnoverLimits, Invoice, Payment, Session, PaymentRoute, Iter) of
                 {ok, Limits} ->
                     {[Route | RoutesNoOverflowIn], RejectedIn, LimitsIn#{PaymentRoute => Limits}};
                 {error, {limit_overflow, IDs, Limits}} ->
@@ -2596,6 +2597,7 @@ get_shop_turnover_limits(ShopConfig) ->
 hold_limit_routes(Routes0, VS, Iter, St) ->
     Opts = get_opts(St),
     Revision = get_payment_revision(St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     Invoice = get_invoice(Opts),
     {Routes1, Rejected} = lists:foldl(
@@ -2604,7 +2606,7 @@ hold_limit_routes(Routes0, VS, Iter, St) ->
             ProviderTerms = hg_routing:get_payment_terms(PaymentRoute, VS, Revision),
             TurnoverLimits = get_turnover_limits(ProviderTerms, strict),
             try
-                ok = hg_limiter:hold_payment_limits(TurnoverLimits, Invoice, Payment, PaymentRoute, Iter),
+                ok = hg_limiter:hold_payment_limits(TurnoverLimits, Invoice, Payment, Session, PaymentRoute, Iter),
                 {[Route | LimitHeldRoutes], RejectedRoutes}
             catch
                 error:(#limiter_LimitNotFound{} = LimiterError) ->
@@ -2630,20 +2632,22 @@ do_reject_route(LimiterError, Route, TurnoverLimits, {LimitHeldRoutes, RejectedR
 rollback_payment_limits(Routes, Iter, St, Flags) ->
     Opts = get_opts(St),
     Revision = get_payment_revision(St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     Invoice = get_invoice(Opts),
     VS = get_varset(St, #{}),
     lists:foreach(
         fun(Route) ->
             ProviderTerms = hg_routing:get_payment_terms(Route, VS, Revision),
             TurnoverLimits = get_turnover_limits(ProviderTerms, strict),
-            ok = hg_limiter:rollback_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter, Flags)
+            ok = hg_limiter:rollback_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter, Flags)
         end,
         Routes
     ).
 
 rollback_broken_payment_limits(St) ->
     Opts = get_opts(St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     Invoice = get_invoice(Opts),
     LimitValues = get_limit_values_(St, lenient),
@@ -2661,7 +2665,7 @@ rollback_broken_payment_limits(St) ->
                         [],
                         Values
                     ),
-                ok = hg_limiter:rollback_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter, [
+                ok = hg_limiter:rollback_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter, [
                     ignore_business_error
                 ])
         end,
@@ -2681,14 +2685,15 @@ get_turnover_limits(ProviderTerms, Mode) ->
 commit_payment_limits(#st{capture_data = CaptureData} = St) ->
     Opts = get_opts(St),
     Revision = get_payment_revision(St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     #payproc_InvoicePaymentCaptureData{cash = CapturedCash} = CaptureData,
     Invoice = get_invoice(Opts),
     Route = get_route(St),
     ProviderTerms = get_provider_payment_terms(St, Revision),
     TurnoverLimits = get_turnover_limits(ProviderTerms, strict),
     Iter = get_iter(St),
-    hg_limiter:commit_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter, CapturedCash).
+    hg_limiter:commit_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter, CapturedCash).
 
 commit_payment_cashflow(St) ->
     Plan = get_cashflow_plan(St),
@@ -3482,6 +3487,7 @@ get_limit_values(St, Opts) ->
 get_limit_values_(St, Mode) ->
     {PaymentInstitution, VS, Revision} = route_args(St),
     Ctx = build_routing_context(PaymentInstitution, VS, Revision, St),
+    Session = get_activity_session(St),
     Payment = get_payment(St),
     Invoice = get_invoice(get_opts(St)),
     %% NOTE If event 'route_changed' didn't occur, then there may be
@@ -3498,7 +3504,7 @@ get_limit_values_(St, Mode) ->
             ProviderTerms = hg_routing:get_payment_terms(PaymentRoute, VS, Revision),
             TurnoverLimits = get_turnover_limits(ProviderTerms, Mode),
             TurnoverLimitValues =
-                hg_limiter:get_limit_values(TurnoverLimits, Invoice, Payment, PaymentRoute, Iter),
+                hg_limiter:get_limit_values(TurnoverLimits, Invoice, Payment, Session, PaymentRoute, Iter),
             Acc#{PaymentRoute => TurnoverLimitValues}
         end,
         #{},
@@ -3633,7 +3639,9 @@ get_payment_state(InvoiceID, PaymentID) ->
             throw(#payproc_InvoicePaymentNotFound{})
     end.
 
--spec get_session(target(), st()) -> session().
+-spec get_session(target(), st()) -> session() | undefined.
+get_session(_Target, #st{routes = []}) ->
+    undefined;
 get_session(Target, #st{sessions = Sessions, routes = [Route | _PreviousRoutes]}) ->
     TargetSessions = maps:get(get_target_type(Target), Sessions, []),
     MatchingRoute = fun(#{route := SR}) -> SR =:= Route end,
@@ -3679,7 +3687,9 @@ get_activity_session({payment, _Step}, St) ->
     get_session(get_target(St), St);
 get_activity_session({refund, ID}, St) ->
     Refund = try_get_refund_state(ID, St),
-    hg_invoice_payment_refund:session(Refund).
+    hg_invoice_payment_refund:session(Refund);
+get_activity_session(_, _St) ->
+    undefined.
 
 %%
 

apps/hellgate/src/hg_invoice_registered_payment.erl

@@ -198,7 +198,7 @@ hold_payment_limits(Invoice, Payment, St) ->
     Route = hg_invoice_payment:get_route(St),
     TurnoverLimits = get_turnover_limits(Payment, Route, St),
     Iter = hg_invoice_payment:get_iter(St),
-    hg_limiter:hold_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter).
+    hg_limiter:hold_payment_limits(TurnoverLimits, Invoice, Payment, undefined, Route, Iter).
 
 get_turnover_limits(Payment, Route, St) ->
     Route = hg_invoice_payment:get_route(St),

apps/hellgate/src/hg_limiter.erl

@@ -10,6 +10,7 @@
 -type turnover_limit() :: dmsl_domain_thrift:'TurnoverLimit'().
 -type invoice() :: dmsl_domain_thrift:'Invoice'().
 -type payment() :: dmsl_domain_thrift:'InvoicePayment'().
+-type session() :: hg_session:t().
 -type route() :: hg_route:payment_route().
 -type refund() :: hg_invoice_payment:domain_refund().
 -type cash() :: dmsl_domain_thrift:'Cash'().
@@ -21,18 +22,18 @@
 -export_type([turnover_limit_value/0]).
 
 -export([get_turnover_limits/2]).
--export([check_limits/5]).
+-export([check_limits/6]).
 -export([check_shop_limits/5]).
--export([hold_payment_limits/5]).
+-export([hold_payment_limits/6]).
 -export([hold_shop_limits/5]).
 -export([hold_refund_limits/5]).
--export([commit_payment_limits/6]).
+-export([commit_payment_limits/7]).
 -export([commit_shop_limits/5]).
 -export([commit_refund_limits/5]).
--export([rollback_payment_limits/6]).
+-export([rollback_payment_limits/7]).
 -export([rollback_shop_limits/6]).
 -export([rollback_refund_limits/5]).
--export([get_limit_values/5]).
+-export([get_limit_values/6]).
 
 -define(route(ProviderRef, TerminalRef), #domain_PaymentRoute{
     provider = ProviderRef,
@@ -77,9 +78,10 @@ filter_existing_turnover_limits(Limits, Mode) ->
         Limits
     ).
 
--spec get_limit_values([turnover_limit()], invoice(), payment(), route(), pos_integer()) -> [turnover_limit_value()].
-get_limit_values(TurnoverLimits, Invoice, Payment, Route, Iter) ->
-    Context = gen_limit_context(Invoice, Payment, Route),
+-spec get_limit_values([turnover_limit()], invoice(), payment(), session() | undefined, route(), pos_integer()) ->
+    [turnover_limit_value()].
+get_limit_values(TurnoverLimits, Invoice, Payment, Session, Route, Iter) ->
+    Context = gen_limit_context(Invoice, Payment, Session, Route),
     get_limit_values(Context, TurnoverLimits, make_route_operation_segments(Invoice, Payment, Route, Iter)).
 
 make_route_operation_segments(Invoice, Payment, ?route(ProviderRef, TerminalRef), Iter) ->
@@ -105,11 +107,11 @@ get_batch_limit_values(Context, TurnoverLimits, OperationIdSegments) ->
         hg_limiter_client:get_batch(LimitRequest, Context)
     ).
 
--spec check_limits([turnover_limit()], invoice(), payment(), route(), pos_integer()) ->
+-spec check_limits([turnover_limit()], invoice(), payment(), session() | undefined, route(), pos_integer()) ->
     {ok, [turnover_limit_value()]}
     | {error, {limit_overflow, [binary()], [turnover_limit_value()]}}.
-check_limits(TurnoverLimits, Invoice, Payment, Route, Iter) ->
-    Context = gen_limit_context(Invoice, Payment, Route),
+check_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter) ->
+    Context = gen_limit_context(Invoice, Payment, Session, Route),
     Limits = get_limit_values(Context, TurnoverLimits, make_route_operation_segments(Invoice, Payment, Route, Iter)),
     try
         ok = check_limits_(Limits, Context),
@@ -166,9 +168,10 @@ check_limits_([TurnoverLimitValue | TLVs], Context) ->
             throw(limit_overflow)
     end.
 
--spec hold_payment_limits([turnover_limit()], invoice(), payment(), route(), pos_integer()) -> ok.
-hold_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter) ->
-    Context = gen_limit_context(Invoice, Payment, Route),
+-spec hold_payment_limits([turnover_limit()], invoice(), payment(), session() | undefined, route(), pos_integer()) ->
+    ok.
+hold_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter) ->
+    Context = gen_limit_context(Invoice, Payment, Session, Route),
     ok = batch_hold_limits(Context, TurnoverLimits, make_route_operation_segments(Invoice, Payment, Route, Iter)).
 
 batch_hold_limits(_Context, [], _OperationIdSegments) ->
@@ -197,9 +200,17 @@ make_refund_operation_segments(Invoice, Payment, Refund) ->
         {refund_session, get_refund_id(Refund)}
     ].
 
--spec commit_payment_limits([turnover_limit()], invoice(), payment(), route(), pos_integer(), cash() | undefined) -> ok.
-commit_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter, CapturedCash) ->
-    Context = gen_limit_context(Invoice, Payment, Route, CapturedCash),
+-spec commit_payment_limits(
+    [turnover_limit()],
+    invoice(),
+    payment(),
+    session() | undefined,
+    route(),
+    pos_integer(),
+    cash() | undefined
+) -> ok.
+commit_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter, CapturedCash) ->
+    Context = gen_limit_context(Invoice, Payment, Session, Route, CapturedCash),
     OperationIdSegments = make_route_operation_segments(Invoice, Payment, Route, Iter),
     ok = batch_commit_limits(Context, TurnoverLimits, OperationIdSegments).
 
@@ -243,10 +254,18 @@ batch_commit_limits(Context, TurnoverLimits, OperationIdSegments) ->
 %%
 %%      - `ignore_not_found` -- does not raise error if limiter won't be able to
 %%      find according posting plan in accountant service
--spec rollback_payment_limits([turnover_limit()], invoice(), payment(), route(), pos_integer(), [handling_flag()]) ->
+-spec rollback_payment_limits(
+    [turnover_limit()],
+    invoice(),
+    payment(),
+    session() | undefined,
+    route(),
+    pos_integer(),
+    [handling_flag()]
+) ->
     ok.
-rollback_payment_limits(TurnoverLimits, Invoice, Payment, Route, Iter, Flags) ->
-    Context = gen_limit_context(Invoice, Payment, Route),
+rollback_payment_limits(TurnoverLimits, Invoice, Payment, Session, Route, Iter, Flags) ->
+    Context = gen_limit_context(Invoice, Payment, Session, Route),
     OperationIdSegments = make_route_operation_segments(Invoice, Payment, Route, Iter),
     ok = batch_rollback_limits(Context, TurnoverLimits, OperationIdSegments, Flags).
 
@@ -281,10 +300,10 @@ rollback_refund_limits(TurnoverLimits, Invoice, Payment, Refund, Route) ->
     OperationIdSegments = make_refund_operation_segments(Invoice, Payment, Refund),
     ok = batch_rollback_limits(Context, TurnoverLimits, OperationIdSegments, []).
 
-gen_limit_context(Invoice, Payment, Route) ->
-    gen_limit_context(Invoice, Payment, Route, undefined).
+gen_limit_context(Invoice, Payment, Session, Route) ->
+    gen_limit_context(Invoice, Payment, Session, Route, undefined).
 
-gen_limit_context(Invoice, Payment, Route, CapturedCash) ->
+gen_limit_context(Invoice, Payment, Session, Route, CapturedCash) ->
     PaymentCtx = #context_payproc_InvoicePayment{
         payment = Payment#domain_InvoicePayment{
             status = {captured, #domain_InvoicePaymentCaptured{cost = CapturedCash}}
@@ -296,11 +315,17 @@ gen_limit_context(Invoice, Payment, Route, CapturedCash) ->
             op = {invoice_payment, #context_payproc_OperationInvoicePayment{}},
             invoice = #context_payproc_Invoice{
                 invoice = Invoice,
-                payment = PaymentCtx
+                payment = PaymentCtx,
+                session = gen_limit_session_context(Session, Route)
             }
         }
     }.
 
+gen_limit_session_context(#{status := finished, route := Route}, Route) ->
+    #context_payproc_InvoicePaymentSession{};
+gen_limit_session_context(_, _) ->
+    undefined.
+
 gen_limit_shop_context(Invoice, Payment) ->
     #limiter_LimitContext{
         payment_processing = #context_payproc_Context{