wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:bulb: add documentation to the `RequestBody` type
+55
-51
+40
-38
src/app/routes/brigade/register_new_brigade.gleam
+40
-38
src/app/routes/brigade/register_new_brigade.gleam
···
8
8
import gleam/http
9
9
import gleam/json
10
10
import gleam/list
11
-
import gleam/result
11
+
import gleam/result.{try}
12
12
import gleam/time/timestamp
13
13
import group_registry
14
14
import pog
···
45
45
}
46
46
}
47
47
48
+
/// Body sent by the Client in during the request
49
+
type RequestBody {
50
+
RequestBody(
51
+
/// Id of the brigade leader
52
+
leader_id: uuid.Uuid,
53
+
/// Name of the brigade
54
+
name: String,
55
+
/// Code of the brigade's vehicle
56
+
vehicle_code: String,
57
+
/// All members meant to be assigned to the brigade
58
+
members_id: List(uuid.Uuid),
59
+
/// Brigade status
60
+
is_active: Bool,
61
+
)
62
+
}
63
+
64
+
/// Registering a new brigade can fail
65
+
type RegisterBrigadeError {
66
+
/// Uuid contain invalid format
67
+
InvalidUuid(String)
68
+
/// An error occurred while accessing the Database
69
+
DataBase(pog.QueryError)
70
+
/// Brigade not found in the Database
71
+
BrigadeNotFound
72
+
/// Error related to Authentication / Authorization
73
+
AccessError(user.AccessControlError)
74
+
}
75
+
48
76
fn body_decoder() {
49
77
let uuid_decoder = {
50
78
use maybe_uuid <- decode.then(decode.string)
···
90
118
ctx ctx: Context,
91
119
body body: RequestBody,
92
120
) -> Result(String, RegisterBrigadeError) {
93
-
use _ <- result.try(
121
+
use _ <- try(
94
122
user.check_role_authorization(
95
123
request:,
96
124
ctx:,
···
100
128
|> result.map_error(AccessError),
101
129
)
102
130
103
-
use returned <- result.try(
131
+
use returned <- try(
104
132
sql.insert_new_brigade(
105
133
ctx.db,
106
134
body.leader_id,
···
108
136
body.vehicle_code,
109
137
body.is_active,
110
138
)
111
-
|> result.map_error(DataBaseError),
139
+
|> result.map_error(DataBase),
112
140
)
113
141
114
-
use row <- result.try(
142
+
use row <- try(
115
143
list.first(returned.rows)
116
144
|> result.replace_error(BrigadeNotFound),
117
145
)
118
146
119
-
use assigned_members <- result.try(try_assign_members(
147
+
use assigned_members <- try(try_assign_members(
120
148
ctx:,
121
149
to: row.id,
122
150
assign: body.members_id,
···
143
171
) -> Result(List(uuid.Uuid), RegisterBrigadeError) {
144
172
use returned <- result.map(
145
173
sql.assign_brigade_members(ctx.db, brigade_id, members)
146
-
|> result.map_error(DataBaseError),
174
+
|> result.map_error(DataBase),
147
175
)
148
176
149
177
let assigned_members = {
···
160
188
161
189
fn handle_error(request request, err err: RegisterBrigadeError) -> wisp.Response {
162
190
case err {
163
-
BrigadeNotFound ->
164
-
wisp.not_found()
165
-
|> wisp.set_body(wisp.Text(
166
-
"O Banco de Dados não retornou informações sobre a nova equipe após a inserção",
167
-
))
168
191
InvalidUuid(user_id) ->
169
192
wisp.bad_request("Usuário possui UUID inválido: " <> user_id)
170
-
DataBaseError(err) -> web.handle_database_error(err)
193
+
DataBase(err) -> web.handle_database_error(err)
171
194
AccessError(err) -> user.handle_access_control_error(request, err)
172
-
FailedToRegisterMember(user_id) ->
173
-
wisp.internal_server_error()
174
-
|> wisp.set_body(wisp.Text(
175
-
"Não foi possível registrar o usuário: "
176
-
<> uuid.to_string(user_id)
177
-
<> " como membro da equipe",
178
-
))
195
+
BrigadeNotFound ->
196
+
"O Banco de Dados não retornou informações sobre a nova equipe após a inserção"
197
+
|> wisp.Text
198
+
|> wisp.set_body(wisp.not_found(), _)
179
199
}
180
200
}
181
-
182
-
type RequestBody {
183
-
RequestBody(
184
-
leader_id: uuid.Uuid,
185
-
name: String,
186
-
vehicle_code: String,
187
-
members_id: List(uuid.Uuid),
188
-
is_active: Bool,
189
-
)
190
-
}
191
-
192
-
type RegisterBrigadeError {
193
-
InvalidUuid(String)
194
-
DataBaseError(pog.QueryError)
195
-
BrigadeNotFound
196
-
AccessError(user.AccessControlError)
197
-
FailedToRegisterMember(uuid.Uuid)
198
-
}
+15
-13
src/app/routes/brigade/sql.gleam
+15
-13
src/app/routes/brigade/sql.gleam
···
41
41
"
42
42
|> pog.query
43
43
|> pog.parameter(pog.text(uuid.to_string(arg_1)))
44
-
|> pog.parameter(
45
-
pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
46
-
)
44
+
|> pog.parameter(pog.array(
45
+
fn(value) { pog.text(uuid.to_string(value)) },
46
+
arg_2,
47
+
))
47
48
|> pog.returning(decoder)
48
49
|> pog.execute(db)
49
50
}
···
189
190
|> pog.execute(db)
190
191
}
191
192
192
-
/// A row you get from running the `query_brigade_by_id` query
193
-
/// defined in `./src/app/routes/brigade/sql/query_brigade_by_id.sql`.
193
+
/// A row you get from running the `query_brigade_info` query
194
+
/// defined in `./src/app/routes/brigade/sql/query_brigade_info.sql`.
194
195
///
195
196
/// > 🐿️ This type definition was generated automatically using v4.5.0 of the
196
197
/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
197
198
///
198
-
pub type QueryBrigadeByIdRow {
199
-
QueryBrigadeByIdRow(
199
+
pub type QueryBrigadeInfoRow {
200
+
QueryBrigadeInfoRow(
200
201
id: Uuid,
201
202
brigade_name: String,
202
203
leader_name: Uuid,
···
209
210
/// > 🐿️ This function was generated automatically using v4.5.0 of
210
211
/// > the [squirrel package](https://github.com/giacomocavalieri/squirrel).
211
212
///
212
-
pub fn query_brigade_by_id(
213
+
pub fn query_brigade_info(
213
214
db: pog.Connection,
214
215
arg_1: Uuid,
215
-
) -> Result(pog.Returned(QueryBrigadeByIdRow), pog.QueryError) {
216
+
) -> Result(pog.Returned(QueryBrigadeInfoRow), pog.QueryError) {
216
217
let decoder = {
217
218
use id <- decode.field(0, uuid_decoder())
218
219
use brigade_name <- decode.field(1, decode.string)
219
220
use leader_name <- decode.field(2, uuid_decoder())
220
221
use is_active <- decode.field(3, decode.bool)
221
-
decode.success(QueryBrigadeByIdRow(
222
+
decode.success(QueryBrigadeInfoRow(
222
223
id:,
223
224
brigade_name:,
224
225
leader_name:,
···
353
354
"
354
355
|> pog.query
355
356
|> pog.parameter(pog.text(uuid.to_string(arg_1)))
356
-
|> pog.parameter(
357
-
pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
358
-
)
357
+
|> pog.parameter(pog.array(
358
+
fn(value) { pog.text(uuid.to_string(value)) },
359
+
arg_2,
360
+
))
359
361
|> pog.returning(decoder)
360
362
|> pog.execute(db)
361
363
}
src/app/routes/brigade/sql/query_brigade_by_id.sql
src/app/routes/brigade/sql/query_brigade_info.sql
src/app/routes/brigade/sql/query_brigade_by_id.sql
src/app/routes/brigade/sql/query_brigade_info.sql