use crate::client::Client;
use crate::errors::Error;
use crate::rest_api::responses::error_response::ErrorResponse;
use crate::rest_api::responses::query_response::QueryResponse;
use crate::tooling_api::responses::create_result::CreateResult;
use crate::tooling_api::responses::execute_anonymous_result::ExecuteAnonymousResult;
use reqwest::Response;
use rustsf_auth::SalesforceCredentials;
use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;
use std::collections::HashMap;
pub mod primary_types;
pub mod responses;
pub mod schema;
pub struct ToolingApi {
pub(crate) client: Client,
}
impl ToolingApi {
pub async fn new(credentials: SalesforceCredentials) -> Result<Self, Error> {
Ok(Self {
client: Client::new(credentials).await?,
})
}
pub fn org_id(&self) -> Option<&str> {
self.client.user_id()
}
pub fn user_id(&self) -> Option<&str> {
self.client.user_id()
}
pub async fn execute_anonymous(&self, apex_code: &str) -> Result<ExecuteAnonymousResult, Error> {
let url = format!("{}/executeAnonymous/", self.base_path()?);
let params = vec![("anonymousBody".to_string(), apex_code.to_string())];
let response = self.client.get_json(&url, ¶ms, &HashMap::new()).await?;
if response.status().is_success() {
Ok(response.json::<ExecuteAnonymousResult>().await?)
} else {
let errors: Vec<ErrorResponse> = response.json().await?;
Err(Error::Other(format!("Errors: {:?}", errors)))
}
}
pub async fn get_latest_apex_logs(&self, limit: u32) -> Result<Vec<schema::apex_log::ApexLog>, Error> {
match self
.query(&format!(
"SELECT {} FROM {} ORDER BY StartTime DESC LIMIT {}",
schema::apex_log::FIELD_NAMES.join(","),
schema::apex_log::SOBJECT_NAME,
limit
))
.await
{
Ok(query_result) => {
let mut logs = Vec::new();
for record in query_result.records {
logs.push(serde_json::from_value::<schema::apex_log::ApexLog>(record)?);
}
Ok(logs)
}
Err(error) => Err(error),
}
}
pub async fn get_apex_log_body(&self, log_id: &str) -> Result<String, Error> {
let url = format!(
"{}/sobjects/ApexLog/{}/Body",
self.client.services_data_version_path(),
log_id
);
let params: Vec<String> = Vec::new();
let response = self.client.get_json(&url, ¶ms, &HashMap::new()).await?;
if response.status().is_success() {
Ok(response.text().await?)
} else {
let errors: Vec<ErrorResponse> = response.json().await?;
Err(Error::Other(format!("Errors: {:?}", errors)))
}
}
pub async fn get_trace_flags(&self, user_id: &str) -> Result<Vec<schema::trace_flag::TraceFlag>, Error> {
match self
.query(&format!(
"SELECT {} FROM {} WHERE TracedEntityId = '{}' AND LogType = 'DEVELOPER_LOG'",
schema::trace_flag::FIELD_NAMES.join(","),
schema::trace_flag::SOBJECT_NAME,
user_id
))
.await
{
Ok(query_result) => {
let mut records = Vec::new();
for record in query_result.records {
records.push(serde_json::from_value::<schema::trace_flag::TraceFlag>(record)?);
}
Ok(records)
}
Err(error) => Err(error),
}
}
pub async fn create_trace_flag<T: Serialize + std::fmt::Debug>(&self, record: T) -> Result<String, Error> {
match self.create("TraceFlag", record).await {
Ok(response) => {
let result = serde_json::from_value::<CreateResult>(response)?;
Ok(result.id)
}
Err(error) => return Err(error),
}
}
pub async fn update_trace_flag<T: Serialize + std::fmt::Debug>(
&self,
id: &str, params: T,
) -> Result<(), Error> {
self.update("TraceFlag", id, params).await
}
pub async fn get_debug_level(&self, developer_name: &str) -> Result<Vec<schema::debug_level::DebugLevel>, Error> {
match self
.query(&format!(
"SELECT {} FROM {} WHERE DeveloperName = '{}'",
schema::debug_level::FIELD_NAMES.join(","),
schema::debug_level::SOBJECT_NAME,
developer_name
))
.await
{
Ok(result) => {
let mut records = Vec::new();
for record in result.records {
records.push(serde_json::from_value::<schema::debug_level::DebugLevel>(record)?);
}
Ok(records)
}
Err(error) => Err(error),
}
}
pub async fn create_debug_level<T: Serialize + std::fmt::Debug>(&self, params: T) -> Result<String, Error> {
let response = self.create("DebugLevel", params).await?;
let result = serde_json::from_value::<CreateResult>(response)?;
Ok(result.id)
}
pub async fn query<T: DeserializeOwned>(&self, query: &str) -> Result<QueryResponse<T>, Error> {
let query_url = format!("{}/query/", self.base_path()?);
let params = vec![("q".to_string(), query.to_string())];
let response = self.client.get_json(&query_url, ¶ms, &HashMap::new()).await?;
handle_json_response(response).await
}
pub async fn find_by_id(&self, sobject_name: &str, id: &str) -> Result<Value, Error> {
let url = format!("{}/sobjects/{}/{}", self.base_path()?, sobject_name, id);
let params: Vec<String> = Vec::new();
let response = self.client.get_json(&url, ¶ms, &HashMap::new()).await?;
handle_json_response(response).await
}
pub async fn create<T: Serialize + std::fmt::Debug>(&self, object_name: &str, params: T) -> Result<Value, Error> {
let url = format!("{}/sobjects/{}", self.base_path()?, object_name);
let response = self.client.post_json(&url, ¶ms, &HashMap::new()).await?;
handle_json_response(response).await
}
pub async fn update<T: Serialize + std::fmt::Debug>(
&self,
object_name: &str,
id: &str,
params: T,
) -> Result<(), Error> {
let url = format!("{}/sobjects/{}/{}", self.base_path()?, object_name, id);
let response = self.client.patch(&url, ¶ms, &HashMap::new()).await?;
handle_empty_response(response).await
}
pub async fn destroy(&self, sobject_name: &str, id: &str) -> Result<(), Error> {
let url = format!("{}/sobjects/{}/{}", self.base_path()?, sobject_name, id);
let response = self.client.delete(&url, &HashMap::new()).await?;
handle_empty_response(response).await
}
fn base_path(&self) -> Result<String, Error> {
Ok(format!("{}/tooling", self.client.services_data_version_path()))
}
}
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::Other(format!("Errors: {:?}", errors)))
}
}
async fn handle_empty_response(response: reqwest::Response) -> Result<(), Error> {
if response.status().is_success() {
Ok(())
} else {
let errors: Vec<ErrorResponse> = response.json().await?;
Err(Error::Other(format!("Errors: {:?}", errors)))
}
}