HG-544: shumaich payments

apps/hellgate/include/payment_events.hrl

@@ -33,6 +33,10 @@
     {invoice_payment_cash_flow_changed, #payproc_InvoicePaymentCashFlowChanged{cash_flow = CashFlow}}
 ).
 
+-define(payment_clock_update(Clock),
+    {invoice_payment_clock_update, #payproc_InvoicePaymentClockUpdate{clock = Clock}}
+).
+
 -define(payment_status_changed(Status),
     {invoice_payment_status_changed, #payproc_InvoicePaymentStatusChanged{status = Status}}
 ).

apps/hellgate/src/hg_accounting_new.erl

@@ -54,6 +54,7 @@
 -type revision() :: hg_domain:revision().
 
 -export_type([batch/0]).
+-export_type([clock/0]).
 
 -type account() :: #{
     account_id => account_id(),

apps/hellgate/src/hg_invoice_payment.erl

@@ -148,7 +148,8 @@
     capture_params :: undefined | capture_params(),
     failure :: undefined | failure(),
     timings :: undefined | hg_timings:t(),
-    latest_change_at :: undefined | hg_datetime:timestamp()
+    latest_change_at :: undefined | hg_datetime:timestamp(),
+    clock :: undefined | hg_accounting_new:clock()
 }).
 
 -record(refund_st, {
@@ -1879,11 +1880,12 @@ process_cash_flow_building(Action, St) ->
     TurnoverLimits = get_turnover_limits(ProviderTerms),
     ok = hg_limiter:hold_payment_limits(TurnoverLimits, Invoice, Payment),
     FinalCashflow = calculate_cashflow(Route, Payment, MerchantTerms, ProviderTerms, VS1, Revision, Opts),
-    _Clock = hg_accounting:hold(
+    Clock = hg_accounting_new:hold(
         construct_payment_plan_id(Invoice, Payment),
-        {1, FinalCashflow}
+        {1, FinalCashflow},
+        Timestamp
     ),
-    Events = [?cash_flow_changed(FinalCashflow)],
+    Events = [?cash_flow_changed(FinalCashflow), ?payment_clock_update(Clock)],
     case hg_limiter:check_limits(TurnoverLimits, Invoice, Payment) of
         {ok, _} ->
             {next, {Events, hg_machine_action:set_timeout(0, Action)}};
@@ -1972,7 +1974,7 @@ process_adjustment_cashflow(ID, _Action, St) ->
     {done, {Events, hg_machine_action:new()}}.
 
 process_accounter_update(Action, St = #st{partial_cash_flow = FinalCashflow, capture_params = CaptureParams}) ->
-    Opts = get_opts(St),
+    #{timestamp := Timestamp} = Opts = get_opts(St),
     #payproc_InvoicePaymentCaptureParams{
         reason = Reason,
         cash = Cost,
@@ -1981,15 +1983,17 @@ process_accounter_update(Action, St = #st{partial_cash_flow = FinalCashflow, cap
     Invoice = get_invoice(Opts),
     Payment = get_payment(St),
     Payment2 = Payment#domain_InvoicePayment{cost = Cost},
-    _Clock = hg_accounting:plan(
+    NewClock = hg_accounting_new:plan(
         construct_payment_plan_id(Invoice, Payment2),
         [
             {2, hg_cashflow:revert(get_cashflow(St))},
             {3, FinalCashflow}
-        ]
+        ],
+        Timestamp,
+        St#st.clock
     ),
     Events = start_session(?captured(Reason, Cost, Cart)),
-    {next, {Events, hg_machine_action:set_timeout(0, Action)}}.
+    {next, {[?payment_clock_update(NewClock) | Events], hg_machine_action:set_timeout(0, Action)}}.
 
 %%
 
@@ -2128,22 +2132,22 @@ process_result({payment, processing_accounter}, Action, St) ->
 process_result({payment, processing_failure}, Action, St = #st{failure = Failure}) ->
     NewAction = hg_machine_action:set_timeout(0, Action),
     _ = rollback_payment_limits(St),
-    _Clocks = rollback_payment_cashflow(St),
-    {done, {[?payment_status_changed(?failed(Failure))], NewAction}};
+    Clock = rollback_payment_cashflow(St),
+    {done, {[?payment_clock_update(Clock), ?payment_status_changed(?failed(Failure))], NewAction}};
 process_result({payment, finalizing_accounter}, Action, St) ->
     Target = get_target(St),
-    _Clocks =
+    AccounterClock =
         case Target of
             ?captured() ->
-                commit_payment_limits(St),
+                _LimiterClock = commit_payment_limits(St),
                 commit_payment_cashflow(St);
             ?cancelled() ->
-                rollback_payment_limits(St),
+                _LimiterClock = rollback_payment_limits(St),
                 rollback_payment_cashflow(St)
         end,
     check_recurrent_token(St),
     NewAction = get_action(Target, Action, St),
-    {done, {[?payment_status_changed(Target)], NewAction}};
+    {done, {[?payment_clock_update(AccounterClock), ?payment_status_changed(Target)], NewAction}};
 process_result({refund_failure, ID}, Action, St) ->
     RefundSt = try_get_refund_state(ID, St),
     Failure = RefundSt#refund_st.failure,
@@ -2545,11 +2549,13 @@ rollback_refund_limits(RefundSt, St) ->
     TurnoverLimits = get_turnover_limits(ProviderTerms),
     hg_limiter:rollback_refund_limits(TurnoverLimits, Invoice, Payment, Refund).
 
-commit_payment_cashflow(St) ->
-    hg_accounting:commit(construct_payment_plan_id(St), get_cashflow_plan(St)).
+commit_payment_cashflow(St = #st{clock = Clock}) ->
+    #{timestamp := Timestamp} = get_opts(St),
+    hg_accounting_new:commit(construct_payment_plan_id(St), get_cashflow_plan(St), Timestamp, Clock).
 
-rollback_payment_cashflow(St) ->
-    hg_accounting:rollback(construct_payment_plan_id(St), get_cashflow_plan(St)).
+rollback_payment_cashflow(St = #st{clock = Clock}) ->
+    #{timestamp := Timestamp} = get_opts(St),
+    hg_accounting_new:rollback(construct_payment_plan_id(St), get_cashflow_plan(St), Timestamp, Clock).
 
 get_cashflow_plan(St = #st{partial_cash_flow = PartialCashFlow}) when PartialCashFlow =/= undefined ->
     [
@@ -2891,8 +2897,7 @@ merge_change(Change = ?cash_flow_changed(Cashflow), #st{activity = Activity} = S
     case Activity of
         {payment, cash_flow_building} ->
             St#st{
-                cash_flow = Cashflow,
-                activity = {payment, processing_session}
+                cash_flow = Cashflow
             };
         {payment, processing_capture} ->
             St#st{
@@ -2902,6 +2907,36 @@ merge_change(Change = ?cash_flow_changed(Cashflow), #st{activity = Activity} = S
         _ ->
             St
     end;
+merge_change(Change = ?payment_clock_update(Clock), #st{activity = Activity} = St, Opts) ->
+    _ = validate_transition(
+        [
+            {payment, S}
+            || S <- [
+                   cash_flow_building,
+                   processing_session,
+                   processing_failure,
+                   finalizing_accounter,
+                   updating_accounter
+               ]
+        ],
+        Change,
+        St,
+        Opts
+    ),
+    case Activity of
+        {payment, cash_flow_building} ->
+            St#st{
+                clock = Clock,
+                activity = {payment, processing_session}
+            };
+        {payment, processing_capture} ->
+            St#st{
+                clock = Clock,
+                activity = {payment, updating_accounter}
+            };
+        _ ->
+            St
+    end;
 merge_change(Change = ?rec_token_acquired(Token), #st{} = St, Opts) ->
     _ = validate_transition([{payment, processing_session}, {payment, finalizing_session}], Change, St, Opts),
     St#st{recurrent_token = Token};

apps/hellgate/test/hg_invoice_adjustment_tests_SUITE.erl

@@ -885,7 +885,8 @@ start_payment(InvoiceID, PaymentParams, Client) ->
         ?payment_ev(PaymentID, ?route_changed(_))
     ] = next_event(InvoiceID, Client),
     [
-        ?payment_ev(PaymentID, ?cash_flow_changed(_))
+        ?payment_ev(PaymentID, ?cash_flow_changed(_)),
+        ?payment_ev(PaymentID, ?payment_clock_update(_))
     ] = next_event(InvoiceID, Client),
     PaymentID.
 
@@ -946,6 +947,7 @@ await_payment_partial_capture(InvoiceID, PaymentID, Reason, Cash, Client, Restar
         ?payment_ev(PaymentID, ?cash_flow_changed(_))
     ] = next_event(InvoiceID, Client),
     [
+        ?payment_ev(PaymentID, ?payment_clock_update(_)),
         ?payment_ev(PaymentID, ?session_ev(?captured(Reason, Cash), ?session_started()))
     ] = next_event(InvoiceID, Client),
     await_payment_capture_finish(InvoiceID, PaymentID, Reason, Client, Restarts, Cash).
@@ -964,6 +966,7 @@ await_payment_capture_finish(InvoiceID, PaymentID, Reason, Client, Restarts, Cos
         ?payment_ev(PaymentID, ?session_ev(Target, ?session_finished(?session_succeeded())))
     ] = next_event(InvoiceID, Client),
     [
+        ?payment_ev(PaymentID, ?payment_clock_update(_)),
         ?payment_ev(PaymentID, ?payment_status_changed(Target)),
         ?invoice_status_changed(?invoice_paid())
     ] = next_event(InvoiceID, Client),