Add support for multiple files types

src/data/base_request_handler.rs

@@ -3,6 +3,7 @@
 //! Base handling code for all user requests
 
 
+use std::collections::HashSet;
 use std::error::Error;
 
 use exif::In;
@@ -23,11 +24,14 @@ use crate::data::user_token::UserAccessToken;
 use crate::helpers::{account_helper, comments_helper, conversations_helper, custom_emojies_helper, friends_helper, groups_helper, posts_helper, user_helper, virtual_directory_helper};
 use crate::helpers::virtual_directory_helper::VirtualDirType;
 use crate::routes::RequestResult;
+use crate::utils::mp3_utils::is_valid_mp3;
+use crate::utils::mp4_utils::is_valid_mp4;
 use crate::utils::pdf_utils::is_valid_pdf;
-use crate::utils::string_utils::{check_emoji_code, check_string_before_insert, check_url, remove_html_nodes, check_html_color};
+use crate::utils::string_utils::{check_emoji_code, check_html_color, check_string_before_insert, check_url, remove_html_nodes};
 use crate::utils::user_data_utils::{generate_new_user_data_file_name, prepare_file_creation, user_data_path};
 use crate::utils::virtual_directories_utils;
-use std::collections::HashSet;
+use crate::utils::zip_utils::is_valid_zip;
+use std::str::from_utf8;
 
 #[derive(Serialize)]
 struct SuccessMessage {
@@ -272,6 +276,34 @@ pub trait BaseRequestHandler {
         unreachable!();
     }
 
+    /// Get the mime type of a file included in the request
+    fn post_file_type(&mut self, name: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        let filetype = mime_guess::from_path(&file.name)
+            .first()
+            .map(|m| format!("{}/{}", m.type_(), m.subtype()));
+
+        if let None = filetype {
+            self.bad_request(format!("Could not determine file type in '{}' !", name))?;
+            unreachable!();
+        }
+
+        Ok(filetype.unwrap())
+    }
+
+    /// Get the extension of a file included in the request
+    fn post_file_ext(&mut self, name: &str, default: &str) -> Res<String> {
+        let suffix = self.post_file_type(name)?
+            .parse::<mime_guess::mime::Mime>()?
+            .suffix()
+            .map(|s| s.as_str())
+            .unwrap_or(default)
+            .to_string();
+
+        Ok(suffix)
+    }
+
     /// Save an image in user data directory
     fn save_post_image(&mut self, name: &str, folder: &str, max_w: u32, max_h: u32) -> ResultBoxError<String> {
 
@@ -329,8 +361,25 @@ pub trait BaseRequestHandler {
         Ok(target_file_path.to_string_lossy().to_string())
     }
 
+    /// Save a file included in the request
+    fn save_post_file(&mut self, name: &str, folder: &str, ext: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        // Avoid memory warnings
+        let copied_buff = file.buff.clone();
+
+        // Determine pdf file destination
+        let target_user_data_folder = prepare_file_creation(self.user_id_ref()?, folder)?;
+        let target_file_path = generate_new_user_data_file_name(target_user_data_folder.as_path(), ext)?;
+        let target_sys_path = user_data_path(target_file_path.as_path());
+
+        std::fs::write(target_sys_path, &copied_buff.as_ref())?;
+
+        Ok(target_file_path.to_string_lossy().to_string())
+    }
+
     /// Save a pdf included in the request
-    fn save_post_pdf(&mut self, name: &str, folder: &str) -> ResultBoxError<String> {
+    fn save_post_pdf(&mut self, name: &str, folder: &str) -> Res<String> {
         let file = self.post_file(name)?;
 
         if !is_valid_pdf(&file.buff)? {
@@ -338,17 +387,76 @@ pub trait BaseRequestHandler {
             unreachable!();
         }
 
-        // Avoid memory warnings
-        let copied_buff = file.buff.clone();
+        self.save_post_file(name, folder, "pdf")
+    }
 
-        // Determine pdf file destination
-        let target_user_data_folder = prepare_file_creation(self.user_id_ref()?, folder)?;
-        let target_file_path = generate_new_user_data_file_name(target_user_data_folder.as_path(), "pdf")?;
-        let target_sys_path = user_data_path(target_file_path.as_path());
+    /// Save a mp3 file included in the request
+    fn save_post_mp3(&mut self, name: &str, folder: &str) -> Res<String> {
+        let file = self.post_file(name)?;
 
-        std::fs::write(target_sys_path, &copied_buff.as_ref())?;
+        if !is_valid_mp3(&file.buff) {
+            self.bad_request(format!("Invalid MP3 file specified in {} !", name))?;
+            unreachable!();
+        }
 
-        Ok(target_file_path.to_string_lossy().to_string())
+        self.save_post_file(name, folder, "mp3")
+    }
+
+    /// Save a mp4 file included in the request
+    fn save_post_mp4(&mut self, name: &str, folder: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        if !is_valid_mp4(&file.buff) {
+            self.bad_request(format!("Invalid MP4 file specified in {} !", name))?;
+            unreachable!();
+        }
+
+        self.save_post_file(name, folder, "mp4")
+    }
+
+    /// Save a zip file included in the request
+    fn save_post_zip(&mut self, name: &str, folder: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        if !is_valid_zip(&file.buff) {
+            self.bad_request(format!("Invalid ZIP archive file specified in {} !", name))?;
+            unreachable!();
+        }
+
+        self.save_post_file(name, folder, "zip")
+    }
+
+    /// Save an office document included in the request
+    fn save_post_office_doc(&mut self, name: &str, folder: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        if !is_valid_zip(&file.buff) {
+            self.bad_request(format!("Invalid ZIP archive file specified in {} !", name))?;
+            unreachable!();
+        }
+
+        let mime = self.post_file_type(name)?;
+
+        if !mime.starts_with("application/") {
+            self.bad_request(format!("Invalid file name in {} !", name))?;
+            unreachable!();
+        }
+
+        let ext = &self.post_file_ext(name, "zip")?;
+        self.save_post_file(name, folder, ext)
+    }
+
+    /// Save a simple text document included in the request
+    fn save_post_txt_doc(&mut self, name: &str, folder: &str) -> Res<String> {
+        let file = self.post_file(name)?;
+
+        if from_utf8(&file.buff).is_err() {
+            self.bad_request(format!("File in {} is not UTF-8!", name))?;
+            unreachable!();
+        }
+
+        let ext = &self.post_file_ext(name, "txt")?;
+        self.save_post_file(name, folder, ext)
     }
 
     /// Get an integer included in the POST request