From 51120f6268aa250b96f6f2f1be12a766d54e5c34 Mon Sep 17 00:00:00 2001 From: grimhilt Date: Wed, 14 Jun 2023 16:29:58 +0200 Subject: [PATCH] add service req props --- src/commands/status.rs | 29 ++++++-- src/services.rs | 1 + src/services/api.rs | 13 ++++ src/services/details.rs | 2 +- src/services/req_props.rs | 135 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 175 insertions(+), 5 deletions(-) create mode 100644 src/services/req_props.rs diff --git a/src/commands/status.rs b/src/commands/status.rs index 9d13eda..6dfb9e4 100644 --- a/src/commands/status.rs +++ b/src/commands/status.rs @@ -15,11 +15,21 @@ enum RemoveSide { Right, } +#[derive(PartialEq)] +#[derive(Debug)] +enum State { + Default, + New, + Renamed, + Modified, + Deleted, +} + // todo: relative path, filename, get modified pub fn status() { let (staged_objs, new_objs, del_objs) = get_diff(); dbg!(get_diff()); - print_status(staged_objs.clone(), del_objs.iter().map(|x| x.name.to_owned()).collect(), new_objs.clone()); + print_status1(staged_objs.clone(), del_objs.iter().map(|x| x.name.to_owned()).collect(), new_objs.clone()); } #[derive(Debug)] @@ -27,6 +37,7 @@ pub struct Obj { otype: String, name: String, path: PathBuf, + state: State, } pub fn get_diff() -> (Vec, Vec, Vec) { @@ -89,7 +100,12 @@ pub fn get_diff() -> (Vec, Vec, Vec) { } let del_objs: Vec = hashes.iter().map(|x| { - Obj {otype: x.1.otype.clone(), name: x.1.name.clone(), path: x.1.path.clone()} + Obj { + otype: x.1.otype.clone(), + name: x.1.name.clone(), + path: x.1.path.clone(), + state: State::Deleted + } }).collect(); (staged_objs.clone(), objs.clone(), del_objs) } @@ -105,6 +121,7 @@ fn add_to_hashmap(lines: Lines>, hashes: &mut HashMap, objects: &mut Vec, root: PathBuf) { } -fn print_status(staged_objs: Vec, del_objs: Vec, new_objs: Vec) { +fn print_status(staged_objs: Vec, objs: Vec) { + +} + +fn print_status1(staged_objs: Vec, del_objs: Vec, new_objs: Vec) { if staged_objs.len() == 0 && del_objs.len() == 0 && new_objs.len() == 0 { println!("Nothing to push, working tree clean"); return; @@ -141,7 +162,7 @@ fn print_status(staged_objs: Vec, del_objs: Vec, new_objs: Vec...\" to update what will be pushed)"); } for object in new_objs { - println!(" {} {}", String::from("added:").red(), object.red()); + println!(" {} {}", String::from("new file:").red(), object.red()); } for object in del_objs { println!(" {} {}", String::from("deleted:").red(), object.red()); diff --git a/src/services.rs b/src/services.rs index 4c4d98a..0e53ee9 100644 --- a/src/services.rs +++ b/src/services.rs @@ -1,3 +1,4 @@ pub mod api; pub mod list_folders; pub mod download_files; +pub mod req_props; diff --git a/src/services/api.rs b/src/services/api.rs index a35243c..887e8a9 100644 --- a/src/services/api.rs +++ b/src/services/api.rs @@ -45,6 +45,19 @@ impl ApiBuilder { self } + pub fn set_xml(&mut self, xml_payload: String) -> &mut ApiBuilder { + match self.request.take() { + None => { + eprintln!("fatal: incorrect request"); + std::process::exit(1); + }, + Some(req) => { + self.request = Some(req.body(xml_payload)); + } + } + self + } + pub async fn send(&mut self) -> Result { self.set_auth(); match self.request.take() { diff --git a/src/services/details.rs b/src/services/details.rs index 4a650c5..24131a7 100644 --- a/src/services/details.rs +++ b/src/services/details.rs @@ -21,7 +21,7 @@ async fn send_propfind_request() -> Result<(), Box> { - + ) "#; let mut headers = HeaderMap::new(); diff --git a/src/services/req_props.rs b/src/services/req_props.rs new file mode 100644 index 0000000..4cf1169 --- /dev/null +++ b/src/services/req_props.rs @@ -0,0 +1,135 @@ +use crate::services::api::{ApiBuilder, ApiError}; +use xml::reader::{EventReader, XmlEvent}; +use std::io::{self, Cursor}; +use reqwest::{Method, IntoUrl, Response, Error}; + +pub struct ReqProps { + api_builder: ApiBuilder, + xml_list: Vec, + xml_payload: String, +} + +impl ReqProps { + pub fn new(url: U) -> Self { + ReqProps { + api_builder: ApiBuilder::new() + .set_request(Method::from_bytes(b"PROPFIND").unwrap(), url), + xml_list: vec![], + xml_payload: String::new(), + } + } + + pub fn getlastmodified(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("getlastmodified")); + self.xml_payload.push_str(r#""#); + self + } + + pub fn getcontentlenght(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("getcontentlength")); + self.xml_payload.push_str(r#""#); + self + } + + pub fn getcontenttype(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("getcontenttype")); + self.xml_payload.push_str(r#""#); + self + } + + pub fn getpermissions(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("permissions")); + self.xml_payload.push_str(r#""#); + self + } + + pub fn getressourcetype(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("resourcetype")); + self.xml_payload.push_str(r#""#); + self + } + + pub fn getetag(&mut self) -> &mut ReqProps { + self.xml_list.push(String::from("getetag")); + self.xml_payload.push_str(r#""#); + self + } + + fn validate_xml(&mut self) -> &mut ReqProps { + let mut xml = String::from(r#""#); + xml.push_str(&self.xml_payload.clone()); + xml.push_str(r#""#); + self.api_builder.set_xml(xml); + self + } + + pub async fn send(&mut self) -> Result { + self.validate_xml(); + self.api_builder.send().await + } + + pub async fn send_with_err(&mut self) -> Result { + 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)) + } + } + + pub async fn send_with_res(&mut self) -> Vec { + 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 { + let cursor = Cursor::new(xml); + let parser = EventReader::new(cursor); + + let mut should_get = false; + let mut values: Vec = vec![]; + let mut iter = self.xml_list.iter(); + let mut val = iter.next(); + + for event in parser { + match event { + Ok(XmlEvent::StartElement { name, .. }) => { + if let Some(v) = val.clone() { + should_get = &name.local_name == v; + } else { + break; + } + } + Ok(XmlEvent::Characters(text)) => { + if !text.trim().is_empty() && should_get { + values.push(text); + val = iter.next() + } + } + Ok(XmlEvent::EndElement { .. }) => { + should_get = false; + } + Err(e) => { + eprintln!("Error: {}", e); + break; + } + _ => {} + } + } + values + } +}