client: Started working on ability to sync messages after last known message

kordophone/src/api/http_client.rs

@@ -10,7 +10,7 @@ use async_trait::async_trait;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 
 use crate::{
-    model::{Conversation, ConversationID, JwtToken, Message}, 
+    model::{Conversation, ConversationID, JwtToken, Message, MessageID}, 
     APIInterface
 };
 
@@ -118,8 +118,27 @@ impl<K: TokenStore + Send + Sync> APIInterface for HTTPAPIClient<K> {
         Ok(token)
     }
 
-    async fn get_messages(&mut self, conversation_id: &ConversationID) -> Result<Vec<Message>, Self::Error> {
-        let endpoint = format!("messages?guid={}", conversation_id);
+    async fn get_messages(
+        &mut self, 
+        conversation_id: &ConversationID,
+        limit: Option<u32>,
+        before: Option<MessageID>,
+        after: Option<MessageID>,
+    ) -> Result<Vec<Message>, Self::Error> {
+        let mut endpoint = format!("messages?guid={}", conversation_id);
+        
+        if let Some(limit_val) = limit {
+            endpoint.push_str(&format!("&limit={}", limit_val));
+        }
+        
+        if let Some(before_id) = before {
+            endpoint.push_str(&format!("&beforeMessageGUID={}", before_id));
+        }
+        
+        if let Some(after_id) = after {
+            endpoint.push_str(&format!("&afterMessageGUID={}", after_id));
+        }
+
         let messages: Vec<Message> = self.request(&endpoint, Method::GET).await?;
         Ok(messages)
     }
@@ -288,7 +307,7 @@ mod test {
         let mut client = local_mock_client();
         let conversations = client.get_conversations().await.unwrap();
         let conversation = conversations.first().unwrap();
-        let messages = client.get_messages(&conversation.guid).await.unwrap();
+        let messages = client.get_messages(&conversation.guid, None, None, None).await.unwrap();
         assert!(!messages.is_empty());
     }
 }

kordophone/src/api/mod.rs

@@ -1,6 +1,6 @@
 use async_trait::async_trait;
 pub use crate::model::{
-    Conversation, Message, ConversationID
+    Conversation, Message, ConversationID, MessageID,
 };
 use crate::model::JwtToken;
 
@@ -20,7 +20,13 @@ pub trait APIInterface {
     async fn get_conversations(&mut self) -> Result<Vec<Conversation>, Self::Error>;
 
     // (GET) /messages
-    async fn get_messages(&mut self, conversation_id: &ConversationID) -> Result<Vec<Message>, Self::Error>;
+    async fn get_messages(
+        &mut self, 
+        conversation_id: &ConversationID,
+        limit: Option<u32>,
+        before: Option<MessageID>,
+        after: Option<MessageID>,
+    ) -> Result<Vec<Message>, Self::Error>;
 
     // (POST) /authenticate
     async fn authenticate(&mut self, credentials: Credentials) -> Result<JwtToken, Self::Error>;

kordophone/src/model/message.rs

@@ -2,6 +2,10 @@ use serde::Deserialize;
 use time::OffsetDateTime; 
 use uuid::Uuid;
 
+use super::Identifiable;
+
+pub type MessageID = <Message as Identifiable>::ID;
+
 #[derive(Debug, Clone, Deserialize)]
 pub struct Message {
     pub guid: String, 
@@ -22,6 +26,14 @@ impl Message {
     }
 }
 
+impl Identifiable for Message {
+    type ID = String;
+
+    fn id(&self) -> &Self::ID {
+        &self.guid
+    }
+}
+
 #[derive(Default)]
 pub struct MessageBuilder {
     guid: Option<String>, 

kordophone/src/model/mod.rs

@@ -5,6 +5,7 @@ pub use conversation::Conversation;
 pub use conversation::ConversationID;
 
 pub use message::Message;
+pub use message::MessageID;
 
 pub mod jwt;
 pub use jwt::JwtToken;

kordophone/src/tests/test_client.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 pub use crate::APIInterface;
 use crate::{
     api::http_client::Credentials, 
-    model::{Conversation, ConversationID, JwtToken, Message}
+    model::{Conversation, ConversationID, JwtToken, Message, MessageID}
 };
 
 pub struct TestClient {
@@ -44,7 +44,13 @@ impl APIInterface for TestClient {
         Ok(self.conversations.clone())
     }
 
-    async fn get_messages(&mut self, conversation_id: &ConversationID) -> Result<Vec<Message>, Self::Error> {
+    async fn get_messages(
+        &mut self, 
+        conversation_id: &ConversationID, 
+        limit: Option<u32>, 
+        before: Option<MessageID>, 
+        after: Option<MessageID>
+    ) -> Result<Vec<Message>, Self::Error> {
         if let Some(messages) = self.messages.get(conversation_id) {
             return Ok(messages.clone())
         }