grimhilt/nextsync-rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

merge list folders and req props

Browse Source
This commit is contained in:
grimhilt
2023-06-17 16:26:31 +02:00
parent eabf707844
commit 1fd7948122
5 changed files with 105 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
src/services/list_folders.rs
View File

@@ -1,135 +0,0 @@
use crate::services::api::{ApiBuilder, ApiError};
use crate::utils::api::{ApiProps, get_relative_s};
use xml::reader::{EventReader, XmlEvent};
use std::io::Cursor;
use reqwest::{Method, Response, Error};
#[derive(Debug)]
pub struct FolderContent {
pub href: Option<String>,
pub relative_s: Option<String>,
}
impl Clone for FolderContent {
fn clone(&self) -> Self {
FolderContent {
href: self.href.clone(),
relative_s: self.relative_s.clone(),
}
}
}
impl FolderContent {
fn new() -> Self {
FolderContent {
href: None,
relative_s: None,
}
}
}
pub struct ListFolders {
api_builder: ApiBuilder,
xml_balises: Vec<String>,
api_props: Option<ApiProps>
}
impl ListFolders {
pub fn new() -> Self {
ListFolders {
api_builder: ApiBuilder::new(),
xml_balises: vec![],
api_props: None,
}
}
pub fn set_url(&mut self, url: &str) -> &mut ListFolders {
self.api_builder.build_request(Method::from_bytes(b"PROPFIND").unwrap(), url);
self
}
pub fn set_request(&mut self, p: &str, api_props: &ApiProps) -> &mut ListFolders {
self.api_props = Some(api_props.clone());
self.api_builder.set_req(Method::from_bytes(b"PROPFIND").unwrap(), p, api_props);
self
}
pub fn gethref(&mut self) -> &mut ListFolders {
self.xml_balises.push(String::from("href"));
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))
}
}
pub async fn send_with_res(&mut self) -> Result<Vec<FolderContent>, ApiError> {
match self.send_with_err().await {
Ok(body) => Ok(self.parse(body)),
Err(err) => Err(err),
}
}
pub fn parse(&self, xml: String) -> Vec<FolderContent> {
let cursor = Cursor::new(xml);
let parser = EventReader::new(cursor);
let mut should_get = false;
let mut values: Vec<FolderContent> = vec![];
let mut iter = self.xml_balises.iter();
let mut val = iter.next();
let mut content = FolderContent::new();
for event in parser {
match event {
Ok(XmlEvent::StartElement { name, .. }) => {
if let Some(v) = val.clone() {
should_get = &name.local_name == v;
} else {
// end of balises to get then start over for next object
values.push(content.clone());
iter = self.xml_balises.iter();
val = iter.next();
content = FolderContent::new();
if let Some(v) = val.clone() {
should_get = &name.local_name == v;
}
}
}
Ok(XmlEvent::Characters(text)) => {
if !text.trim().is_empty() && should_get {
match val.unwrap().as_str() {
"href" => {
content.href = Some(text.clone());
content.relative_s = Some(get_relative_s(text, &(self.api_props.clone().unwrap())));
dbg!(content.relative_s.clone());
},
_ => (),
}
val = iter.next()
}
}
Ok(XmlEvent::EndElement { .. }) => {
should_get = false;
}
Err(e) => {
eprintln!("Error: {}", e);
break;
}
_ => {}
}
}
values
}
}

106
src/services/req_props.rs
View File

