use crate::Error;
use base64::prelude::*;
use std::io::{Cursor, Read};
use zip::ZipArchive;
use crate::errors::XmlError;
use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, Serialize)]
pub struct CheckRetrieveStatusResponse {
done: bool,
#[serde(rename = "errorMessage")]
error_message: Option<String>,
#[serde(rename = "errorStatusCode")]
error_status_code: Option<String>,
file_properties: Vec<FileProperties>,
id: Option<String>,
status: String,
success: bool,
zip_file: Option<Vec<u8>>,
}
impl CheckRetrieveStatusResponse {
pub fn from_xml(xml: &str) -> Result<Self, XmlError> {
let doc = roxmltree::Document::parse(xml)?;
let body = find_element(doc.root_element(), "Body")?;
let check_retrieve_status_response = find_element(body, "checkRetrieveStatusResponse")?;
let result = find_element(check_retrieve_status_response, "result")?;
let mut file_properties = vec![];
for element in find_elements(result, "fileProperties") {
file_properties.push(FileProperties::from_xml(element)?);
}
Ok(Self {
done: parse_bool_child(result, "done")?,
error_message: None,
error_status_code: None,
file_properties,
id: match parse_text_child(result, "id") {
Ok(id) => Some(id),
Err(_) => None,
},
status: parse_text_child(result, "status")?,
success: parse_bool_child(result, "success")?,
zip_file: Some(
BASE64_STANDARD.decode(parse_text_child(result, "zipFile")?).unwrap(), ),
})
}
pub fn done(&self) -> bool {
self.done
}
pub fn get_files(mut self) -> Result<Vec<FileProperties>, Error> {
match self.zip_file {
Some(zip_file) => {
let mut cursor = Cursor::new(zip_file);
let mut archive = ZipArchive::new(&mut cursor)?;
for file_props in &mut self.file_properties {
let mut file = match archive.by_name(&file_props.file_name) {
Ok(file) => file,
Err(_) => continue,
};
let mut contents = Vec::new();
file.read_to_end(&mut contents).unwrap();
file_props.contents = Some(contents);
}
}
None => return Ok(vec![]),
}
Ok(self.file_properties)
}
pub fn get_id(&self) -> Option<&str> {
self.id.as_deref()
}
pub fn get_status(&self) -> &str {
&self.status
}
pub fn get_zip_file(&self) -> Option<&[u8]> {
self.zip_file.as_deref()
}
pub fn is_success(&self) -> bool {
self.success
}
}
#[derive(Debug, Deserialize, Serialize)]
pub struct FileProperties {
#[serde(rename = "createdById")]
created_by_id: String,
#[serde(rename = "createdByName")]
created_by_name: String,
#[serde(rename = "createdDate")]
created_date: String,
#[serde(rename = "fileName")]
file_name: String,
#[serde(rename = "fullName")]
full_name: String,
#[serde(rename = "id")]
id: Option<String>,
#[serde(rename = "lastModifiedById")]
last_modified_by_id: String,
#[serde(rename = "lastModifiedByName")]
last_modified_by_name: String,
#[serde(rename = "lastModifiedDate")]
last_modified_date: String,
#[serde(rename = "manageableState")]
manageable_state: String,
#[serde(rename = "type")]
file_type: String,
contents: Option<Vec<u8>>,
}
impl FileProperties {
fn from_xml(node: roxmltree::Node) -> Result<Self, XmlError> {
Ok(Self {
created_by_id: parse_text_child(node, "createdById")?,
created_by_name: parse_text_child(node, "createdByName")?,
created_date: parse_text_child(node, "createdDate")?,
file_name: parse_text_child(node, "fileName")?,
full_name: parse_text_child(node, "fullName")?,
id: match parse_text_child(node, "id") {
Ok(id) => Some(id),
Err(_) => None,
},
last_modified_by_id: parse_text_child(node, "lastModifiedById")?,
last_modified_by_name: parse_text_child(node, "lastModifiedByName")?,
last_modified_date: parse_text_child(node, "lastModifiedDate")?,
manageable_state: parse_text_child(node, "manageableState")?,
file_type: parse_text_child(node, "type")?,
contents: None,
})
}
pub fn get_contents(&self) -> Option<&[u8]> {
self.contents.as_deref()
}
}
fn find_element<'a, 'input>(
root: roxmltree::Node<'a, 'input>,
local_name: &'static str,
) -> Result<roxmltree::Node<'a, 'input>, XmlError> {
root.descendants()
.find(|node| node.is_element() && node.tag_name().name() == local_name)
.ok_or(XmlError::MissingElement(local_name))
}
fn find_elements<'a, 'input>(
root: roxmltree::Node<'a, 'input>,
local_name: &'static str,
) -> Vec<roxmltree::Node<'a, 'input>> {
root.descendants()
.filter(|node| node.is_element() && node.tag_name().name() == local_name)
.collect()
}
fn parse_text_child<'a, 'input>(
root: roxmltree::Node<'a, 'input>,
local_name: &'static str,
) -> Result<String, XmlError> {
let node = find_element(root, local_name)?;
node.text()
.map(ToOwned::to_owned)
.ok_or(XmlError::MissingText(local_name))
}
fn parse_bool_child<'a, 'input>(root: roxmltree::Node<'a, 'input>, local_name: &'static str) -> Result<bool, XmlError> {
let value = parse_text_child(root, local_name)?;
value.parse::<bool>().map_err(|_| XmlError::InvalidBool {
element: local_name,
value,
})
}