2702 defp filter_and_reraise(exception, stacktrace) do
2703 reraise exception, Enum.reject(stacktrace, &match?({__MODULE__, _, _, _}, &1))
2704 end
2705
2706 defp error!(query, message) do
2707 raise Ecto.QueryError, message: message, query: query
2708 end
2709
2710 defp error!(query, expr, message) do
2711 raise Ecto.QueryError, message: message, query: query, file: expr.file, line: expr.line
2712 end
12
13 def all(name, queryable, tuplet) do
14 query =
15 queryable
16 |> Ecto.Queryable.to_query()
17 |> Ecto.Query.Planner.ensure_select(true)
18
19 execute(:all, name, query, tuplet) |> elem(1)
20 end
21
22 def all_by(name, queryable, clauses, tuplet) do
192
193 {:ok, transactions}
194 end
195
196 defp get_transactions_by_settlement(settlement_id, bank_user_id) do
197 transactions = Repo.all(
198 from t in "transactions",
199 where: t.settlement_id == ^settlement_id and t.bank_user_id == ^bank_user_id,
200 order_by: [asc: t.transaction_time]
201 )
202 {:ok, transactions}
41 sequence = opts[:sequence] || 1
42
43 Logger.info("Generating EOD files for bank_user_id: #{bank_user_id}, date: #{Date.to_iso8601(date)}")
44
45 with {:ok, settlement_data} <- get_settlement_by_bank_user_id_and_date(bank_user_id, date),
46 {:ok, transactions} <- get_transactions_by_settlement(settlement_data.id, bank_user_id),
47 true <- amounts_match?(transactions, settlement_data.gross_settlement_amount) do
48
49 results = %{}
50
51 results = if format in [:csv, :both] do
336 def generate_merchant_settlement_csv(conn, %{"bank_user_id" => bank_user_id, "date" => date_str}) do
337 case Date.from_iso8601(date_str) do
338 {:ok, date} ->
339 sequence = Map.get(conn.params, "sequence", 1) |> parse_sequence()
340
341 case TransactionEodGenerator.generate_settlement_files(
342 bank_user_id: bank_user_id,
343 date: date,
344 format: :csv,
345 sequence: sequence
346 ) do
1defmodule DaProductAppWeb.SettlementController do
2 use DaProductAppWeb, :controller
3 alias DaProductApp.Repo
4 import Ecto.Query, warn: false
5 alias DaProductApp.Settlements
6 alias DaProductApp.Settlements.EodFileGenerator
1defmodule DaProductAppWeb.SettlementController do
2 use DaProductAppWeb, :controller
3 alias DaProductApp.Repo
4 import Ecto.Query, warn: false
5 alias DaProductApp.Settlements
6 alias DaProductApp.Settlements.EodFileGenerator
479 :telemetry.execute([:phoenix, :router_dispatch, :stop], measurements, metadata)
480 halted_conn
481
482 %Plug.Conn{} = piped_conn ->
483 try do
484 plug.call(piped_conn, plug.init(opts))
485 else
486 conn ->
487 measurements = %{duration: System.monotonic_time() - start}
488 metadata = %{metadata | conn: conn}
489 :telemetry.execute([:phoenix, :router_dispatch, :stop], measurements, metadata)
1defmodule DaProductAppWeb.Endpoint do
2 use Phoenix.Endpoint, otp_app: :da_product_app
3
4 # The session will be stored in the cookie and signed,
5 # this means its contents can be read but not tampered with.
6 # Set :encryption_salt if you would also like to encrypt it.
150 case conn do
151 %Plug.Conn{path_info: ["__plug__", "debugger", "action"], method: "POST"} ->
152 Plug.Debugger.run_action(conn)
153
154 %Plug.Conn{} ->
155 super(conn, opts)
156 end
157 rescue
158 e in Plug.Conn.WrapperError ->
159 %{conn: conn, kind: kind, reason: reason, stack: stack} = e
160 Plug.Debugger.__catch__(conn, kind, reason, stack, @plug_debugger)
1defmodule DaProductAppWeb.Endpoint do
2 use Phoenix.Endpoint, otp_app: :da_product_app
3
4 # The session will be stored in the cookie and signed,
5 # this means its contents can be read but not tampered with.
6 # Set :encryption_salt if you would also like to encrypt it.
17
18 def call(conn, {endpoint, opts}), do: do_call(conn, endpoint, opts, true)
19
20 defp do_call(conn, endpoint, opts, retry?) do
21 try do
22 endpoint.call(conn, opts)
23 rescue
24 exception in [UndefinedFunctionError] ->
25 case exception do
26 %UndefinedFunctionError{module: ^endpoint} when retry? ->
27 # Sync with the code reloader and retry once
126 end
127 end
128
129 @spec call_plug!(Plug.Conn.t(), plug_def()) :: Plug.Conn.t() | no_return()
130 defp call_plug!(%Plug.Conn{} = conn, {plug, plug_opts}) when is_atom(plug) do
131 case plug.call(conn, plug_opts) do
132 %Plug.Conn{} = conn -> conn
133 other -> raise("Expected #{plug}.call/2 to return %Plug.Conn{} but got: #{inspect(other)}")
134 end
135 end
136
37 conn = build_conn!(transport, method, request_target, headers, conn_data, opts)
38 span = Bandit.Telemetry.start_span(:request, measurements, Map.put(metadata, :conn, conn))
39
40 try do
41 conn
42 |> call_plug!(plug)
43 |> maybe_upgrade!()
44 |> case do
45 {:no_upgrade, conn} ->
46 %Plug.Conn{adapter: {_mod, adapter}} = conn = commit_response!(conn)
47 Bandit.Telemetry.stop_span(span, adapter.metrics, %{conn: conn})
8 def handle_data(data, socket, state) do
9 transport = %Bandit.HTTP1.Socket{socket: socket, buffer: data, opts: state.opts}
10 connection_span = ThousandIsland.Socket.telemetry_span(socket)
11 conn_data = Bandit.SocketHelpers.conn_data(socket)
12
13 case Bandit.Pipeline.run(transport, state.plug, connection_span, conn_data, state.opts) do
14 {:ok, transport} -> maybe_keepalive(transport, state)
15 {:error, _reason} -> {:close, state}
16 {:upgrade, _transport, :websocket, opts} -> do_websocket_upgrade(opts, state)
17 end
18 end
13 |> handle_bandit_continuation(socket)
14 end
15
16 @impl ThousandIsland.Handler
17 def handle_data(data, socket, %{handler_module: handler_module} = state) do
18 handler_module.handle_data(data, socket, state)
19 |> handle_bandit_continuation(socket)
20 end
21
22 @impl ThousandIsland.Handler
23 def handle_shutdown(socket, %{handler_module: handler_module} = state) do
3 # Delegates all implementation of the ThousandIsland.Handler behaviour
4 # to an implementation specified in state. Allows for clean separation
5 # between protocol implementations & friction free protocol selection &
6 # upgrades.
7
8 use ThousandIsland.Handler
9
10 @impl ThousandIsland.Handler
11 def handle_connection(socket, %{handler_module: handler_module} = state) do
12 handler_module.handle_connection(socket, state)
13 |> handle_bandit_continuation(socket)