@@ -1,20 +1,47 @@
use crate::services::api::{ApiBuilder, ApiError};
use crate::utils::api::get_relative_s;
use xml::reader::{EventReader, XmlEvent};
use std::io::Cursor;
use reqwest::{Method, Response, Error};
use crate::utils::api::ApiProps;
pub struct ObjProps {
pub href: Option<String>,
pub relative_s: Option<String>,
}
impl Clone for ObjProps {
fn clone(&self) -> Self {
ObjProps {
href: self.href.clone(),
relative_s: self.relative_s.clone(),
}
}
}
impl ObjProps {
fn new() -> Self {
ObjProps {
href: None,
relative_s: None,
}
}
}
pub struct ReqProps {
api_builder: ApiBuilder,
xml_list: Vec<String>,
xml_balises: Vec<String>,
xml_payload: String,
api_props: Option<ApiProps>
}
impl ReqProps {
pub fn new() -> Self {
ReqProps {
api_builder: ApiBuilder::new(),
xml_list: vec![],
xml_balises: vec![],
xml_payload: String::new(),
api_props: None,
}
}
@@ -23,38 +50,49 @@ impl ReqProps {
self
}
pub fn set_request(&mut self, p: &str, api_props: &ApiProps) -> &mut ReqProps {
self.api_props = Some(api_props.clone());
self.api_builder.set_req(Method::from_bytes(b"PROPFIND").unwrap(), p, api_props);
self
}
pub fn gethref(&mut self) -> &mut ReqProps {
self.xml_balises.push(String::from("href"));
self
}
pub fn getlastmodified(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("getlastmodified"));
self.xml_balises.push(String::from("getlastmodified"));
self.xml_payload.push_str(r#"<d:getlastmodified/>"#);
self
}
pub fn getcontentlenght(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("getcontentlength"));
self.xml_balises.push(String::from("getcontentlength"));
self.xml_payload.push_str(r#"<d:getcontentlength/>"#);
self
}
pub fn _getcontenttype(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("getcontenttype"));
self.xml_balises.push(String::from("getcontenttype"));
self.xml_payload.push_str(r#"<d:getcontenttype/>"#);
self
}
pub fn _getpermissions(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("permissions"));
self.xml_balises.push(String::from("permissions"));
self.xml_payload.push_str(r#"<oc:permissions/>"#);
self
}
pub fn _getressourcetype(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("resourcetype"));
self.xml_balises.push(String::from("resourcetype"));
self.xml_payload.push_str(r#"<d:resourcetype/>"#);
self
}
pub fn _getetag(&mut self) -> &mut ReqProps {
self.xml_list.push(String::from("getetag"));
self.xml_balises.push(String::from("getetag"));
self.xml_payload.push_str(r#"<d:getetag/>"#);
self
}
@@ -72,24 +110,44 @@ impl ReqProps {
self.api_builder.send().await
}
pub async fn send_with_err(&mut self) -> Result<Vec<String>, ApiError> {
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(self.parse(body))
Ok(body)
} else {
Err(ApiError::IncorrectRequest(res))
}
}
pub fn parse(&self, xml: String) -> Vec<String> {
pub async fn send_req_multiple(&mut self) -> Result<Vec<ObjProps>, ApiError> {
match self.send_with_err().await {
Ok(body) => Ok(self.parse(body, true)),
Err(err) => Err(err),
}
}
pub async fn send_req_single(&mut self) -> Result<ObjProps, ApiError> {
match self.send_with_err().await {
Ok(body) => {
let objs = self.parse(body, false);
let obj = objs[0].clone();
Ok(obj)
},
Err(err) => Err(err),
}
}
fn parse(&self, xml: String, multiple: bool) -> Vec<ObjProps> {
let cursor = Cursor::new(xml);
let parser = EventReader::new(cursor);
let mut should_get = false;
let mut values: Vec<String> = vec![];
let mut iter = self.xml_list.iter();
let mut values: Vec<ObjProps> = vec![];
let mut iter = self.xml_balises.iter();
let mut val = iter.next();
let mut content = ObjProps::new();
for event in parser {
match event {
@@ -97,12 +155,30 @@ impl ReqProps {
if let Some(v) = val.clone() {
should_get = &name.local_name == v;
} else {
break;
// end of balises to get then start over for
// next object if want multiple
if multiple {
values.push(content.clone());
iter = self.xml_balises.iter();
val = iter.next();
content = ObjProps::new();
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);
match val.unwrap().as_str() {
"href" => {
content.href = Some(text.clone());
content.relative_s = Some(get_relative_s(text, &(self.api_props.clone().unwrap())));
},
_ => (),
}
val = iter.next()
}
}