:recycle: no need to pattern match on the http method

dev/dummy.gleam

···
       row.id
     }
     True -> {
-      let assert Ok(returned) = o_sql.resolve_occurrence(ctx.db, occ)
+      let assert Ok(returned) = o_sql.close_occurrence(ctx.db, occ)
       let assert Ok(row) = list.first(returned.rows)
       row.id
     }

src/app/domain/brigade/get_brigade_members.gleam

···
 ///    }
 /// ]
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
   id brigade_id: String,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Get)
+  use <- wisp.require_method(req, http.Get)
 
   case query_brigade_members(ctx, brigade_id) {
     Ok(body) -> wisp.json_response(body, 200)

src/app/domain/brigade/sql.gleam

···
 "
   |> pog.query
   |> pog.parameter(pog.text(uuid.to_string(arg_1)))
-  |> pog.parameter(pog.array(
-    fn(value) { pog.text(uuid.to_string(value)) },
-    arg_2,
-  ))
+  |> pog.parameter(
+    pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
+  )
   |> pog.returning(decoder)
   |> pog.execute(db)
 }
···
 "
   |> pog.query
   |> pog.parameter(pog.text(uuid.to_string(arg_1)))
-  |> pog.parameter(pog.array(
-    fn(value) { pog.text(uuid.to_string(value)) },
-    arg_2,
-  ))
+  |> pog.parameter(
+    pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
+  )
   |> pog.returning(decoder)
   |> pog.execute(db)
 }

src/app/domain/dashboard.gleam

···
 /// }
 /// ```
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Get)
+  use <- wisp.require_method(req, http.Get)
 
   case query_dashboard_stats(ctx) {
     Ok(body) -> wisp.json_response(body, 200)

src/app/domain/data_analysis/sql.gleam

···
     "medic_emergency" -> decode.success(MedicEmergency)
     _ -> decode.failure(Other, "OccurrenceCategoryEnum")
   }
-}
-
-/// Corresponds to the Postgres `occurrence_priority_enum` enum.
+}/// Corresponds to the Postgres `occurrence_priority_enum` enum.
 ///
 /// > 🐿️ This type definition was generated automatically using v4.6.0 of the
 /// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
···
     "low" -> decode.success(Low)
     _ -> decode.failure(High, "OccurrencePriorityEnum")
   }
-}
-
-/// Corresponds to the Postgres `occurrence_subcategory_enum` enum.
+}/// Corresponds to the Postgres `occurrence_subcategory_enum` enum.
 ///
 /// > 🐿️ This type definition was generated automatically using v4.6.0 of the
 /// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
···
   HeartStop
 }
 
-fn occurrence_subcategory_enum_decoder() -> decode.Decoder(
-  OccurrenceSubcategoryEnum,
-) {
+fn occurrence_subcategory_enum_decoder() -> decode.Decoder(OccurrenceSubcategoryEnum) {
   use occurrence_subcategory_enum <- decode.then(decode.string)
   case occurrence_subcategory_enum {
     "injured_animal" -> decode.success(InjuredAnimal)
···
     "heart_stop" -> decode.success(HeartStop)
     _ -> decode.failure(InjuredAnimal, "OccurrenceSubcategoryEnum")
   }
-}
-
-/// Corresponds to the Postgres `user_role_enum` enum.
+}/// Corresponds to the Postgres `user_role_enum` enum.
 ///
 /// > 🐿️ This type definition was generated automatically using v4.6.0 of the
 /// > [squirrel package](https://github.com/giacomocavalieri/squirrel).

src/app/domain/occurrence/close_occurrence.gleam

