babelforce-manager-sdk 0.42.1

/*
 * 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 [`list_all_simple_reporting_calls`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListAllSimpleReportingCallsError {
    UnknownValue(serde_json::Value),
}

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

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

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

/// Returns a paginated list of the customer's calls in the condensed \"simple\" reporting shape — per-call timing metrics (wait, queue, bridge, talk, hold, wrap-up and handle time) alongside agent and queue names — in the list envelope `{ items: ReportingCall[], pagination, success }`. All filters are optional and combine with AND. The `/inbound`, `/outbound` and `/dialer` variants apply the same filters to a single call direction.
pub async fn list_all_simple_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>,
    queue_name: Option<&str>,
    agent_name: Option<&str>,
    bridged: Option<bool>,
    duration_start: Option<f64>,
    duration_end: Option<f64>,
    wait_time_start: Option<f64>,
    wait_time_end: Option<f64>,
    queue_wait_time_start: Option<f64>,
    queue_wait_time_end: Option<f64>,
    bridge_time_start: Option<f64>,
    bridge_time_end: Option<f64>,
    talk_time_start: Option<f64>,
    talk_time_end: Option<f64>,
    hold_time_start: Option<f64>,
    hold_time_end: Option<f64>,
    wrapup_time_start: Option<f64>,
    wrapup_time_end: Option<f64>,
    handle_time_start: Option<f64>,
    handle_time_end: Option<f64>,
) -> Result<models::PaginatedReportingCallResponse, Error<ListAllSimpleReportingCallsError>> {
    // 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_queue_name = queue_name;
    let p_query_agent_name = agent_name;
    let p_query_bridged = bridged;
    let p_query_duration_start = duration_start;
    let p_query_duration_end = duration_end;
    let p_query_wait_time_start = wait_time_start;
    let p_query_wait_time_end = wait_time_end;
    let p_query_queue_wait_time_start = queue_wait_time_start;
    let p_query_queue_wait_time_end = queue_wait_time_end;
    let p_query_bridge_time_start = bridge_time_start;
    let p_query_bridge_time_end = bridge_time_end;
    let p_query_talk_time_start = talk_time_start;
    let p_query_talk_time_end = talk_time_end;
    let p_query_hold_time_start = hold_time_start;
    let p_query_hold_time_end = hold_time_end;
    let p_query_wrapup_time_start = wrapup_time_start;
    let p_query_wrapup_time_end = wrapup_time_end;
    let p_query_handle_time_start = handle_time_start;
    let p_query_handle_time_end = handle_time_end;

    let uri_str = format!("{}/api/v2/calls/reporting/simple", 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_queue_name {
        req_builder = req_builder.query(&[("queueName", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_agent_name {
        req_builder = req_builder.query(&[("agentName", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_bridged {
        req_builder = req_builder.query(&[("bridged", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_duration_start {
        req_builder = req_builder.query(&[("duration.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_duration_end {
        req_builder = req_builder.query(&[("duration.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_wait_time_start {
        req_builder = req_builder.query(&[("waitTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_wait_time_end {
        req_builder = req_builder.query(&[("waitTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_queue_wait_time_start {
        req_builder = req_builder.query(&[("queueWaitTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_queue_wait_time_end {
        req_builder = req_builder.query(&[("queueWaitTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_bridge_time_start {
        req_builder = req_builder.query(&[("bridgeTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_bridge_time_end {
        req_builder = req_builder.query(&[("bridgeTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_talk_time_start {
        req_builder = req_builder.query(&[("talkTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_talk_time_end {
        req_builder = req_builder.query(&[("talkTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_hold_time_start {
        req_builder = req_builder.query(&[("holdTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_hold_time_end {
        req_builder = req_builder.query(&[("holdTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_wrapup_time_start {
        req_builder = req_builder.query(&[("wrapupTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_wrapup_time_end {
        req_builder = req_builder.query(&[("wrapupTime.end", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_handle_time_start {
        req_builder = req_builder.query(&[("handleTime.start", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_handle_time_end {
        req_builder = req_builder.query(&[("handleTime.end", &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::PaginatedReportingCallResponse`"))),
            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::PaginatedReportingCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAllSimpleReportingCallsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a paginated list of **dialer** simple reporting calls — the same view as `/api/v2/calls/reporting/simple` pre-filtered to calls placed by the automated outbound dialer. Accepts the same query filters as that endpoint.
pub async fn list_dialer_simple_reporting_calls(
    configuration: &configuration::Configuration,
    page: Option<i32>,
    max: Option<i32>,
) -> Result<models::PaginatedReportingCallResponse, Error<ListDialerSimpleReportingCallsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_page = page;
    let p_query_max = max;

    let uri_str = format!(
        "{}/api/v2/calls/reporting/simple/dialer",
        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 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::PaginatedReportingCallResponse`"))),
            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::PaginatedReportingCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListDialerSimpleReportingCallsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a paginated list of **inbound** simple reporting calls — the same view as `/api/v2/calls/reporting/simple` pre-filtered to calls the customer received. Accepts the same query filters as that endpoint.
pub async fn list_inbound_simple_reporting_calls(
    configuration: &configuration::Configuration,
    page: Option<i32>,
    max: Option<i32>,
) -> Result<models::PaginatedReportingCallResponse, Error<ListInboundSimpleReportingCallsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_page = page;
    let p_query_max = max;

    let uri_str = format!(
        "{}/api/v2/calls/reporting/simple/inbound",
        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 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::PaginatedReportingCallResponse`"))),
            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::PaginatedReportingCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListInboundSimpleReportingCallsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

/// Returns a paginated list of **outbound** simple reporting calls — the same view as `/api/v2/calls/reporting/simple` pre-filtered to calls the customer placed. Accepts the same query filters as that endpoint.
pub async fn list_outbound_simple_reporting_calls(
    configuration: &configuration::Configuration,
    page: Option<i32>,
    max: Option<i32>,
) -> Result<models::PaginatedReportingCallResponse, Error<ListOutboundSimpleReportingCallsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_page = page;
    let p_query_max = max;

    let uri_str = format!(
        "{}/api/v2/calls/reporting/simple/outbound",
        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 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::PaginatedReportingCallResponse`"))),
            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::PaginatedReportingCallResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListOutboundSimpleReportingCallsError> =
            serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}