babelforce-manager-sdk 0.46.0

/*
 * Manager API
 *
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 0.0.0-dev
 * Contact: support@babelforce.com
 * Generated by: https://openapi-generator.tech
 */

use super::{configuration, ContentType, Error};
use crate::gen::manager::{apis::ResponseContent, models};
use reqwest;
use serde::{de::Error as _, Deserialize, Serialize};

/// struct for typed errors of method [`create_agent_outbound_call`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateAgentOutboundCallError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_inbound_test_call`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateInboundTestCallError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_call`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCallError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_reporting_calls`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListReportingCallsError {
    UnknownValue(serde_json::Value),
}

/// Create an outbound call for the agent
pub async fn create_agent_outbound_call(
    configuration: &configuration::Configuration,
    id: &str,
    agent_outbound_call_request: models::AgentOutboundCallRequest,
) -> Result<models::CallItemResponse, Error<CreateAgentOutboundCallError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;
    let p_body_agent_outbound_call_request = agent_outbound_call_request;

    let uri_str = format!(
        "{}/api/v2/agents/{id}/calls",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_agent_outbound_call_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CallItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CallItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAgentOutboundCallError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Starts a synthetic test call from `fromNumber` to `toNumber` and runs it through the customer's call flows, so a configuration can be exercised end-to-end without a real caller. `duration` (seconds, default 60) bounds how long the simulated call stays up; an optional `session` map seeds call-session variables. Returns the created call in the single-item envelope `{ item: Call, message }`.
pub async fn create_inbound_test_call(
    configuration: &configuration::Configuration,
    create_test_call_request: models::CreateTestCallRequest,
) -> Result<models::CallItemResponse, Error<CreateInboundTestCallError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_test_call_request = create_test_call_request;

    let uri_str = format!("{}/api/v2/calls/test", configuration.base_path);
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_create_test_call_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CallItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CallItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateInboundTestCallError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a single call by its uuid in the single-item envelope `{ item: Call, success }`, or `404` if no call with that uuid exists for the customer.
pub async fn get_call(
    configuration: &configuration::Configuration,
    id: &str,
) -> Result<models::CallItemResponse, Error<GetCallError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_id = id;

    let uri_str = format!(
        "{}/api/v2/calls/{id}",
        configuration.base_path,
        id = crate::gen::manager::apis::urlencode(p_path_id)
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CallItemResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CallItemResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCallError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a paginated, filterable list of the customer's calls for reporting in the list envelope `{ items: Call[], pagination, success }`. Every filter is optional and combines with AND; each filter can also be supplied under a `filters.` prefix (e.g. `filters.state`) — the two forms are equivalent. Free-text `q` matches numbers, agent/queue name, conversation and session ids. Add `format=csv` to stream the result as a CSV download instead of JSON.
pub async fn list_reporting_calls(
    configuration: &configuration::Configuration,
    page: Option<i32>,
    max: Option<i32>,
    session_id: Option<&str>,
    conversation_id: Option<&str>,
    id: Option<models::ListReportingCallsIdParameter>,
    parent_id: Option<models::ListReportingCallsIdParameter>,
    r#type: Option<models::ListReportingCallsTypeParameter>,
    from: Option<&str>,
    from_number: Option<&str>,
    to: Option<models::ListReportingCallsToParameter>,
    to_number: Option<models::ListReportingCallsToParameter>,
    time_start: Option<i32>,
    time_end: Option<i32>,
    agent_id: Option<models::ListReportingCallsIdParameter>,
    q: Option<&str>,
    state: Option<models::ListReportingCallsStateParameter>,
    domain: Option<models::ListReportingCallsDomainParameter>,
    source: Option<models::ListReportingCallsSourceParameter>,
    finish_reason: Option<models::ListReportingCallsFinishReasonParameter>,
    anonymous: Option<bool>,
    filters_session_id: Option<&str>,
    filters_conversation_id: Option<&str>,
    filters_id: Option<models::ListReportingCallsIdParameter>,
    filters_parent_id: Option<models::ListReportingCallsIdParameter>,
    filters_type: Option<models::ListReportingCallsTypeParameter>,
    filters_from: Option<&str>,
    filters_from_number: Option<&str>,
    filters_to: Option<models::ListReportingCallsToParameter>,
    filters_to_number: Option<models::ListReportingCallsToParameter>,
    filters_time_start: Option<i32>,
    filters_time_end: Option<i32>,
    filters_agent_id: Option<models::ListReportingCallsIdParameter>,
    filters_q: Option<&str>,
    filters_state: Option<models::ListReportingCallsStateParameter>,
    filters_domain: Option<models::ListReportingCallsDomainParameter>,
    filters_source: Option<models::ListReportingCallsSourceParameter>,
    filters_finish_reason: Option<models::ListReportingCallsFinishReasonParameter>,
    filters_anonymous: Option<bool>,
) -> Result<models::PaginatedCallResponse, Error<ListReportingCallsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_page = page;
    let p_query_max = max;
    let p_query_session_id = session_id;
    let p_query_conversation_id = conversation_id;
    let p_query_id = id;
    let p_query_parent_id = parent_id;
    let p_query_type = r#type;
    let p_query_from = from;
    let p_query_from_number = from_number;
    let p_query_to = to;
    let p_query_to_number = to_number;
    let p_query_time_start = time_start;
    let p_query_time_end = time_end;
    let p_query_agent_id = agent_id;
    let p_query_q = q;
    let p_query_state = state;
    let p_query_domain = domain;
    let p_query_source = source;
    let p_query_finish_reason = finish_reason;
    let p_query_anonymous = anonymous;
    let p_query_filters_session_id = filters_session_id;
    let p_query_filters_conversation_id = filters_conversation_id;
    let p_query_filters_id = filters_id;
    let p_query_filters_parent_id = filters_parent_id;
    let p_query_filters_type = filters_type;
    let p_query_filters_from = filters_from;
    let p_query_filters_from_number = filters_from_number;
    let p_query_filters_to = filters_to;
    let p_query_filters_to_number = filters_to_number;
    let p_query_filters_time_start = filters_time_start;
    let p_query_filters_time_end = filters_time_end;
    let p_query_filters_agent_id = filters_agent_id;
    let p_query_filters_q = filters_q;
    let p_query_filters_state = filters_state;
    let p_query_filters_domain = filters_domain;
    let p_query_filters_source = filters_source;
    let p_query_filters_finish_reason = filters_finish_reason;
    let p_query_filters_anonymous = filters_anonymous;

    let uri_str = format!("{}/api/v2/calls/reporting", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_max {
        req_builder = req_builder.query(&[("max", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_session_id {
        req_builder = req_builder.query(&[("sessionId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_conversation_id {
        req_builder = req_builder.query(&[("conversationId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_id {
        req_builder = req_builder.query(&[("id", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_parent_id {
        req_builder = req_builder.query(&[("parentId", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_type {
        req_builder = req_builder.query(&[("type", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_from {
        req_builder = req_builder.query(&[("from", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_from_number {
        req_builder = req_builder.query(&[("fromNumber", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_to {
        req_builder = req_builder.query(&[("to", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_to_number {
        req_builder = req_builder.query(&[("toNumber", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_time_start {
        req_builder = req_builder.query(&[("time.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_time_end {
        req_builder = req_builder.query(&[("time.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_agent_id {
        req_builder = req_builder.query(&[("agentId", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_q {
        req_builder = req_builder.query(&[("q", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_state {
        req_builder = req_builder.query(&[("state", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_domain {
        req_builder = req_builder.query(&[("domain", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_source {
        req_builder = req_builder.query(&[("source", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_finish_reason {
        req_builder = req_builder.query(&[("finishReason", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_anonymous {
        req_builder = req_builder.query(&[("anonymous", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_session_id {
        req_builder = req_builder.query(&[("filters.sessionId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_conversation_id {
        req_builder = req_builder.query(&[("filters.conversationId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_id {
        req_builder = req_builder.query(&[("filters.id", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_parent_id {
        req_builder =
            req_builder.query(&[("filters.parentId", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_type {
        req_builder = req_builder.query(&[("filters.type", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_from {
        req_builder = req_builder.query(&[("filters.from", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_from_number {
        req_builder = req_builder.query(&[("filters.fromNumber", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_to {
        req_builder = req_builder.query(&[("filters.to", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_to_number {
        req_builder =
            req_builder.query(&[("filters.toNumber", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_time_start {
        req_builder = req_builder.query(&[("filters.time.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_time_end {
        req_builder = req_builder.query(&[("filters.time.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_agent_id {
        req_builder =
            req_builder.query(&[("filters.agentId", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_q {
        req_builder = req_builder.query(&[("filters.q", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filters_state {
        req_builder = req_builder.query(&[("filters.state", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_domain {
        req_builder =
            req_builder.query(&[("filters.domain", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_source {
        req_builder =
            req_builder.query(&[("filters.source", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_finish_reason {
        req_builder =
            req_builder.query(&[("filters.finishReason", &serde_json::to_string(param_value)?)]);
    }
    if let Some(ref param_value) = p_query_filters_anonymous {
        req_builder = req_builder.query(&[("filters.anonymous", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PaginatedCallResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PaginatedCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListReportingCallsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}