Chunk loading

src/cli.rs

@@ -1,9 +1,4 @@
-use std::{
+use std::{fs::File, path::PathBuf, str::FromStr, sync::Arc};
-    fs::{self, File},
-    path::PathBuf,
-    str::FromStr,
-    sync::Arc,
-};
 
 use rustyline::{DefaultEditor, error::ReadlineError};
 use zip::ZipArchive;

src/requests/chunk.rs

@@ -0,0 +1,16 @@
+use crate::{server::Server, types::message::ServerMessage, utils::client::Client};
+use std::sync::Arc;
+
+crate::logger!(LOGGER "Chunk Loader");
+
+pub fn load_chunk(
+    server: &Arc<Server>,
+    client: &Client,
+    channel_id: &str,
+    chunk_id: usize,
+) -> crate::Result<()> {
+    let mut chunk = server.db.get_chunk(channel_id, chunk_id)?;
+    chunk.reverse();
+    client.send(ServerMessage::Chunk(chunk))?;
+    Ok(())
+}

src/requests/mod.rs

@@ -1,3 +1,4 @@
+pub mod chunk;
 pub mod message;
 
 use std::sync::Arc;
@@ -31,6 +32,13 @@ impl Server {
                 ClientMessage::DeleteMessage { message_id } => {
                     message::delete(self, client, *message_id)?
                 }
+
+                ClientMessage::LoadChunk {
+                    chunk_id,
+                    channel_id,
+                } => {
+                    chunk::load_chunk(self, client, channel_id, *chunk_id)?;
+                }
             },
 
             WsMessage::Binary(b) => {

src/server.rs

@@ -1,6 +1,5 @@
 use std::{
     collections::HashSet,
-    fs::{self},
     net::{TcpListener, TcpStream},
     path::{Path, PathBuf},
     sync::{
@@ -159,21 +158,13 @@ impl Server {
         match self.wrap_err(&client, client.read_t::<types::handshake::ClientDetails>())? {
             Some(types::message::WsMessage::Message(types::handshake::ClientDetails {
                 auth_token,
-                last_message,
                 ..
             })) => {
                 let auth_res = utils::auth::auth(self, &mut client, &auth_token);
                 let uuid = self.wrap_err(&client, auth_res)?;
                 self.wrap_err(
                     &client,
-                    client.send(types::message::ServerMessage::Authenticated {
+                    client.send(types::message::ServerMessage::Authenticated { uuid }),
-                        uuid,
-                        messages: if let Some(i) = last_message {
-                            self.wrap_err(&client, self.db.get_messages_after_id(i))?
-                        } else {
-                            self.wrap_err(&client, self.db.get_messages_after_id(0))?
-                        },
-                    }),
                 )?;
             }
             Some(v) => {

src/types.rs

@@ -49,14 +49,16 @@ pub mod handshake {
     pub struct ClientDetails {
         pub version: String,
         pub auth_token: String,
-        pub last_message: Option<i64>,
     }
 }
 
 pub mod message {
     use serde::{Deserialize, Serialize};
 
-    use crate::types::{Author, data};
+    use crate::types::{
+        Author,
+        data::{self, Message},
+    };
 
     /// Messages sent *from the client* (user’s app) to the server
     #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -75,7 +77,14 @@ pub mod message {
         },
 
         /// Delete a message (if allowed)
-        DeleteMessage { message_id: i64 },
+        DeleteMessage {
+            message_id: i64,
+        },
+
+        LoadChunk {
+            channel_id: String,
+            chunk_id: usize,
+        },
     }
 
     /// Messages sent *from the server* to the client
@@ -85,7 +94,6 @@ pub mod message {
         /// Successful authentication
         Authenticated {
             uuid: Author,
-            messages: Vec<data::Message>,
         },
 
         TempMessage {
@@ -121,6 +129,8 @@ pub mod message {
         Shutdown {
             message: String,
         },
+
+        Chunk(Vec<Message>),
     }
 
     #[derive(Debug, Clone, Serialize, Deserialize)]

src/utils/database.rs

@@ -103,16 +103,16 @@ impl Database {
         Ok(None)
     }
 
-    /// Get all messages with an ID greater than the given one
+    pub fn get_chunk(&self, channel_id: &str, chunk_id: usize) -> Result<Vec<Message>> {
-    pub fn get_messages_after_id(&self, message_id: i64) -> Result<Vec<Message>> {
         let mut stmt = self.0.prepare(
             "SELECT id, channel_id, user_id, contents, timestamp
-         FROM chat
+            FROM chat
-         WHERE id > ?1
+            WHERE channel_id = ?1
-         ORDER BY id ASC",
+            ORDER BY id DESC
+            LIMIT 16 OFFSET (?2 * 16)",
         )?;
 
-        let rows = stmt.query_map(params![message_id], |row| {
+        let rows = stmt.query_map(params![channel_id, chunk_id], |row| {
             Ok(Message {
                 id: row.get::<_, i64>(0)?,
                 channel_id: row.get::<_, String>(1)?,