babelforce-manager-sdk 0.46.0

use crate::error::{map_manager_err, ManagerError};
use crate::gen::manager::apis::configuration::Configuration;
use crate::gen::manager::apis::manager_api as api;
use crate::gen::manager::apis::outbound_api;
use crate::gen::manager::models;
use crate::retry::{with_retry, RetryPolicy};
use crate::token::SharedCfg;

/// Outbound campaigns — `/api/v2/outbound/campaigns`.
pub struct CampaignsResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl CampaignsResource {
    /// List the outbound campaigns.
    pub async fn list(&self) -> Result<Vec<models::OutboundCampaign>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        let resp = with_retry(&self.retry, true, || api::list_campaigns(cfg))
            .await
            .map_err(map_manager_err)?;
        Ok(resp.items)
    }

    /// Create a campaign.
    pub async fn create(
        &self,
        body: models::CreateCampaignRequest,
    ) -> Result<models::OutboundCampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            api::create_campaign(cfg, Some(body.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get a campaign by id.
    pub async fn get(
        &self,
        id: &str,
    ) -> Result<models::OutboundCampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || api::get_campaign(cfg, id))
            .await
            .map_err(map_manager_err)
    }

    /// Update a campaign.
    pub async fn update(
        &self,
        id: &str,
        body: models::UpdateCampaignRequest,
    ) -> Result<models::OutboundCampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            api::update_campaign(cfg, id, Some(body.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete a campaign.
    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || api::delete_campaign(cfg, id))
            .await
            .map_err(map_manager_err)?;
        Ok(())
    }

    /// List the dial attempts for a campaign, optionally filtered by phone `number`.
    pub async fn attempts(
        &self,
        id: &str,
        number: Option<&str>,
    ) -> Result<models::PaginatedAttemptResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::list_campaign_attempts(cfg, id, number)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get the hopper (queued leads) of a campaign.
    pub async fn hopper(&self, id: &str) -> Result<models::CampaignHopperResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::get_campaign_hopper(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the leads of a campaign.
    pub async fn leads(&self, id: &str) -> Result<models::PaginatedLeadResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::list_campaign_leads(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the processed leads of a campaign.
    pub async fn processed_leads(
        &self,
        id: &str,
    ) -> Result<models::PaginatedLeadResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::list_campaign_processed_leads(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get the lead list assigned to a campaign.
    pub async fn get_list(&self, id: &str) -> Result<models::LeadListItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::get_campaign_list(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Set the lead list of a campaign.
    pub async fn set_list(
        &self,
        id: &str,
        body: models::SetCampaignListRequest,
    ) -> Result<models::CampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            outbound_api::set_campaign_list(cfg, id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Unset (detach) the lead list of a campaign.
    pub async fn unset_list(&self, id: &str) -> Result<models::CampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            outbound_api::unset_campaign_list(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Set the lead list of a campaign by list id.
    pub async fn set_list_by_id(
        &self,
        id: &str,
        list_id: &str,
    ) -> Result<models::CampaignItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            outbound_api::set_campaign_list_by_id(cfg, id, list_id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Log out all agents currently assigned to a campaign.
    pub async fn logout_all_agents(
        &self,
        id: &str,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            outbound_api::logout_all_campaign_agents(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get the statistics of a campaign, optionally bounded by a `from`/`to` time range.
    pub async fn statistics(
        &self,
        id: &str,
        from: Option<i32>,
        to: Option<i32>,
    ) -> Result<models::CampaignStatisticsResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::get_campaign_statistics(cfg, id, from, to)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get the realtime status of a campaign.
    pub async fn status(
        &self,
        id: &str,
    ) -> Result<models::CampaignRealtimeStatusResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            outbound_api::get_campaign_status(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }
}