v0.3.0 (#2)

Reviewed-on: #2

src/service/mer.rs

@@ -0,0 +1,112 @@
+pub struct MessageEventResponse {
+    pub app: crate::app::App,
+    pub token: textsender_models::token::LoginResult,
+}
+
+impl MessageEventResponse {
+    pub async fn record_message_event_response(
+        &self,
+        mer: &textsender_models::message::event::MessageEventResponse,
+    ) -> Result<textsender_models::message::event::MessageEventResponse, std::io::Error> {
+        let client = reqwest::Client::new();
+        let endpoint = String::from("api/v1/schedule/message/event/response/record");
+        let api_url = format!("{}/{endpoint}", self.app.api_url);
+
+        println!("Url: {api_url:?}");
+
+        use time::format_description::well_known::Iso8601;
+        let sent = match mer.sent.unwrap().format(&Iso8601::DEFAULT) {
+            Ok(converted) => converted,
+            Err(err) => {
+                return Err(std::io::Error::other(err.to_string()));
+            }
+        };
+
+        let payload = serde_json::json!({
+            "scheduled_message_event_id": mer.scheduled_message_event_id.unwrap(),
+            "response": mer.response,
+            "user_id": mer.user_id,
+            "sent": sent,
+            "status": textsender_models::message::event::MESSAGE_EVENT_RESPONSE_STATUS_SCHEDULED,
+            "contact_id": mer.contact_id,
+            "message_id": mer.message_id
+        });
+
+        println!("Payload: {payload:?}");
+
+        let (key, header) = super::auth_header(&self.token.access_token);
+
+        match client
+            .post(api_url)
+            .json(&payload)
+            .header(key, header)
+            .send()
+            .await
+        {
+            Ok(response) => match response.status() {
+                reqwest::StatusCode::CREATED | reqwest::StatusCode::OK => {
+                    println!("Response: {response:?}");
+                    match response.text().await {
+                        Ok(val) => match parse_response(&val).await {
+                            Ok(login_result) => Ok(login_result),
+                            Err(err) => Err(err),
+                        },
+                        Err(err) => Err(std::io::Error::other(err)),
+                    }
+                }
+                _ => Err(std::io::Error::other(
+                    "Error recording Message Event Response",
+                )),
+            },
+            Err(err) => Err(std::io::Error::other(err.to_string())),
+        }
+    }
+
+    /*
+        *
+        * {
+        "scheduled_message_event_id": "{{scheduled_message_event_id}}",
+        "response": {{text_response_raw}},
+        "user_id": "{{user_id}}",
+        "sent": "2026-06-20T17:10:00Z",
+        "status": "{{mer_status_scheduled}}",
+        "contact_id": "{{contact_id}}",
+        "message_id": "{{message_id}}"
+    }
+        *
+        */
+}
+
+async fn parse_response(
+    response: &str,
+) -> Result<textsender_models::message::event::MessageEventResponse, std::io::Error> {
+    match serde_json::from_str::<serde_json::Value>(response) {
+        Ok(j) => {
+            println!("Good");
+            let message = &j["message"];
+            let data = &j["data"];
+
+            println!("Message: {message:?}");
+            println!("Data: {data:?}");
+            match j.get("data") {
+                Some(serde_json::Value::Array(lrs)) => {
+                    if lrs.is_empty() {
+                        Err(std::io::Error::other("Error response is empty"))
+                    } else {
+                        let lr = lrs[0].clone();
+                        let ll: textsender_models::message::event::MessageEventResponse =
+                            match serde_json::from_value(lr) {
+                                Ok(lr) => lr,
+                                Err(err) => {
+                                    return Err(std::io::Error::other(err.to_string()));
+                                }
+                            };
+                        Ok(ll)
+                    }
+                }
+                _ => Err(std::io::Error::other("Error parsing response")),
+            }
+        }
+        Err(err) => Err(std::io::Error::other(err.to_string())),
+    }
+}