use serde_json::{Map, Value};
use super::{LoopsClient, Page, check};
use crate::error::Result;
use crate::generated::{
ChangeWorkflowMailingListRequestParams, ChangeWorkflowMailingListResponse,
ChangeWorkflowMailingListResponseEnum, CreateWorkflowRequest, CreateWorkflowRequestParams,
CreateWorkflowResponse, DeleteWorkflowRequestParams, DeleteWorkflowResponse,
GetWorkflowRequest, GetWorkflowResponse, ListWorkflowsRequest, ListWorkflowsRequestQuery,
ListWorkflowsResponse, ListWorkflowsResponseEnum, SimplifiedWorkflow,
UpdateWorkflowPropertiesRequestParams, UpdateWorkflowPropertiesResponse,
WorkflowQueuedContactPolicy,
};
use crate::routes::Route;
impl LoopsClient {
pub async fn list_workflows(&self, page: Page) -> Result<ListWorkflowsResponse> {
const ACTION: &str = "list workflows";
let query = ListWorkflowsRequestQuery {
per_page: page.per_page_param(),
cursor: page.cursor,
};
let raw = self
.send(Route::ListWorkflows, &[], |r| r.query(&query))
.await?;
match raw
.parse(ACTION, ListWorkflowsRequest::parse_response)
.await?
{
ListWorkflowsResponseEnum::Ok(workflows) => Ok(workflows),
_ => Err(raw.unexpected(ACTION)),
}
}
pub async fn get_workflow(&self, workflow_id: &str) -> Result<SimplifiedWorkflow> {
const ACTION: &str = "get workflow";
let raw = self.send(Route::GetWorkflow, &[workflow_id], |r| r).await?;
match raw
.parse(ACTION, GetWorkflowRequest::parse_response)
.await?
{
GetWorkflowResponse::Ok(workflow) => Ok(workflow),
_ => Err(raw.unexpected(ACTION)),
}
}
pub async fn create_workflow(
&self,
name: &str,
description: Option<&str>,
mailing_list_id: Option<&str>,
) -> Result<SimplifiedWorkflow> {
const ACTION: &str = "create workflow";
let body = CreateWorkflowRequest {
name: name.to_owned(),
description: description.map(str::to_owned),
mailing_list_id: mailing_list_id.map(str::to_owned),
};
check(&body)?;
let raw = self
.send(Route::CreateWorkflow, &[], |r| r.json(&body))
.await?;
match raw
.parse(ACTION, CreateWorkflowRequestParams::parse_response)
.await?
{
CreateWorkflowResponse::Ok(workflow) => Ok(workflow),
_ => Err(raw.unexpected(ACTION)),
}
}
pub async fn update_workflow(
&self,
workflow_id: &str,
expected_revision_id: Option<&str>,
name: Option<&str>,
description: Option<&str>,
) -> Result<SimplifiedWorkflow> {
const ACTION: &str = "update workflow";
let mut body = revision_body(expected_revision_id);
if let Some(name) = name {
body.insert("name".to_owned(), Value::from(name));
}
if let Some(description) = description {
body.insert("description".to_owned(), Value::from(description));
}
let raw = self
.send(Route::UpdateWorkflow, &[workflow_id], |r| r.json(&body))
.await?;
match raw
.parse(
ACTION,
UpdateWorkflowPropertiesRequestParams::parse_response,
)
.await?
{
UpdateWorkflowPropertiesResponse::Ok(workflow) => Ok(workflow),
_ => Err(raw.unexpected(ACTION)),
}
}
pub async fn change_workflow_mailing_list(
&self,
workflow_id: &str,
expected_revision_id: Option<&str>,
mailing_list_id: Option<&str>,
dry_run: Option<bool>,
queued_contact_policy: Option<WorkflowQueuedContactPolicy>,
) -> Result<ChangeWorkflowMailingListResponse> {
const ACTION: &str = "change workflow mailing list";
let mut body = revision_body(expected_revision_id);
body.insert(
"mailingListId".to_owned(),
mailing_list_id.map_or(Value::Null, Value::from),
);
if let Some(dry_run) = dry_run {
body.insert("dryRun".to_owned(), Value::Bool(dry_run));
}
if let Some(policy) = queued_contact_policy {
body.insert(
"queuedContactPolicy".to_owned(),
queued_contact_policy_value(&policy),
);
}
let raw = self
.send(Route::ChangeWorkflowMailingList, &[workflow_id], |r| {
r.json(&body)
})
.await?;
match raw
.parse(
ACTION,
ChangeWorkflowMailingListRequestParams::parse_response,
)
.await?
{
ChangeWorkflowMailingListResponseEnum::Ok(response) => Ok(response),
_ => Err(raw.unexpected(ACTION)),
}
}
pub async fn delete_workflow(
&self,
workflow_id: &str,
expected_revision_id: Option<&str>,
confirm_delete: Option<bool>,
) -> Result<bool> {
const ACTION: &str = "delete workflow";
let mut body = revision_body(expected_revision_id);
if let Some(confirm) = confirm_delete {
body.insert("confirmDelete".to_owned(), Value::Bool(confirm));
}
let raw = self
.send(Route::DeleteWorkflow, &[workflow_id], |r| r.json(&body))
.await?;
match raw
.parse(ACTION, DeleteWorkflowRequestParams::parse_response)
.await?
{
DeleteWorkflowResponse::NoContent => Ok(true),
_ => Err(raw.unexpected(ACTION)),
}
}
}
pub(super) fn revision_body(expected_revision_id: Option<&str>) -> Map<String, Value> {
let mut body = Map::new();
body.insert(
"expectedRevisionId".to_owned(),
expected_revision_id.map_or(Value::Null, Value::from),
);
body
}
pub(super) fn queued_contact_policy_value(policy: &WorkflowQueuedContactPolicy) -> Value {
Value::from(match policy {
WorkflowQueuedContactPolicy::Fail => "fail",
WorkflowQueuedContactPolicy::Discard => "discard",
})
}