···
+import app/domain/occurrence
+import app/domain/occurrence/sql
+import app/domain/user
+import app/web
+import app/web/context.{type Context}
+import app/web/socket/message as msg
+import gleam/http
+import gleam/json
+import gleam/list
+import gleam/result
+import gleam/time/timestamp
+import group_registry
+import pog
+import wisp
+import youid/uuid
+
+/// Resolving a occurence can fail
+type ResolveOccurrenceError {
+  /// Occurrence has invalid Uuid format
+  InvalidUuid(String)
+  /// Occurrence was not found in the DataBase
+  OccurrenceNotFound(uuid.Uuid)
+  /// An error occurred whe naccessing the DataBase
+  DataBase(pog.QueryError)
+  /// Errors related to authentication / authorization
+  AccessControl(user.AuthenticationError)
+}
+
+/// 󰚰  Updates the `resolved_at` field of a occurrence
+///
+/// ```jsonc
+/// {
+///   "id": "a32fb57f-b547-434d-a5d6-2a2c96cddb20",
+///   "resolved_at": 1762889998.0, // or null
+///   "updated_at": 1762889998.0
+/// }
+/// ````
+pub fn handle_request(
+  request req: wisp.Request,
+  ctx ctx: Context,
+  id occurrence_id: String,
+) -> wisp.Response {
+  use <- wisp.require_method(req, http.Post)
+
+  case close_occurrence(req, ctx, occurrence_id) {
+    Error(err) -> handle_error(err)
+    Ok(body) -> wisp.json_response(body, 200)
+  }
+}
+
+fn close_occurrence(
+  req: wisp.Request,
+  ctx: Context,
+  occ_id: String,
+) -> Result(String, ResolveOccurrenceError) {
+  use _ <- result.try(
+    user.extract_uuid(request: req, cookie_name: user.uuid_cookie_name)
+    |> result.map_error(AccessControl),
+  )
+
+  use target <- result.try(
+    uuid.from_string(occ_id)
+    |> result.replace_error(InvalidUuid(occ_id)),
+  )
+
+  use returned <- result.try(
+    sql.close_occurrence(ctx.db, target)
+    |> result.map_error(DataBase),
+  )
+
+  use row <- result.map(
+    list.first(returned.rows)
+    |> result.replace_error(OccurrenceNotFound(target)),
+  )
+
+  //   Broadcast to all assigned users ----------------------------------------
+  let _ =
+    occurrence.broadcast(
+      ctx:,
+      registry: group_registry.get_registry(ctx.registry_name),
+      occurrence: row.id,
+      message: msg.Domain(msg.OccurrenceResolved(
+        id: row.id,
+        when: row.resolved_at,
+      )),
+    )
+
+  // RESPONSE
+  let timestamp_json =
+    json.nullable(row.resolved_at, fn(time) {
+      timestamp.to_unix_seconds(time) |> json.float
+    })
+
+  json.to_string(
+    json.object([
+      #("id", json.string(uuid.to_string(row.id))),
+      #("resolved_at", timestamp_json),
+      #("updated_at", json.float(timestamp.to_unix_seconds(row.updated_at))),
+    ]),
+  )
+}
+
+fn handle_error(err: ResolveOccurrenceError) -> wisp.Response {
+  case err {
+    AccessControl(err) -> user.handle_authentication_error(err)
+    DataBase(err) -> web.handle_database_error(err)
+    InvalidUuid(id) ->
+      wisp.bad_request("Ocorrência possui Uuid inválido: " <> id)
+    OccurrenceNotFound(occ_id) ->
+      wisp.Text("Ocorrência não encontrada: " <> uuid.to_string(occ_id))
+      |> wisp.set_body(wisp.not_found(), _)
+  }
+}

src/app/domain/occurrence/get_ocurrences_by_applicant.gleam

···
 /// 󰡦  Find all occurrences/applications associated with a specific user
 /// returns them as formatted JSON data
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
   id user_id: String,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Get)
+  use <- wisp.require_method(req, http.Get)
 
   case query_occurrences(ctx, user_id) {
     Ok(resp) -> wisp.json_response(resp, 200)

src/app/domain/occurrence/register_new_occurrence.gleam

···
 /// }
 /// ```
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Post)
-  use body <- wisp.require_json(request)
+  use <- wisp.require_method(req, http.Post)
+  use body <- wisp.require_json(req)
 
   case decode.run(body, body_decoder()) {
     Error(err) -> web.handle_decode_error(err)
-    Ok(body) -> handle_body(request:, ctx:, body:)
+    Ok(body) -> handle_body(request: req, ctx:, body:)
   }
 }
 

src/app/domain/occurrence/sql.gleam

···
 "
   |> pog.query
   |> pog.parameter(pog.text(uuid.to_string(arg_1)))
