use crate::client::Client;
use crate::errors::Error;
use crate::metadata_api::metadata_retriever::MetadataRetriever;
use crate::metadata_api::responses::async_result::AsyncResult;
use crate::metadata_api::responses::cancel_request::CancelRequest;
use crate::metadata_api::responses::check_retrieve_status_response::CheckRetrieveStatusResponse;
use crate::metadata_api::responses::deploy_response::DeployResponse;
use crate::rest_api::responses::error_response::ErrorResponse;
use log::{debug, trace};
use metadata_deployer::MetadataDeployer;
use reqwest::{Response, multipart};
use rustsf_auth::SalesforceCredentials;
use serde::de::DeserializeOwned;
use std::collections::HashMap;
pub mod metadata_deployer;
pub mod metadata_retriever;
pub mod responses;
const METADATA_NAMESPACE: &str = "http://soap.sforce.com/2006/04/metadata";
const ENVELOPE_NAMESPACE: &str = "http://schemas.xmlsoap.org/soap/envelope/";
pub struct MetadataApi {
client: Client,
}
impl MetadataApi {
pub async fn new(credentials: SalesforceCredentials) -> Result<Self, Error> {
Ok(Self {
client: Client::new(credentials).await?,
})
}
pub async fn cancel(&self, deploy_request_id: &str) -> Result<DeployResponse, Error> {
let url = format!(
"{}/metadata/deployRequest/{}",
self.client.services_data_version_path(),
deploy_request_id,
);
let response = self.client.patch(&url, CancelRequest::new(), &HashMap::new()).await?;
handle_json_response(response).await
}
pub async fn deploy(&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 url = format!("{}/metadata/deployRequest", self.client.services_data_version_path());
let response = self
.client
.post_multipart(
&url,
&HashMap::new(),
form,
)
.await?;
handle_json_response(response).await
}
pub fn new_deployment_request(&self) -> MetadataDeployer {
MetadataDeployer::new()
}
pub fn new_retrieval_request(&self) -> MetadataRetriever {
MetadataRetriever::new()
}
pub async fn retrieve(&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.client.access_token().await?),
crate::client::DEFAULT_API_VERSION,
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(&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.client.access_token().await?),
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(&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_json(
format!(
"{}/metadata/deployRequest/{}",
self.client.services_data_version_path(),
deploy_request_id
),
¶ms,
&HashMap::new(),
)
.await?;
handle_json_response(response).await
}
}
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::Salesforce(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(); debug!("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<S: AsRef<str>>(value: S) -> String {
value
.as_ref()
.replace('&', "&")
.replace('<', "<")
.replace('>', ">")
.replace('"', """)
.replace('\'', "'")
}