push file

docs/store.md

@@ -2,12 +2,12 @@
 ## Blob object
 
 ```
-file_name hash timestamp
+file_name timestamp size hash
 ```
 
 ## Tree object
 ```
-folder_name
+folder_name timestamp
 tree hash_path folder_name
 blob hash_path file_name
 ```

src/commands/push.rs

@@ -1,7 +1,11 @@
 use crate::commands::{status, config};
+use crate::services::req_props::ReqProps;
+use crate::services::api::ApiError;
+use crate::services::upload_file::UploadFile;
+use crate::commands::status::{State, Obj};
 
 pub fn push() {
-    dbg!(status::get_diff());
+    dbg!(status::get_all_staged());
 
     let remote = match config::get("remote") {
         Some(r) => r,
@@ -10,9 +14,149 @@ pub fn push() {
             std::process::exit(1);
         }
     };
-    let (staged_obj, new_obj, del_obj) = status::get_diff();
-    
+  
+    let staged_objs = status::get_all_staged();
+    // todo sort folder first
+    for obj in staged_objs {
+        if obj.otype == String::from("tree") {
+           dbg!("should push folder");
+        } else {
+            let push_factory = PushFactory.new(obj.clone());
+            match push_factory.can_push() {
+                PushState::Valid => push_factory.push(),
+                _ => todo!(),
+            }
+        }
+    }
     // read index
     // if dir upload dir
 
 }
+
+#[derive(Debug)]
+enum PushState {
+    Valid,
+    Conflict,
+    Error,
+} 
+
+trait PushChange {
+    fn can_push(&self) -> PushState;
+    fn push(&self);
+}
+
+struct New {
+    obj: Obj,
+}
+
+impl PushChange for New {
+    fn can_push(&self) -> PushState {
+        // check if exist on server
+        let file_infos = tokio::runtime::Runtime::new().unwrap().block_on(async {
+            let res = ReqProps::new()
+                .set_url(&self.obj.path.to_str().unwrap())
+                .getlastmodified()
+                .send_with_err()
+                .await;
+
+            match res {
+                Ok(data) => Ok(data),
+                Err(ApiError::IncorrectRequest(err)) => {
+                    if err.status() == 404 {
+                        Ok(vec![])
+                    } else {
+                        Err(())
+                    }
+                },
+                Err(_) => Err(()),
+            }
+        });
+
+        if let Ok(infos) = file_infos {
+            if infos.len() == 0 {
+                // file doesn't exist on remote
+                PushState::Valid
+            } else {
+                // check date
+                PushState::Conflict
+            }
+        } else {
+            PushState::Error
+        }
+    }
+
+    fn push(&self) {
+        let obj = &self.obj;
+        tokio::runtime::Runtime::new().unwrap().block_on(async {
+            let res = UploadFile::new()
+                .set_url(obj.path.to_str().unwrap())
+                .set_file(obj.path.clone())
+                .send_with_err()
+                .await;
+
+            match res {
+                Err(ApiError::IncorrectRequest(err)) => {
+                    eprintln!("fatal: error pushing file {}: {}", obj.name, err.status());
+                    std::process::exit(1);
+                },
+                Err(ApiError::RequestError(_)) => {
+                    eprintln!("fatal: request error pushing file {}", obj.name);
+                    std::process::exit(1);
+                }
+                _ => (),
+            }
+            // todo manage err
+            // todo remove index
+        });
+    }
+}
+
+struct PushFactory;
+
+impl PushFactory {
+    fn new(&self, obj: Obj) -> Box<dyn PushChange> {
+        match obj.state {
+            State::New => Box::new(New { obj: obj.clone() }),
+            State::Renamed => todo!(),
+            State::Modified => todo!(),
+            State::Deleted => todo!(),
+            State::Default => todo!(),
+        }
+    }
+}
+
+fn can_push_file(obj: Obj) -> PushState {
+    dbg!(obj.clone());
+    // check if exist on server
+    let file_infos = tokio::runtime::Runtime::new().unwrap().block_on(async {
+        let res = ReqProps::new()
+            .set_url(obj.path.to_str().unwrap())
+            .getlastmodified()
+            .send_with_err()
+            .await;
+
+        match res {
+            Ok(data) => Ok(data),
+            Err(ApiError::IncorrectRequest(err)) => {
+                if err.status() == 404 {
+                    Ok(vec![])
+                } else {
+                    Err(())
+                }
+            },
+            Err(_) => Err(()),
+        }
+    });
+
+    if let Ok(infos) = file_infos {
+        if infos.len() == 0 {
+            // file doesn't exist on remote
+            PushState::Valid
+        } else {
+            // check date
+           PushState::Conflict
+        }
+    } else {
+        PushState::Error
+    }
+}

src/commands/status.rs

