use crate::metadata_api::responses::deploy_response::DeployResponse;
use crate::rest_api::responses::error_response::ErrorResponse;
use crate::{Client, Error};
use reqwest::{Response, multipart};
use serde::Serialize;
use serde::de::DeserializeOwned;
use std::collections::HashMap;
use log::{debug, trace};
use crate::metadata_api::responses::cancel_request::CancelRequest;
use metadata_deployer::MetadataDeployer;
use crate::metadata_api::metadata_retriever::MetadataRetriever;
use crate::metadata_api::responses::async_result::AsyncResult;
use crate::metadata_api::responses::check_retrieve_status_response::CheckRetrieveStatusResponse;
pub mod responses;
pub mod metadata_deployer;
pub mod metadata_retriever;
const METADATA_NAMESPACE: &str = "http://soap.sforce.com/2006/04/metadata";
const ENVELOPE_NAMESPACE: &str = "http://schemas.xmlsoap.org/soap/envelope/";
pub(crate) mod errors;
pub struct MetadataApi {
client: Client,
}
impl MetadataApi {
pub fn new(client: Client) -> Self {
MetadataApi { client }
}
pub async fn cancel(&mut self, deploy_request_id: &str) -> Result<DeployResponse, Error> {
let response = self
.client
.patch(
format!(
"{}/metadata/deployRequest/{}",
self.client.base_version_path()?,
deploy_request_id,
),
CancelRequest::new(),
)
.await?;
handle_json_response(response).await
}
pub async fn deploy(&mut self, request: MetadataDeployer) -> Result<DeployResponse, Error> {
let form = multipart::Form::new()
.part(
"json",
multipart::Part::bytes(request.get_deploy_request_json()?.into_bytes())
.mime_str("application/json")?,
)
.part(
"zipfile",
multipart::Part::bytes(request.get_zip_file()?)
.file_name("deploy.zip")
.mime_str("application/zip")?,
);
let response = self
.client
.post_multipart(
format!(
"{}/metadata/deployRequest",
self.client.base_version_path()?
),
vec![],
form,
)
.await?;
handle_json_response(response).await
}
pub fn new_deployment_request(&self) -> MetadataDeployer {
MetadataDeployer::new(&self.client)
}
pub fn new_retrieval_request(&self) -> MetadataRetriever {
MetadataRetriever::new()
}
pub async fn retrieve(&mut self, request: MetadataRetriever) -> Result<AsyncResult, Error> {
let body = format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="{}" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="{}">
<soapenv:Header><SessionHeader><sessionId>{}</sessionId></SessionHeader></soapenv:Header>
<soapenv:Body>
<retrieve>
<retrieveRequest>
<apiVersion>{}</apiVersion>
<unpackaged>{}</unpackaged>
</retrieveRequest>
</retrieve>
</soapenv:Body>
</soapenv:Envelope>"#,
ENVELOPE_NAMESPACE,
METADATA_NAMESPACE,
escape_xml(self.session_id()?),
self.client.version_number()?,
request.get_package(),
);
let response = self.client.post_soap("retrieve", body).await?;
let xml = response.text().await?;
trace!("Soap Metadata API retrieve response: {}", xml );
Ok(AsyncResult::from_xml(&xml)?)
}
pub async fn retrieve_status(&mut self, id: &str) -> Result<CheckRetrieveStatusResponse, Error> {
let body = format!(
r#"<?xml version="1.0" encoding="UTF-8"?>
<soapenv:Envelope xmlns:soapenv="{}" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="{}">
<soapenv:Header><SessionHeader><sessionId>{}</sessionId></SessionHeader></soapenv:Header>
<soapenv:Body>
<checkRetrieveStatus>
<id>{}</id>
<includeZip>true</includeZip>
</checkRetrieveStatus>
</soapenv:Body>
</soapenv:Envelope>"#,
ENVELOPE_NAMESPACE,
METADATA_NAMESPACE,
escape_xml(self.session_id()?),
id,
);
let response = self.client.post_soap("retrieve", body).await?;
let xml = response.text().await?;
trace!("Soap Metadata API retrieve status response: {}", xml );
Ok(CheckRetrieveStatusResponse::from_xml(&xml)?)
}
pub async fn deploy_status(
&mut self,
deploy_request_id: &str,
include_details: bool,
) -> Result<DeployResponse, Error> {
let mut params: Vec<(String, String)> = vec![];
if include_details {
params.push(("includeDetails".to_string(), "true".to_string()));
}
let response = self
.client
.get(
format!(
"{}/metadata/deployRequest/{}",
self.client.base_version_path()?,
deploy_request_id
),
params,
vec![],
)
.await?;
handle_json_response(response).await
}
fn session_id(&self) -> Result<&str, Error> {
self.client.access_token_value().ok_or(Error::NotLoggedIn)
}
}
async fn handle_json_response<T: DeserializeOwned>(response: Response) -> Result<T, Error> {
if response.status().is_success() {
Ok(response.json().await?)
} else {
let errors: Vec<ErrorResponse> = response.json().await?;
Err(Error::ErrorResponses(errors))
}
}
async fn handle_raw_response(response: Response) -> Result<String, Error> {
if response.status().is_success() {
Ok(response.text().await?)
} else {
let errors: Vec<ErrorResponse> = response.json().await?;
Err(Error::ErrorResponses(errors))
}
}
fn generate_package_xml(version: &str, elements: &HashMap<String, Vec<String>>) -> String {
let header = r#"<?xml version="1.0" encoding="UTF-8"?>
<Package xmlns="http://soap.sforce.com/2006/04/metadata">"#;
let footer = format!(" <version>{}</version>\n</Package>", version);
let mut metadata_type = "".to_string();
for (metadata, objects) in elements {
let members = objects
.iter()
.map(|object| format!(" <members>{}</members>", object))
.collect::<Vec<String>>()
.join("\n");
metadata_type.push_str(
format!(
"<types>\n{}\n <name>{}</name>\n </types>\n",
members, metadata
)
.as_str(),
);
}
format!("{}\n{}\n{}", header, metadata_type, footer)
}
fn add_file_to_package(
package: &mut HashMap<String, Vec<String>>,
metadata_type: &str,
file_name: &str,
) {
let package_file_name = file_name.split(".").next().unwrap().to_string(); println!("Adding package file: {}", package_file_name);
package
.entry(metadata_type.to_string())
.or_insert_with(Vec::new)
.push(package_file_name);
}
pub struct Deployment {}
fn escape_xml(value: &str) -> String {
value
.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}
#[cfg(test)]
mod tests;