use std::fmt::Debug;
use serde::de::DeserializeOwned;
use serde::Serialize;
use crate::client::responses::response_error::ResponseError;
use crate::Error;
use crate::primary_types::{SObject, SObjectOwner};
use crate::rest_api::{handle_json_response, RestApi};
use crate::rest_api::responses::sobject_create_response::SObjectCreateResponse;
use crate::rest_api::responses::sobject_create_request::SObjectCreateRequest;
impl RestApi {
pub async fn create<T: Serialize + Debug + SObject + SObjectOwner + Clone>(
&mut self,
records: &mut Vec<T>,
all_or_none: bool
) -> Result<Vec<SObjectCreateResponse>, Error> {
if records.len() > 200 {
return Err(Error::ResponseError(ResponseError::new("Max 200 records per request".to_string())));
} else if records.len() == 0 {
return Ok(Vec::new());
}
for record in records.iter_mut() {
if record.get_owner_id().is_none() {
record.set_owner_id(self.client.get_user_id().as_deref().map(str::to_string).as_deref());
}
}
let resource_url = format!("{}/composite/sobjects", self.client.base_version_path()?);
let body = SObjectCreateRequest::new(records.clone(), all_or_none);
let response = self.client.post(resource_url, body, vec![]).await?;
let responses : Vec<SObjectCreateResponse> = handle_json_response(response).await?;
if responses.len() != records.len() {
return Err(
Error::ResponseError(
ResponseError::new(
format!("Expected the same amount of responses, send {}, response {}", responses.len(), records.len()))))
};
for i in 0..responses.len() {
let id = &responses.get(i).unwrap().id;
let record = records.iter_mut().nth(i).unwrap();
record.set_id(Some(id));
}
Ok(responses)
}
pub async fn sobject_by_ids<T: Serialize + DeserializeOwned + Debug + SObject>(
&mut self,
object_name: &str,
ids: Vec<&str>,
fields: Vec<&str>
) -> Result<Vec<T>, Error> {
let url = format!("{}/composite/sobjects/{}", self.client.base_version_path()?, object_name);
let params = vec![("fields", fields.join(",")), ("ids", ids.join(","))];
let response = self.client.post(url, params, vec![]).await?;
let responses: Vec<Option<T>> = handle_json_response(response).await?;
Ok(responses.into_iter().filter_map(|r| r).collect())
}
}