@@ -18,7 +18,7 @@ enum RemoveSide {
 #[derive(PartialEq)]
 #[derive(Debug)]
 #[derive(Clone)]
-enum State {
+pub enum State {
     Default,
     New,
     Renamed,
@@ -42,10 +42,23 @@ pub fn status() {
 #[derive(Debug)]
 #[derive(Clone)]
 pub struct Obj {
-    otype: String,
-    name: String,
-    path: PathBuf,
-    state: State,
+    pub otype: String,
+    pub name: String,
+    pub path: PathBuf,
+    pub state: State,
+}
+
+pub fn get_all_staged() -> Vec<Obj> {
+    // todo opti getting staged and then finding differences ?
+    // todo opti return folder
+    let (mut new_objs, mut del_objs) = get_diff();
+    let mut renamed_objs = get_renamed(&mut new_objs, &mut del_objs);
+    // get copy, modified
+    let mut objs = new_objs;
+    objs.append(&mut del_objs);
+    objs.append(&mut renamed_objs);
+    let staged_objs = get_staged(&mut objs);
+    staged_objs
 }
 
 fn get_renamed(new_obj: &mut Vec<Obj>, del_obj: &mut Vec<Obj>) -> Vec<Obj> {
@@ -62,7 +75,6 @@ fn get_staged(objs: &mut Vec<Obj>) -> Vec<Obj> {
     let nextsync_path = utils::path::nextsync().unwrap();
     if let Ok(entries) = store::index::read_line(nextsync_path.clone()) {
         for entry in entries {
-            // todo hash this
             indexes.insert(entry.unwrap());
         }
     }
@@ -88,7 +100,7 @@ fn get_staged(objs: &mut Vec<Obj>) -> Vec<Obj> {
     staged_objs
 }
 
-pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
+fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
     let mut hashes = HashMap::new();
     let mut objs: Vec<String> = vec![];
 
@@ -119,7 +131,7 @@ pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
     while obj_to_analyse.len() > 0 {
         let cur_obj = obj_to_analyse.pop().unwrap();
         let cur_path = PathBuf::from(&cur_obj);
-        dbg!(cur_path.clone());
+
         let obj_path = root.clone().join(cur_path.clone());
 
         if obj_path.is_dir() {
@@ -149,17 +161,26 @@ pub fn get_diff() -> (Vec<Obj>, Vec<Obj>) {
     }).collect();
 
     let new_objs: Vec<Obj> = objs.iter().map(|x| {
-        // todo otype and name
+        let p = PathBuf::from(x.to_string());
+        // todo name
         Obj {
-            otype: String::from(""),
+            otype: get_type(p.clone()),
             name: x.to_string(),
-            path: PathBuf::from(x.to_string()),
+            path: p,
             state: State::New
         }
     }).collect();
     (new_objs, del_objs)
 }
 
+fn get_type(p: PathBuf) -> String {
+    if p.is_dir() {
+        String::from("tree")
+    } else {
+        String::from("blob")
+    }
+}
+
 fn add_to_hashmap(lines: Lines<BufReader<File>>, hashes: &mut HashMap<String, Obj>, path: PathBuf) {
     for line in lines {
         if let Ok(ip) = line {

src/services.rs

@@ -2,3 +2,4 @@ pub mod api;
 pub mod list_folders;
 pub mod download_files;
 pub mod req_props;
+pub mod upload_file;

src/services/api.rs

@@ -4,6 +4,7 @@ use reqwest::{Response, Error, IntoUrl, Method};
 use std::env;
 use dotenv::dotenv;
 
+#[derive(Debug)]
 pub enum ApiError {
     IncorrectRequest(reqwest::Response),
     EmptyError(reqwest::Error),
@@ -28,6 +29,24 @@ impl ApiBuilder {
         self
     }
 
+    pub fn build_request(&mut self, method: Method, path: &str) -> &mut ApiBuilder {
+        dotenv().ok();
+        // todo remove env
+        let host = env::var("HOST").unwrap();
+        let username = env::var("USERNAME").unwrap();
+        let root = env::var("ROOT").unwrap();
+        let mut url = String::from(host);
+        url.push_str("/remote.php/dav/files/");
+        url.push_str(&username);
+        url.push_str("/");
+        url.push_str(&root);
+        url.push_str("/");
+        url.push_str(path);
+        dbg!(url.clone());
+        self.request = Some(self.client.request(method, url));
+        self
+    }
+
     fn set_auth(&mut self) -> &mut ApiBuilder {
         // todo if not exist
         dotenv().ok();
@@ -58,6 +77,20 @@ impl ApiBuilder {
         self
     }
 
+    pub fn set_body(&mut self, body: Vec<u8>) -> &mut ApiBuilder {
+        match self.request.take() {
+            None => {
+                eprintln!("fatal: incorrect request");
+                std::process::exit(1);
+            },
+            Some(req) => {
+                self.request = Some(req.body(body));
+            }
+        }
+        self
+
+    }
+
     pub async fn send(&mut self) -> Result<Response, Error> {
         self.set_auth();
         match self.request.take() {

src/services/req_props.rs

@@ -10,15 +10,19 @@ pub struct ReqProps {
 }
 
 impl ReqProps {
-    pub fn new<U: IntoUrl>(url: U) -> Self {
+    pub fn new() -> Self {
         ReqProps {
-            api_builder: ApiBuilder::new()
-                .set_request(Method::from_bytes(b"PROPFIND").unwrap(), url),
+            api_builder: ApiBuilder::new(),
             xml_list: vec![],
             xml_payload: String::new(),
         }
     }
 
+    pub fn set_url(&mut self, url: &str) -> &mut ReqProps {
+        self.api_builder.build_request(Method::from_bytes(b"PROPFIND").unwrap(), url);
+        self
+    }
+
     pub fn getlastmodified(&mut self) -> &mut ReqProps {
         self.xml_list.push(String::from("getlastmodified"));
         self.xml_payload.push_str(r#"<d:getlastmodified/>"#);
@@ -68,34 +72,16 @@ impl ReqProps {
         self.api_builder.send().await
     }
 
-    pub async fn send_with_err(&mut self) -> Result<String, ApiError> {
+    pub async fn send_with_err(&mut self) -> Result<Vec<String>, ApiError> {
         let res = self.send().await.map_err(ApiError::RequestError)?; 
         if res.status().is_success() {
             let body = res.text().await.map_err(ApiError::EmptyError)?;
-            Ok(body)
+            Ok(self.parse(body))
         } else {
             Err(ApiError::IncorrectRequest(res))
         }
     }
 
-    pub async fn send_with_res(&mut self) -> Vec<String> {
-        match self.send_with_err().await {
-            Ok(body) => self.parse(body),
-            Err(ApiError::IncorrectRequest(err)) => {
-                eprintln!("fatal: {}", err.status());
-                std::process::exit(1);
-            },
-            Err(ApiError::EmptyError(_)) => {
-                eprintln!("Failed to get body");
-                vec![]
-            }
-            Err(ApiError::RequestError(err)) => {
-                eprintln!("fatal: {}", err);
-                std::process::exit(1);
-            }
-        }
-    }
-
     pub fn parse(&self, xml: String) -> Vec<String> {
         let cursor = Cursor::new(xml);
         let parser = EventReader::new(cursor);

src/services/upload_file.rs

@@ -1,34 +1,47 @@
-async fn upload_file(path: &str) -> Result<(), Box<dyn Error>> { 
-    dotenv().ok();
-    
-    let mut api_endpoint = env::var("HOST").unwrap().to_owned();
-    api_endpoint.push_str("/remote.php/dav/files/");
-    let username = env::var("USERNAME").unwrap();
-    api_endpoint.push_str(&username);
-    api_endpoint.push_str("/test/ok");
-    let password = env::var("PASSWORD").unwrap();
-    
-    let mut file = File::open("./file.test")?;
-    let mut buffer = Vec::new();
-    file.read_to_end(&mut buffer)?;
+use xml::reader::{EventReader, XmlEvent};
+use std::fs::File;
+use crate::services::api::{ApiBuilder, ApiError};
+use std::path::PathBuf;
+use std::io::{self, Read};
+use reqwest::{Method, IntoUrl, Response, Error};
 
-    // Create a reqwest client
-    let client = Client::new();
-
-    // Send the request
-    let response = client
-        .request(reqwest::Method::PUT, api_endpoint)
-        .basic_auth(username, Some(password))
-        .body(buffer)
-        .send()
-        .await?;
-
-    // Handle the response
-    if response.status().is_success() {
-        let body = response.text().await?;
-        println!("Response body: {}", body);
-    } else {
-        println!("Request failed with status code: {}", response.status());
-    }
-    Ok(())
+pub struct UploadFile {
+    api_builder: ApiBuilder,
+}
+
+impl UploadFile {
+    pub fn new() -> Self {
+        UploadFile {
+            api_builder: ApiBuilder::new(),
+        }
+    }
+
+    pub fn set_url(&mut self, url: &str) -> &mut UploadFile {
+        self.api_builder.build_request(Method::PUT, url);
+        self
+    }
+
+    pub fn set_file(&mut self, path: PathBuf) -> &mut UploadFile {
+        // todo large file
+        // todo small files
+        let mut file = File::open(path).unwrap();
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer).unwrap();
+        self.api_builder.set_body(buffer);
+        self
+    }
+
+    pub async fn send(&mut self) -> Result<Response, Error> {
+        self.api_builder.send().await
+    }
+
+    pub async fn send_with_err(&mut self) -> Result<String, ApiError> {
+        let res = self.send().await.map_err(ApiError::RequestError)?; 
+        if res.status().is_success() {
+            let body = res.text().await.map_err(ApiError::EmptyError)?;
+            Ok(body)
+        } else {
+            Err(ApiError::IncorrectRequest(res))
+        }
+    }
 }