-  |> pog.parameter(pog.array(
-    fn(value) { pog.text(uuid.to_string(value)) },
-    arg_2,
-  ))
+  |> pog.parameter(
+    pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
+  )
+  |> pog.returning(decoder)
+  |> pog.execute(db)
+}
+
+/// A row you get from running the `close_occurrence` query
+/// defined in `./src/app/domain/occurrence/sql/close_occurrence.sql`.
+///
+/// > 🐿️ This type definition was generated automatically using v4.6.0 of the
+/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
+///
+pub type CloseOccurrenceRow {
+  CloseOccurrenceRow(
+    id: Uuid,
+    resolved_at: Option(Timestamp),
+    updated_at: Timestamp,
+  )
+}
+
+/// 󰚰  Mark a occurrence as resolved
+///
+/// > 🐿️ This function was generated automatically using v4.6.0 of
+/// > the [squirrel package](https://github.com/giacomocavalieri/squirrel).
+///
+pub fn close_occurrence(
+  db: pog.Connection,
+  arg_1: Uuid,
+) -> Result(pog.Returned(CloseOccurrenceRow), pog.QueryError) {
+  let decoder = {
+    use id <- decode.field(0, uuid_decoder())
+    use resolved_at <- decode.field(1, decode.optional(pog.timestamp_decoder()))
+    use updated_at <- decode.field(2, pog.timestamp_decoder())
+    decode.success(CloseOccurrenceRow(id:, resolved_at:, updated_at:))
+  }
+
+  "-- 󰚰  Mark a occurrence as resolved
+update public.occurrence
+set
+    resolved_at = current_timestamp,
+    updated_at = current_timestamp
+where id = $1
+returning
+    id,
+    resolved_at,
+    updated_at;
+"
+  |> pog.query
+  |> pog.parameter(pog.text(uuid.to_string(arg_1)))
   |> pog.returning(decoder)
   |> pog.execute(db)
 }
···
 "
   |> pog.query
   |> pog.parameter(pog.text(uuid.to_string(arg_1)))
-  |> pog.parameter(pog.array(
-    fn(value) { pog.text(uuid.to_string(value)) },
-    arg_2,
-  ))
-  |> pog.returning(decoder)
-  |> pog.execute(db)
-}
-
-/// A row you get from running the `resolve_occurrence` query
-/// defined in `./src/app/domain/occurrence/sql/resolve_occurrence.sql`.
-///
-/// > 🐿️ This type definition was generated automatically using v4.6.0 of the
-/// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
-///
-pub type ResolveOccurrenceRow {
-  ResolveOccurrenceRow(
-    id: Uuid,
-    resolved_at: Option(Timestamp),
-    updated_at: Timestamp,
+  |> pog.parameter(
+    pog.array(fn(value) { pog.text(uuid.to_string(value)) }, arg_2),
   )
-}
-
-/// 󰚰  Mark a occurrence as resolved
-///
-/// > 🐿️ This function was generated automatically using v4.6.0 of
-/// > the [squirrel package](https://github.com/giacomocavalieri/squirrel).
-///
-pub fn resolve_occurrence(
-  db: pog.Connection,
-  arg_1: Uuid,
-) -> Result(pog.Returned(ResolveOccurrenceRow), pog.QueryError) {
-  let decoder = {
-    use id <- decode.field(0, uuid_decoder())
-    use resolved_at <- decode.field(1, decode.optional(pog.timestamp_decoder()))
-    use updated_at <- decode.field(2, pog.timestamp_decoder())
-    decode.success(ResolveOccurrenceRow(id:, resolved_at:, updated_at:))
-  }
-
-  "-- 󰚰  Mark a occurrence as resolved
-update public.occurrence
-set
-    resolved_at = current_timestamp,
-    updated_at = current_timestamp
-where id = $1
-returning
-    id,
-    resolved_at,
-    updated_at;
-"
-  |> pog.query
-  |> pog.parameter(pog.text(uuid.to_string(arg_1)))
   |> pog.returning(decoder)
   |> pog.execute(db)
 }
···
     MedicEmergency -> "medic_emergency"
   }
   |> pog.text
-}
-
-/// Corresponds to the Postgres `occurrence_priority_enum` enum.
+}/// Corresponds to the Postgres `occurrence_priority_enum` enum.
 ///
 /// > 🐿️ This type definition was generated automatically using v4.6.0 of the
 /// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
···
     Low -> "low"
   }
   |> pog.text
-}
-
-/// Corresponds to the Postgres `occurrence_subcategory_enum` enum.
+}/// Corresponds to the Postgres `occurrence_subcategory_enum` enum.
 ///
 /// > 🐿️ This type definition was generated automatically using v4.6.0 of the
 /// > [squirrel package](https://github.com/giacomocavalieri/squirrel).
