reprogramming messages

marci1175 · Dec 1, 2023 · 201dc5d · 201dc5d
1 parent fba38be
commit 201dc5d
Show file tree

Hide file tree

Showing 7 changed files with 105 additions and 24 deletions.
diff --git a/proto/messages.proto b/proto/messages.proto
@@ -16,14 +16,11 @@ service Message {
 //ingoing
 message MessageRequest {
     string message = 1;
-    string author = 2;
-    string password = 3;
 }
 
 //empty request, for syncing
 message MessageSync {
     string password = 1;
-
 }
 
 //outgoing

diff --git a/schematics/message_struct.schematics b/schematics/message_struct.schematics
@@ -0,0 +1,12 @@
+enum MessageType {
+    File_upload,
+    Image,
+    Message,
+}
+
+struct Message {
+    MessageType: MessageType,
+    File_upload: Option<[String; 2]>,
+    Image: Option<GenericArray>,
+    Message: Option<String>
+}
diff --git a/src/app.rs b/src/app.rs
@@ -15,6 +15,7 @@ use self::account_manager::{
     append_to_file, decrypt_lines_from_vec, delete_line_from_file, read_from_file,
 };
 
+use self::backend::{FileUpload, Message};
 use self::input::keymap;
 
 impl eframe::App for backend::TemplateApp {
@@ -38,7 +39,7 @@ impl eframe::App for backend::TemplateApp {
 
     fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
         let input_keys = keymap(self.keymap.clone());
-
+        
         /*
 
             :: custom font ::

diff --git a/src/app/backend.rs b/src/app/backend.rs
@@ -1,3 +1,4 @@
+use chrono::Utc;
 use rand::rngs::ThreadRng;
 
 use std::collections::BTreeMap;
@@ -108,7 +109,7 @@ impl Default for TemplateApp {
             //fontbook
             filter: Default::default(),
             named_chars: Default::default(),
-            
+
             //login page
             login_username: String::new(),
             login_password: String::new(),
@@ -184,3 +185,58 @@ impl TemplateApp {
         Default::default()
     }
 }
+
+//Message Types
+#[derive(Default, serde::Serialize, serde::Deserialize, Debug)]
+pub struct FileUpload {
+    pub name: String,
+    pub bytes: Vec<u8>,
+}
+
+#[derive(Default, serde::Serialize, serde::Deserialize, Debug)]
+pub struct NormalMessage {
+    pub message: String,
+}
+
+#[derive(Default, serde::Serialize, serde::Deserialize, Debug)]
+pub struct Image {
+    pub bytes: Vec<u8>,
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub enum MessageType {
+    FileUpload(FileUpload),
+    Image(Image),
+    NormalMessage(NormalMessage),
+}
+
+#[derive(serde::Serialize, serde::Deserialize, Debug)]
+pub struct Message {
+    pub MessageType: MessageType,
+    pub Password: String,
+    pub Author: String,
+    pub MessageDate: String,
+    pub Destination: String,
+}
+
+impl Message {
+    pub fn struct_into_string(&self) -> String {
+        return serde_json::to_string(self).unwrap_or_default();
+    }
+    pub fn construct_normal_msg(
+        msg: &str,
+        ip: String,
+        password: String,
+        author: String,
+    ) -> Message {
+        Message {
+            MessageType: MessageType::NormalMessage(NormalMessage { message: msg.trim().to_string() }),
+            Password: password,
+            Author: author,
+            MessageDate: {
+                Utc::now().format("%Y.%m.%d. %H:%M").to_string()
+            },
+            Destination: ip,
+        }
+    }
+}
diff --git a/src/app/client.rs b/src/app/client.rs
@@ -3,24 +3,21 @@ use std::path::PathBuf;
 use messages::{message_client::MessageClient, FileRequest, FileSend, MessageRequest, MessageSync};
 
 use self::messages::FileResponse;
+
+use super::backend::Message;
 pub mod messages {
     tonic::include_proto!("messages");
 }
 
 //main is for sending
 pub async fn send_msg(
-    username: String,
-    msg: String,
-    passw: String,
-    ip: String,
+    message: Message
 ) -> Result<String, Box<dyn std::error::Error>> {
     let mut client: MessageClient<tonic::transport::Channel> =
-        MessageClient::connect(format!("http://{}", ip)).await?;
+        MessageClient::connect(format!("http://{}", message.Destination)).await?;
 
     let request = tonic::Request::new(MessageRequest {
-        message: msg.trim().to_string(),
-        author: username,
-        password: passw,
+        message: message.struct_into_string(),
     });
 
     let response = client.send_message(request).await?.into_inner().clone();

diff --git a/src/app/server.rs b/src/app/server.rs
@@ -20,10 +20,12 @@ use instant_acme::{
 */
 
 use messages::{
-    message_server::{Message, MessageServer},
+    message_server::{Message as ServerMessage, MessageServer},
     FileRequest, FileResponse, FileSend, FileStatus, MessageRequest, MessageResponse, MessageSync,
 };
 
+use crate::app::backend::Message;
+
 pub mod messages {
     tonic::include_proto!("messages");
 }
@@ -37,24 +39,31 @@ pub struct MessageService {
     pub file_paths: Mutex<Vec<PathBuf>>,
 }
 #[tonic::async_trait]
-impl Message for MessageService {
+impl ServerMessage for MessageService {
     async fn send_message(
         &self,
         request: Request<MessageRequest>,
     ) -> Result<Response<MessageResponse>, Status> {
         println!("Got a request: {:?}", request);
 
-        let req = request.into_inner();
-
+        let req_result: Result<Message, serde_json::Error> = serde_json::from_str(&request.into_inner().message);
+        let req: Message = req_result.unwrap();
+
+        let req_message = match req.MessageType {
+            crate::app::backend::MessageType::FileUpload(_) => todo!(),
+            crate::app::backend::MessageType::Image(_) => todo!(),
+            crate::app::backend::MessageType::NormalMessage(ok) => ok.message,
+        };
+
         let current_datetime = Local::now();
         let format = StrftimeItems::new("%Y.%m.%d. %H:%M");
         let formatted_datetime = current_datetime.format_with_items(format);
 
-        if req.password.trim() == self.passw.trim() {
+        if req.Password == self.passw.trim() {
             match self.messages.lock() {
                 Ok(mut ok) => {
                     ok.push(
-                        format!("{formatted_datetime} $ {} | {} ", req.author, req.message) + "\n",
+                        format!("{formatted_datetime} $ {} | {} ", req.Author, req_message) + "\n",
                     );
                 }
                 Err(err) => {
@@ -75,7 +84,7 @@ impl Message for MessageService {
 
         // Wait for the spawned thread to finish
         let final_msg = handle.join().unwrap();
-        if req.password.trim() == self.passw.trim() {
+        if req.Password.trim() == self.passw.trim() {
             let reply = MessageResponse {
                 message: final_msg.to_string(),
             };
@@ -213,12 +222,21 @@ impl Message for MessageService {
 
         let file_path_vec = self.file_paths.lock().unwrap();
 
+        //check for index in uploaded files path vector
+        // EX ::
+        //       Vec() => {"C:\Apad.exe", "C:\Kurva"}
+        // INPUT ::
+        //      1
+        // OUTPUT ::
+        //       "C:\Kurva" 
+
         let apad = &file_path_vec[req.index as usize];
 
         let file = fs::read(apad).unwrap();
 
         let file_name = apad.file_name().unwrap().to_string_lossy().to_string();
-
+
+        //reply with file name, bytes
         let reply = FileResponse {
             file,
             name: file_name,

diff --git a/src/app/ui/client.rs b/src/app/ui/client.rs
@@ -13,7 +13,7 @@ use windows_sys::Win32::UI::WindowsAndMessaging::{MessageBoxW, MB_ICONEXCLAMATIO
 use std::sync::mpsc;
 
 use crate::app::account_manager::write_file;
-use crate::app::backend::TemplateApp;
+use crate::app::backend::{TemplateApp, Message};
 use crate::app::client::{self, request_file, send_file};
 
 impl TemplateApp {
@@ -319,9 +319,9 @@ impl TemplateApp {
                                     true => self.client_password.clone(),
                                     false => "".into(),
                                 };
-                                let ok = self.send_on_ip.clone();
+                                let temp_ip = self.send_on_ip.clone();
                                 tokio::spawn(async move {
-                                    match client::send_msg(username, temp_msg, passw, ok)
+                                    match client::send_msg(Message::construct_normal_msg(&temp_msg, temp_ip, passw, username))
                                         .await
                                     {
                                         Ok(ok) => {