use crate::errors::Error;
use crate::metadata_api::responses::deploy_options::DeployOptions;
use crate::metadata_api::responses::deploy_request::DeployRequest;
use crate::metadata_api::{add_file_to_package, generate_package_xml};
use s_zip::{SZipError, StreamingZipWriter};
use std::collections::HashMap;
use std::io::Cursor;
use log::debug;
pub struct MetadataDeployer {
options: DeployOptions,
writer: StreamingZipWriter<Cursor<Vec<u8>>>,
package: HashMap<String, Vec<String>>,
pre_destructive: HashMap<String, Vec<String>>,
post_destructive: HashMap<String, Vec<String>>,
}
impl MetadataDeployer {
pub fn new() -> Self {
MetadataDeployer {
options: DeployOptions::new(),
writer: StreamingZipWriter::from_writer(Cursor::new(Vec::new())).unwrap(),
package: HashMap::new(),
pre_destructive: HashMap::new(),
post_destructive: HashMap::new(),
}
}
pub fn set_options(&mut self, options: DeployOptions) {
self.options = options;
}
pub fn add(
&mut self,
metadata_type: &str, folder: &str, file_name: &str, content: &[u8], file_name_xml: Option<&str>, content_xml: Option<&[u8]>, ) -> Result<&mut Self, Error> {
self.add_file_to_zip(folder, file_name, content)
.map_err(|e| Error::CompressionError(e.to_string()))?;
match (file_name_xml, content_xml) {
(Some(file_name_xml), Some(content_xml)) => {
self.add_file_to_zip(folder, file_name, content)
.map_err(|e| Error::CompressionError(e.to_string()))?;
self.add_file_to_zip(folder, file_name_xml, content_xml)
.map_err(|e| Error::CompressionError(e.to_string()))?;
}
_ => {}
}
add_file_to_package(&mut self.package, metadata_type, file_name);
Ok(self)
}
pub fn delete_post(&mut self, metadata_type: &str, objects: Vec<&str>) -> &mut Self {
for file_name in objects {
add_file_to_package(&mut self.post_destructive, metadata_type, file_name);
}
self
}
pub fn delete_pre(&mut self, metadata_type: &str, objects: Vec<&str>) -> &mut Self {
for file_name in objects {
add_file_to_package(&mut self.pre_destructive, metadata_type, file_name);
}
self
}
fn add_file_to_zip(&mut self, folder: &str, file_name: &str, content: &[u8]) -> Result<(), SZipError> {
let filename = format!("{}/{}", folder, file_name);
self.writer.start_entry(filename.as_str())?;
self.writer.write_data(content)?;
Ok(())
}
fn add_package(&mut self, name: &str, content: HashMap<String, Vec<String>>) -> Result<(), Error> {
let package = generate_package_xml(crate::client::DEFAULT_API_VERSION, &content);
debug!("Adding package: {}\n{}", name, package);
self.writer
.start_entry(name)
.map_err(|e| Error::CompressionError(e.to_string()))?;
self.writer
.write_data(package.as_bytes())
.map_err(|e| Error::CompressionError(e.to_string()))?;
Ok(())
}
pub(crate) fn get_deploy_request_json(&self) -> Result<String, Error> {
let request = DeployRequest {
options: self.options.clone(),
};
serde_json::to_string(&request).map_err(|e| Error::Json(e))
}
pub(crate) fn get_zip_file(mut self) -> Result<Vec<u8>, Error> {
self.add_package("package.xml", self.package.clone())?;
if !self.pre_destructive.is_empty() {
self.add_package("destructiveChangesPre.xml", self.pre_destructive.clone())?;
}
if !self.post_destructive.is_empty() {
self.add_package("destructiveChangesPost.xml", self.post_destructive.clone())?;
}
Ok(self
.writer
.finish()
.map_err(|e| Error::CompressionError(e.to_string()))?
.into_inner())
}
}