···
   HeartStop
 }
 
-fn occurrence_subcategory_enum_decoder() -> decode.Decoder(
-  OccurrenceSubcategoryEnum,
-) {
+fn occurrence_subcategory_enum_decoder() -> decode.Decoder(OccurrenceSubcategoryEnum) {
   use occurrence_subcategory_enum <- decode.then(decode.string)
   case occurrence_subcategory_enum {
     "injured_animal" -> decode.success(InjuredAnimal)
···
   }
 }
 
-fn occurrence_subcategory_enum_encoder(occurrence_subcategory_enum) -> pog.Value {
+fn occurrence_subcategory_enum_encoder(
+  occurrence_subcategory_enum,
+) -> pog.Value {
   case occurrence_subcategory_enum {
     InjuredAnimal -> "injured_animal"
     Flood -> "flood"

src/app/domain/occurrence/update_occurrence_status.gleam src/app/domain/occurrence/reopen_occurrence.gleam

···
   ctx ctx: Context,
   id occurrence_id: String,
 ) -> wisp.Response {
-  case req.method {
-    // Mark an occurrence as resolved
-    http.Post ->
-      case resolve_occurrence(req, ctx, occurrence_id) {
-        Error(err) -> handle_error(err)
-        Ok(body) -> wisp.json_response(body, 200)
-      }
-
-    // Reopen a resolved occurrence
-    http.Delete ->
-      case reopen_occurrence(req, ctx, occurrence_id) {
-        Error(err) -> handle_error(err)
-        Ok(body) -> wisp.json_response(body, 200)
-      }
+  use <- wisp.require_method(req, http.Post)
 
-    _ -> wisp.method_not_allowed([http.Post, http.Delete])
+  case reopen_occurrence(req, ctx, occurrence_id) {
+    Error(err) -> handle_error(err)
+    Ok(body) -> wisp.json_response(body, 200)
   }
-}
-
-fn resolve_occurrence(
-  req: wisp.Request,
-  ctx: Context,
-  occ_id: String,
-) -> Result(String, ResolveOccurrenceError) {
-  use _ <- result.try(
-    user.extract_uuid(request: req, cookie_name: user.uuid_cookie_name)
-    |> result.map_error(AccessControl),
-  )
-
-  use target <- result.try(
-    uuid.from_string(occ_id)
-    |> result.replace_error(InvalidUuid(occ_id)),
-  )
-
-  use returned <- result.try(
-    sql.resolve_occurrence(ctx.db, target)
-    |> result.map_error(DataBase),
-  )
-
-  use row <- result.map(
-    list.first(returned.rows)
-    |> result.replace_error(OccurrenceNotFound(target)),
-  )
-
-  //   Broadcast to all assigned users ----------------------------------------
-  let _ =
-    occurrence.broadcast(
-      ctx:,
-      registry: group_registry.get_registry(ctx.registry_name),
-      occurrence: row.id,
-      message: msg.Domain(msg.OccurrenceResolved(
-        id: row.id,
-        when: row.resolved_at,
-      )),
-    )
-
-  // RESPONSE
-  let timestamp_json =
-    json.nullable(row.resolved_at, fn(time) {
-      timestamp.to_unix_seconds(time) |> json.float
-    })
-
-  json.to_string(
-    json.object([
-      #("id", json.string(uuid.to_string(row.id))),
-      #("resolved_at", timestamp_json),
-      #("updated_at", json.float(timestamp.to_unix_seconds(row.updated_at))),
-    ]),
-  )
 }
 
 fn reopen_occurrence(

src/app/domain/role/get_role_list.gleam

···
 /// ```
 ///
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Get)
+  use <- wisp.require_method(req, http.Get)
 
   case query_user_roles(ctx) {
     Ok(body) -> wisp.json_response(body, 200)

src/app/domain/user/get_user_profile.gleam

···
 /// }
 /// ```
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Get)
+  use <- wisp.require_method(req, http.Get)
 
   // 󰡦  Query the database
-  case query_user_data(ctx, request) {
+  case query_user_data(ctx, req) {
     //   Handle possible errors
     Error(err) -> handle_error(err)
     // 󱃜  Send the response to the client

src/app/domain/user/login.gleam

···
 import argus
 import formal/form
 import gleam/float
+import gleam/http
 import gleam/http/response
 import gleam/json
 import gleam/list
···
 /// ```sh
 /// set-cookie: USER_ID=0199b58a-acb0-70a8-9de7-0b65a03b8743
 /// ```
-pub fn handle_request(request request: wisp.Request, ctx ctx: Context) {
-  use form_data <- wisp.require_form(request)
+pub fn handle_request(request req: wisp.Request, ctx ctx: Context) {
+  use <- wisp.require_method(req, http.Post)
+
+  use form_data <- wisp.require_form(req)
   let form_result =
     login_form()
     |> form.add_values(form_data.values)
···
     Error(_) -> wisp.unprocessable_content()
     Ok(data) -> {
       let cookie = user.uuid_cookie_name
-      handle_login(request, ctx, data, cookie)
+      handle_login(req, ctx, data, cookie)
     }
   }
 }
 
 fn handle_login(
-  request: wisp.Request,
+  req: wisp.Request,
   ctx: Context,
   data: RequestBody,
   name: String,
 ) -> response.Response(wisp.Body) {
   case query_database(data, ctx) {
     Error(err) -> handle_error(err)
-    Ok(resp) -> set_token(resp, request, name)
+    Ok(resp) -> set_token(resp, req, name)
   }
 }
 
-fn set_token(
-  resp: LoginToken,
-  request: wisp.Request,
-  name: String,
-) -> wisp.Response {
+fn set_token(resp: LoginToken, req: wisp.Request, name: String) -> wisp.Response {
   let response = wisp.json_response(resp.body, 200)
   let value = uuid.to_string(resp.user_id)
   let security = wisp.Signed
···
     |> duration.to_seconds
     |> float.round
 
-  wisp.set_cookie(response:, request:, name:, value:, security:, max_age:)
+  wisp.set_cookie(response:, request: req, name:, value:, security:, max_age:)
 }
 
 /// 󱐁  A form that decodes the `LogIn` value.

src/app/domain/user/signup.gleam

···
 import app/web/context.{type Context}
 import argus
 import formal/form
+import gleam/http
 import gleam/json
 import gleam/list
 import gleam/result
···
   request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
+  use <- wisp.require_method(req, http.Post)
   use form_data <- wisp.require_form(req)
   let form_result =
     signup_form()

src/app/domain/user/update_user_password.gleam

···
 ///
 ///   Extracts the user UUID form the request's Cookies
 pub fn handle_request(
-  request request: wisp.Request,
+  request req: wisp.Request,
   ctx ctx: Context,
 ) -> wisp.Response {
-  use <- wisp.require_method(request, http.Put)
-  use form_data <- wisp.require_form(request)
+  use <- wisp.require_method(req, http.Put)
+  use form_data <- wisp.require_form(req)
   let form_result =
     update_password_form()
     |> form.add_values(form_data.values)
     |> form.run()
 
   case form_result {
-    Ok(form_data) -> handle_form_data(request:, ctx:, form_data:)
+    Ok(form_data) -> handle_form_data(request: req, ctx:, form_data:)
     Error(_) -> {
       let resp = wisp.unprocessable_content()
 

src/app/http_router.gleam

···
 import app/domain/data_analysis/analysis_occurrence_volume
 import app/domain/notification/get_notification_preferences
 import app/domain/notification/update_notification_preferences
+import app/domain/occurrence/close_occurrence
 import app/domain/occurrence/delete_occurrence
 import app/domain/occurrence/get_ocurrences_by_applicant
 import app/domain/occurrence/register_new_occurrence
-import app/domain/occurrence/update_occurrence_status
+import app/domain/occurrence/reopen_occurrence
 import app/domain/role/get_role_list
 import app/domain/user/delete_user
 import app/domain/user/get_all_user_profiles
···
 import app/domain/user/update_user_status
 import app/web
 import app/web/context.{type Context}
-import gleam/http
 import wisp
 
 /// 󱂇  Main request router - matches HTTP methods and paths to appropriate handlers
···
   ctx ctx: Context,
 ) -> wisp.Response {
   use request <- web.middleware(request:, context: ctx)
-  case request.method, wisp.path_segments(request) {
+  case wisp.path_segments(request) {
     //   Security routes -------------------------------------------------
-    http.Post, ["user", "login"] -> login.handle_request(request:, ctx:)
+    ["user", "login"] -> login.handle_request(request:, ctx:)
 
-    http.Put, ["user", "password"] ->
-      update_user_password.handle_request(request:, ctx:)
+    ["user", "password"] -> update_user_password.handle_request(request:, ctx:)
 
     //   Admin routes ---------------------------------------------------------
-    http.Post, ["admin", "setup"] ->
-      setup_first_admin.handle_request(request:, ctx:)
+    ["admin", "setup"] -> setup_first_admin.handle_request(request:, ctx:)
 
-    http.Post, ["admin", "signup"] -> signup.handle_request(request:, ctx:)
+    ["admin", "signup"] -> signup.handle_request(request:, ctx:)
 
-    http.Get, ["admin", "users"] ->
-      get_all_user_profiles.handle_request(request:, ctx:)
+    ["admin", "users"] -> get_all_user_profiles.handle_request(request:, ctx:)
 
-    http.Put, ["admin", "users", id] ->
+    ["admin", "users", id, "update"] ->
       admin_update_user.handle_request(request:, ctx:, id:)
 
-    http.Delete, ["admin", "users", id] ->
+    ["admin", "users", id, "delete"] ->
       delete_user.handle_request(request:, ctx:, id:)
 
-    http.Put, ["admin", "users", id, "status"] ->
+    ["admin", "users", id, "status"] ->
       update_user_status.handle_request(request:, ctx:, id:)
 
-    http.Get, ["admin", "teams"] ->
-      get_all_brigades.handle_request(request:, ctx:)
+    ["admin", "brigade"] -> get_all_brigades.handle_request(request:, ctx:)
 
-    http.Post, ["admin", "teams"] ->
+    ["admin", "brigade", "new"] ->
       register_new_brigade.handle_request(request:, ctx:)
 
-    http.Put, ["admin", "teams", id, "status"] ->
+    ["admin", "brigade", id, "status"] ->
       update_brigade_status.handle_request(request:, ctx:, id:)
 
-    http.Delete, ["admin", "teams", id] ->
+    ["admin", "brigade", id] ->
       delete_brigade.handle_request(request:, ctx:, id:)
 
     // 󰨇  Dashboard stats ------------------------------------------------------
-    http.Get, ["dashboard", "stats"] -> dashboard.handle_request(request:, ctx:)
+    ["dashboard", "stats"] -> dashboard.handle_request(request:, ctx:)
 
     // 󰕮  Data analysis routes
-    http.Get, ["analysis", "occurrence"] ->
+    ["analysis", "occurrence"] ->
       analysis_occurrence_volume.handle_request(request:, ctx:)
 
     //   User data routes -----------------------------------------------------
-    http.Get, ["user", id, "occurrences"] ->
+    ["user", id, "occurrences"] ->
       get_ocurrences_by_applicant.handle_request(request:, ctx:, id:)
 
-    http.Get, ["user", "profile"] ->
-      get_user_profile.handle_request(request:, ctx:)
+    ["user", "profile"] -> get_user_profile.handle_request(request:, ctx:)
 
-    http.Put, ["user", "profile"] ->
+    ["user", "profile", "update"] ->
       update_user_profile.handle_request(request:, ctx:)
 
-    http.Get, ["user", id, "crew_members"] ->
+    ["user", id, "crew_members"] ->
       get_crew_members.handle_request(request:, ctx:, id:)
 
     //   Notification routes --------------------------------------------------
-    http.Get, ["user", "notification_preferences"] ->
+    ["user", "notification_preferences"] ->
       get_notification_preferences.handle_request(request:, ctx:)
 
-    http.Put, ["user", "notification_preferences"] ->
+    ["user", "notification_preferences", "update"] ->
       update_notification_preferences.handle_request(request:, ctx:)
 
     // 󰞏  Occurrence routes ----------------------------------------------------
-    http.Post, ["occurrence", "new"] ->
+    ["occurrence", "new"] ->
       register_new_occurrence.handle_request(request:, ctx:)
 
-    http.Delete, ["occurrence", id] ->
-      delete_occurrence.handle_request(request:, ctx:, id:)
+    ["occurrence", id] -> delete_occurrence.handle_request(request:, ctx:, id:)
 
-    http.Post, ["occurrence", "resolved_at", id]
-    | http.Delete, ["occurrence", "resolved_at", id]
-    -> update_occurrence_status.handle_request(request:, ctx:, id:)
+    ["occurrence", "close", id] ->
+      close_occurrence.handle_request(request:, ctx:, id:)
+
+    ["occurrence", "reopen", id] ->
+      reopen_occurrence.handle_request(request:, ctx:, id:)
 
     // 󰢫  Brigade routes -------------------------------------------------------
-    http.Get, ["brigade", id, "members"] ->
+    ["brigade", id, "members"] ->
       get_brigade_members.handle_request(request:, ctx:, id:)
 
     //   Role routes ----------------------------------------------------------
-    http.Get, ["user", "roles"] -> get_role_list.handle_request(request:, ctx:)
+    ["user", "roles"] -> get_role_list.handle_request(request:, ctx:)
 
     // Fallback routes ---------------------------------------------------------
-    _, [] -> wisp.ok() |> wisp.html_body("<h2>🌠</h2>")
-    _, _ -> wisp.not_found()
+    [] -> wisp.ok() |> wisp.html_body("<h2>🌠</h2>")
+    _ -> wisp.not_found()
   }
 }

test/admin_test.gleam

···
 
   // DUMMY USER ----------------------------------------------------------------
   let dummy_user_id = dummy.random_user(ctx.db)
-  let path = "/admin/users/" <> uuid.to_string(dummy_user_id)
+  let path = "/admin/users/" <> uuid.to_string(dummy_user_id) <> "/update"
 
   // Data
   let new_full_name = "wibble"

test/brigade_test.gleam

···
 import youid/uuid
 
 pub fn register_new_brigade_test() {
-  let path = "/admin/teams"
+  let path = "/admin/brigade/new"
   let ctx = app_test.global_data()
   use _ <- list.each(list.range(1, app_test.n_tests))
 
···
 pub fn get_all_brigades_test() {
   let ctx = app_test.global_data()
   use _ <- list.each(list.range(1, app_test.n_tests))
-  let path = "/admin/teams"
+  let path = "/admin/brigade"
 
   //   DUMMY LEADER -----------------------------------------------------------
   let leader_id = dummy.random_user(ctx.db)

test/occurrence_test.gleam

···
   let assert Ok(_) = dev_sql.soft_truncate_user_account(ctx.db)
 }
 
-pub fn resolve_occurrence_test() {
+pub fn close_occurrence_test() {
   let ctx = app_test.global_data()
-  let base_path = "/occurrence/resolved_at/"
+  let base_path = "/occurrence/close/"
   use _ <- list.each(list.range(1, app_test.n_tests))
 
   // DUMMY ---------------------------------------------------------------------
···
   let assert Ok(_) = dev_sql.soft_truncate_user_account(ctx.db)
 }
 
-pub fn resolve_missing_occurrence_test() {
+pub fn close_missing_occurrence_test() {
   let ctx = app_test.global_data()
-  let base_path = "/occurrence/resolved_at/"
+  let base_path = "/occurrence/close/"
   let path = base_path <> uuid.v7_string()
 
   let req =
···
 
 pub fn reopen_occurrence_test() {
   let ctx = app_test.global_data()
-  let base_path = "/occurrence/resolved_at/"
+  let base_path = "/occurrence/reopen/"
   use _ <- list.each(list.range(1, app_test.n_tests))
 
   // DUMMY ---------------------------------------------------------------------
···
     )
 
   let path = base_path <> uuid.to_string(dummy_occurrence)
-  let req = simulate.request(http.Delete, path)
+  let req = simulate.request(http.Post, path)
   let resp = http_router.handle_request(req, ctx)
 
   assert resp.status == 401 as "Restricted to authenticated Users"
···
 
 pub fn reopen_missing_occurrence_test() {
   let ctx = app_test.global_data()
-  let base_path = "/occurrence/resolved_at/"
+  let base_path = "/occurrence/reopen/"
   let path = base_path <> uuid.v7_string()
 
   let req =
-    simulate.browser_request(http.Delete, path)
+    simulate.browser_request(http.Post, path)
     |> app_test.with_authorization()
 
   let resp = http_router.handle_request(req, ctx)

test/user_test.gleam

···
     })
     as "Response contain invalid JSON"
 
-  let path = "/user/profile"
+  let path = "/user/profile/update"
   let login_req =
     simulate.browser_request(http.Post, login_path)
     |> simulate.form_body([