:sparkles: saved processor in redis when saving data

src/model.gleam

···
 import gleam/dict
 import gleam/dynamic/decode
 import gleam/json
+import gleam/option
 import gleam/result
 
 pub type PaymentRequest {
-  PaymentRequest(correlation_id: String, amount: Float, requested_at: birl.Time)
+  PaymentRequest(
+    correlation_id: String,
+    amount: Float,
+    requested_at: birl.Time,
+    provider: option.Option(String),
+  )
+}
+
+pub fn set_provider(
+  payment_request: PaymentRequest,
+  provider: String,
+) -> PaymentRequest {
+  PaymentRequest(..payment_request, provider: option.Some(provider))
 }
 
 pub fn to_dict(payment: PaymentRequest) -> dict.Dict(String, String) {
···
     #("correlationId", json.string(payment.correlation_id)),
     #("amount", json.float(payment.amount)),
     #("requestedAt", json.string(payment.requested_at |> birl.to_iso8601)),
+    #("provider", json.nullable(payment.provider, of: fn(a) { json.string(a) })),
   ]
   |> json.object
 }
···
     use amount <- decode.field("amount", decode.float)
     use correlation_id <- decode.field("correlationId", decode.string)
     use requested_at <- decode.field("requestedAt", decode.string)
+    use provider <- decode.field("provider", decode.optional(decode.string))
 
     decode.success(PaymentRequest(
       amount: amount,
···
       requested_at: requested_at
         |> birl.parse
         |> result.unwrap(birl.now()),
+      provider: provider,
     ))
   }
 

src/processor.gleam

···
 import gleam/option
 import gleam/otp/actor
 import gleam/otp/supervision
+import gleam/string
 import integrations/provider
 import model
 import redis
···
 fn integrations(
   providers: List(provider.ProviderConfig),
   body: String,
-) -> Result(Bool, Bool) {
+) -> Result(provider.ProviderConfig, Bool) {
   case providers {
     [] -> Error(False)
     [provider, ..rest] -> {
       echo "Trying provider -> " <> provider.url
       case provider.send_request(provider, body) {
-        Ok(_) -> Ok(True)
+        Ok(_) -> Ok(provider)
         _ -> integrations(rest, body)
       }
     }
···
       processor.redis_conn
       |> redis.enqueue_payments([data])
     }
-    Ok(_) -> {
+    Ok(provider_processed) -> {
       echo "Success, saving it"
 
+      let save_provider = case
+        string.contains(provider_processed.url, contain: "default")
+      {
+        True -> "default"
+        _ -> "fallback"
+      }
+
       processor.redis_conn
-      |> redis.save_data(message |> model.to_dict)
+      |> redis.save_data(
+        message
+        |> model.set_provider(save_provider)
+        |> model.to_dict,
+      )
     }
   }
 }

src/web/controllers/payment_controller.gleam

···
 import gleam/http/response
 import gleam/json
 import gleam/list
+import gleam/option
 import gleam/string_tree
 import model.{type PaymentRequest, PaymentRequest}
 import redis
···
       correlation_id: correlation,
       amount: amount,
       requested_at: birl.now(),
+      provider: option.None,
     ))
   }
   case decode.run(body, decoder) {