this repo has no description
:sparkles: reimplementing get summary payments
+130
-29
+1
-1
request-get-all.hurl
+1
-1
request-get-all.hurl
+2
-2
src/integrations/provider.gleam
+2
-2
src/integrations/provider.gleam
···
5
5
import gleam/httpc
6
6
import gleam/json
7
7
import gleam/result
8
-
import model
8
+
import models/payment_request.{type PaymentRequest}
9
9
10
10
pub type ProviderConfig {
11
11
ProviderConfig(url: String)
12
12
}
13
13
14
-
pub fn create_body(body: model.PaymentRequest) -> String {
14
+
pub fn create_body(body: PaymentRequest) -> String {
15
15
json.object([
16
16
#("correlationId", json.string(body.correlation_id)),
17
17
#("amount", json.float(body.amount)),
src/model.gleam
src/models/payment_request.gleam
src/model.gleam
src/models/payment_request.gleam
+38
src/models/count_provider.gleam
+38
src/models/count_provider.gleam
···
1
+
import gleam/dict
2
+
import gleam/json
3
+
import gleam/list
4
+
import models/payment_request.{type PaymentRequest}
5
+
6
+
pub type CountProvider {
7
+
CountProvider(provider: String, total_requests: Int, total_amount: Float)
8
+
}
9
+
10
+
pub fn new(provider: String) -> CountProvider {
11
+
CountProvider(provider: provider, total_amount: 0.0, total_requests: 0)
12
+
}
13
+
14
+
pub fn count_provider(
15
+
count: CountProvider,
16
+
payments: dict.Dict(String, List(PaymentRequest)),
17
+
) -> CountProvider {
18
+
case dict.get(payments, count.provider) {
19
+
Error(_) -> count
20
+
Ok(data) ->
21
+
data
22
+
|> list.fold(count, fn(acc, d) {
23
+
CountProvider(
24
+
..acc,
25
+
total_requests: acc.total_requests + 1,
26
+
total_amount: acc.total_amount +. d.amount,
27
+
)
28
+
})
29
+
}
30
+
}
31
+
32
+
pub fn to_json(count: CountProvider) -> json.Json {
33
+
[
34
+
#("totalRequests", json.int(count.total_requests)),
35
+
#("totalAmount", json.float(count.total_amount)),
36
+
]
37
+
|> json.object()
38
+
}
+5
-5
src/processor.gleam
+5
-5
src/processor.gleam
···
4
4
import gleam/otp/supervision
5
5
import gleam/string
6
6
import integrations/provider
7
-
import model
7
+
import models/payment_request
8
8
import redis
9
9
import valkyrie
10
10
···
73
73
74
74
pub fn loop_worker(subject: process.Subject(Message)) {
75
75
process.send(subject, ServerTick)
76
-
process.sleep(2000)
76
+
process.sleep(200)
77
77
loop_worker(subject)
78
78
}
79
79
···
95
95
96
96
fn integrate_data(processor: Processor, data: String) {
97
97
echo "Trying to integrate " <> data
98
-
let assert Ok(message) = model.from_json_string(data)
98
+
let assert Ok(message) = payment_request.from_json_string(data)
99
99
100
100
let body_to_send = message |> provider.create_body
101
101
···
119
119
processor.redis_conn
120
120
|> redis.save_data(
121
121
message
122
-
|> model.set_provider(save_provider)
123
-
|> model.to_dict,
122
+
|> payment_request.set_provider(save_provider)
123
+
|> payment_request.to_dict,
124
124
)
125
125
}
126
126
}
+84
-21
src/web/controllers/payment_controller.gleam
+84
-21
src/web/controllers/payment_controller.gleam
···
1
1
import birl
2
+
import gleam/bool
2
3
import gleam/dict
3
4
import gleam/dynamic
4
5
import gleam/dynamic/decode
···
6
7
import gleam/json
7
8
import gleam/list
8
9
import gleam/option
10
+
import gleam/order
9
11
import gleam/string_tree
10
-
import model.{type PaymentRequest, PaymentRequest}
12
+
import models/count_provider
13
+
import models/payment_request.{type PaymentRequest, PaymentRequest}
11
14
import redis
12
15
import valkyrie/resp
13
16
import web/server
···
43
46
44
47
let data_to_insert =
45
48
body
46
-
|> model.to_json
49
+
|> payment_request.to_json
47
50
|> json.to_string
48
51
|> list.wrap
49
52
···
55
58
}
56
59
57
60
pub fn get_all_payments(
58
-
_req: wisp.Request,
61
+
req: wisp.Request,
59
62
ctx: server.Context,
60
63
) -> response.Response(wisp.Body) {
61
-
case redis.get_all_saved_data(ctx.valkye_conn) {
62
-
Ok(data) -> {
63
-
let response =
64
-
data
65
-
|> dict.values
66
-
|> list.map(fn(value) {
67
-
let assert resp.BulkString(v) = value
68
-
let assert Ok(json_data) = model.from_json_string(v)
69
-
json_data
70
-
})
71
-
|> json.array(of: model.to_json)
72
-
|> json.to_string_tree
64
+
let params =
65
+
req
66
+
|> wisp.get_query
67
+
|> list.map(fn(param) {
68
+
let #(key, value) = param
69
+
let assert Ok(v) = value |> birl.parse
70
+
71
+
#(key, v)
72
+
})
73
+
|> dict.from_list
74
+
75
+
use <- bool.guard(
76
+
when: !dict.has_key(params, "from"),
77
+
return: wisp.bad_request()
78
+
|> wisp.json_body(string_tree.from_string("Needs query params 'from'")),
79
+
)
80
+
81
+
use <- bool.guard(
82
+
when: !dict.has_key(params, "to"),
83
+
return: wisp.bad_request()
84
+
|> wisp.json_body(string_tree.from_string("Needs query params 'to'")),
85
+
)
86
+
87
+
let assert Ok(from) = dict.get(params, "from")
88
+
let assert Ok(to) = dict.get(params, "to")
89
+
90
+
let data_in_redis = case redis.get_all_saved_data(ctx.valkye_conn) {
91
+
Ok(data) ->
92
+
data
93
+
|> dict.values
94
+
|> list.filter_map(fn(value) {
95
+
let assert resp.BulkString(v) = value
96
+
let assert Ok(json_data) = payment_request.from_json_string(v)
97
+
98
+
use <- bool.guard(
99
+
when: birl.compare(json_data.requested_at, from) == order.Lt,
100
+
return: Error(Nil),
101
+
)
102
+
use <- bool.guard(
103
+
when: birl.compare(json_data.requested_at, to) == order.Gt,
104
+
return: Error(Nil),
105
+
)
73
106
74
-
wisp.ok()
75
-
|> wisp.json_body(response)
76
-
}
77
-
Error(_) ->
78
-
wisp.no_content()
79
-
|> wisp.json_body(string_tree.from_string("[]"))
107
+
Ok(json_data)
108
+
})
109
+
Error(_) -> []
80
110
}
111
+
112
+
use <- bool.guard(
113
+
when: data_in_redis == [],
114
+
return: wisp.no_content()
115
+
|> wisp.json_body(string_tree.from_string("[]")),
116
+
)
117
+
118
+
let grouped_by_provider =
119
+
data_in_redis
120
+
|> list.group(by: fn(data) {
121
+
case data {
122
+
payment_request.PaymentRequest(provider: option.Some("default"), ..) ->
123
+
"default"
124
+
_ -> "fallback"
125
+
}
126
+
})
127
+
128
+
let default_requests =
129
+
count_provider.new("default")
130
+
|> count_provider.count_provider(grouped_by_provider)
131
+
let fallback_requests =
132
+
count_provider.new("fallback")
133
+
|> count_provider.count_provider(grouped_by_provider)
134
+
135
+
wisp.ok()
136
+
|> wisp.json_body(
137
+
[
138
+
#("default", count_provider.to_json(default_requests)),
139
+
#("fallback", count_provider.to_json(fallback_requests)),
140
+
]
141
+
|> json.object
142
+
|> json.to_string_tree,
143
+
)
81
144
}
82
145
83
146
pub fn purge_payments(