kacaii.dev
wip: currently rewriting the project as a full stack application
tangled.org/kacaii.dev/sigo
gleam
:truck: rename `AccessError` error to `AccessControl`
+40
-29
+19
-8
src/app/domain/admin/admin_update_user.gleam
+19
-8
src/app/domain/admin/admin_update_user.gleam
···
61
61
/// User has invalid Uuid format
62
62
InvalidUuid(String)
63
63
/// Authentication / Authorization failed
64
-
AccessError(user.AccessControlError)
64
+
AccessControl(user.AccessControlError)
65
65
/// User not found in the DataBase
66
66
UserNotFound(uuid.Uuid)
67
67
}
···
72
72
err: AdminUpdateUserError,
73
73
) -> wisp.Response {
74
74
case err {
75
-
AccessError(err) -> user.handle_access_control_error(req, err)
75
+
AccessControl(err) -> user.handle_access_control_error(req, err)
76
76
77
77
InvalidUuid(id) -> wisp.bad_request("Usuário possui Uuid inválido: " <> id)
78
78
79
-
UserNotFound(id) ->
80
-
wisp.Text("Usuário não encontrado: " <> uuid.to_string(id))
79
+
UserNotFound(id) -> {
80
+
let body = "Usuário não encontrado: " <> uuid.to_string(id)
81
+
82
+
body
83
+
|> wisp.Text
81
84
|> wisp.set_body(wisp.not_found(), _)
85
+
}
82
86
83
87
DataBase(err) -> {
84
88
case err {
85
-
pog.ConstraintViolated(_, _, constraint: "user_account_email_key") ->
86
-
wisp.Text("Email já está sendo utilizado: " <> body.email)
89
+
pog.ConstraintViolated(_, _, constraint: "user_account_email_key") -> {
90
+
let body = "Email já está sendo utilizado: " <> body.email
91
+
92
+
body
93
+
|> wisp.Text
87
94
|> wisp.set_body(wisp.response(409), _)
95
+
}
88
96
89
97
pog.ConstraintViolated(
90
98
_,
91
99
_,
92
100
constraint: "user_account_registration_key",
93
101
) -> {
94
-
wisp.Text("Matrícula já está sendo utilizada: " <> body.registration)
102
+
let body = "Matrícula já está sendo utilizada: " <> body.registration
103
+
104
+
body
105
+
|> wisp.Text
95
106
|> wisp.set_body(wisp.response(409), _)
96
107
}
97
108
···
114
125
cookie_name: user.uuid_cookie_name,
115
126
authorized_roles: [role.Admin, role.Developer],
116
127
)
117
-
|> result.map_error(AccessError),
128
+
|> result.map_error(AccessControl),
118
129
)
119
130
120
131
use user_uuid <- result.try(
+3
-3
src/app/domain/brigade/register_new_brigade.gleam
+3
-3
src/app/domain/brigade/register_new_brigade.gleam
···
70
70
/// Brigade not found in the Database
71
71
BrigadeNotFound
72
72
/// Error related to Authentication / Authorization
73
-
AccessError(user.AccessControlError)
73
+
AccessControl(user.AccessControlError)
74
74
}
75
75
76
76
fn body_decoder() {
···
125
125
cookie_name: user.uuid_cookie_name,
126
126
authorized_roles: [role.Admin, role.Developer],
127
127
)
128
-
|> result.map_error(AccessError),
128
+
|> result.map_error(AccessControl),
129
129
)
130
130
131
131
use returned <- result.try(
···
195
195
InvalidUuid(user_id) ->
196
196
wisp.bad_request("Usuário possui UUID inválido: " <> user_id)
197
197
DataBase(err) -> web.handle_database_error(err)
198
-
AccessError(err) -> user.handle_access_control_error(request, err)
198
+
AccessControl(err) -> user.handle_access_control_error(request, err)
199
199
BrigadeNotFound ->
200
200
"O Banco de Dados não retornou informações sobre a nova equipe após a inserção"
201
201
|> wisp.Text
+3
-3
src/app/domain/user/delete_user.gleam
+3
-3
src/app/domain/user/delete_user.gleam
···
39
39
/// Target user has invalid Uuid
40
40
InvalidUserUuid(String)
41
41
/// Errors related to authentication and authorization
42
-
AccessError(user.AccessControlError)
42
+
AccessControl(user.AccessControlError)
43
43
/// User was not found in the Database
44
44
UserNotFound(uuid.Uuid)
45
45
/// An user should not be able to delete theirself
···
52
52
wisp.bad_request("Usuário possui Uuid Inválido: " <> invalid_uuid)
53
53
UserNotFound(user_uuid) ->
54
54
wisp.bad_request("Usuário não encontrado: " <> uuid.to_string(user_uuid))
55
-
AccessError(err) -> user.handle_access_control_error(req, err)
55
+
AccessControl(err) -> user.handle_access_control_error(req, err)
56
56
DataBase(err) -> web.handle_database_error(err)
57
57
CantDeleteSelf -> wisp.bad_request("Um usuário não deve remover a si mesmo")
58
58
}
···
76
76
cookie_name: user.uuid_cookie_name,
77
77
authorized_roles: [role.Admin, role.Developer],
78
78
)
79
-
|> result.map_error(AccessError),
79
+
|> result.map_error(AccessControl),
80
80
)
81
81
82
82
// Check if the authenticated user is trying to delete theirself
+3
-3
src/app/domain/user/get_all_user_profiles.gleam
+3
-3
src/app/domain/user/get_all_user_profiles.gleam
···
50
50
/// Gathering the user list can fail
51
51
type GetAllUsersError {
52
52
/// Errors related to user authentication / authorization
53
-
AccessError(user.AccessControlError)
53
+
AccessControl(user.AccessControlError)
54
54
/// An error occurred while querying the DataBase
55
55
DataBase(pog.QueryError)
56
56
}
57
57
58
58
fn handle_error(req: wisp.Request, err: GetAllUsersError) -> wisp.Response {
59
59
case err {
60
-
AccessError(err) -> user.handle_access_control_error(req, err)
60
+
AccessControl(err) -> user.handle_access_control_error(req, err)
61
61
DataBase(err) -> web.handle_database_error(err)
62
62
}
63
63
}
···
73
73
cookie_name: user.uuid_cookie_name,
74
74
authorized_roles: [role.Admin, role.Developer],
75
75
)
76
-
|> result.map_error(AccessError),
76
+
|> result.map_error(AccessControl),
77
77
)
78
78
79
79
use returned <- result.try(
+3
-3
src/app/domain/user/signup.gleam
+3
-3
src/app/domain/user/signup.gleam
···
69
69
cookie_name: user.uuid_cookie_name,
70
70
authorized_roles: [role.Admin, role.Developer],
71
71
)
72
-
|> result.map_error(AccessError),
72
+
|> result.map_error(AccessControl),
73
73
)
74
74
75
75
use hashed_password <- result.try(
···
205
205
DataBase(err) -> handle_database_error(err)
206
206
InvalidRole(unknown) ->
207
207
wisp.bad_request("O novo usuário possui um cargo inválido: " <> unknown)
208
-
AccessError(err) -> user.handle_access_control_error(req, err)
208
+
AccessControl(err) -> user.handle_access_control_error(req, err)
209
209
MissingSignupConfirmation ->
210
210
wisp.internal_server_error()
211
211
|> wisp.set_body(wisp.Text(
···
223
223
/// Unknown user role
224
224
InvalidRole(String)
225
225
/// User / Role related issues
226
-
AccessError(user.AccessControlError)
226
+
AccessControl(user.AccessControlError)
227
227
/// Database didnt return information about the new user
228
228
MissingSignupConfirmation
229
229
}
+3
-3
src/app/domain/user/update_user_password.gleam
+3
-3
src/app/domain/user/update_user_password.gleam
···
61
61
62
62
fn handle_error(err: UpdatePasswordError) -> wisp.Response {
63
63
case err {
64
-
AccessError(err) -> user.handle_authentication_error(err)
64
+
AccessControl(err) -> user.handle_authentication_error(err)
65
65
UserNotFound(id) -> {
66
66
let body = "Usuário não encontrado: " <> uuid.to_string(id)
67
67
···
92
92
) -> Result(Nil, UpdatePasswordError) {
93
93
use user_uuid <- result.try(
94
94
user.extract_uuid(request:, cookie_name: user.uuid_cookie_name)
95
-
|> result.map_error(AccessError),
95
+
|> result.map_error(AccessControl),
96
96
)
97
97
98
98
// Fetch the password hash from the DataBase
···
189
189
/// Updating an user's password can fail
190
190
type UpdatePasswordError {
191
191
/// Authentication failed
192
-
AccessError(user.AuthenticationError)
192
+
AccessControl(user.AuthenticationError)
193
193
/// User was not found in the database
194
194
UserNotFound(uuid.Uuid)
195
195
/// Failed to access the DataBase
+3
-3
src/app/domain/user/update_user_profile.gleam
+3
-3
src/app/domain/user/update_user_profile.gleam
···
49
49
50
50
fn handle_error(err: UpdateProfileError) -> wisp.Response {
51
51
case err {
52
-
AccessError(err) -> user.handle_authentication_error(err)
52
+
AccessControl(err) -> user.handle_authentication_error(err)
53
53
UserNotFound(user_uuid) -> {
54
54
let resp = wisp.not_found()
55
55
let body =
···
91
91
) -> Result(String, UpdateProfileError) {
92
92
use maybe_id <- result.try(
93
93
user.extract_uuid(req, user.uuid_cookie_name)
94
-
|> result.map_error(AccessError),
94
+
|> result.map_error(AccessControl),
95
95
)
96
96
97
97
use returned <- result.try(
···
122
122
/// Updating an user profile can fail
123
123
type UpdateProfileError {
124
124
/// Authentication failed
125
-
AccessError(user.AuthenticationError)
125
+
AccessControl(user.AuthenticationError)
126
126
/// An error occurred when accessing the DataBase
127
127
DatabaseError(pog.QueryError)
128
128
/// User was not found in the DataBase
+3
-3
src/app/domain/user/update_user_status.gleam
+3
-3
src/app/domain/user/update_user_status.gleam
···
44
44
/// Updating an user status can fail
45
45
type UpdateUserStatusError {
46
46
/// Error related to authentication / authorization
47
-
AccessError(user.AccessControlError)
47
+
AccessControl(user.AccessControlError)
48
48
/// User not found in the DataBase
49
49
UserNotFound(String)
50
50
/// UUID is not valid
···
66
66
cookie_name: user.uuid_cookie_name,
67
67
authorized_roles: [role.Admin, role.Developer],
68
68
)
69
-
|> result.map_error(AccessError),
69
+
|> result.map_error(AccessControl),
70
70
)
71
71
72
72
use user_uuid <- result.try(
···
93
93
94
94
fn handle_error(req: wisp.Request, err: UpdateUserStatusError) -> wisp.Response {
95
95
case err {
96
-
AccessError(err) -> user.handle_access_control_error(req, err)
96
+
AccessControl(err) -> user.handle_access_control_error(req, err)
97
97
DataBase(err) -> web.handle_database_error(err)
98
98
InvalidUuid(user_id) ->
99
99
wisp.response(401)