babelforce-manager-sdk 0.44.0

use crate::error::{map_manager_err, ManagerError};
use crate::gen::manager::apis::configuration::Configuration;
use crate::gen::manager::apis::recording_api;
use crate::gen::manager::models;
use crate::http::{collect_all, fetch_page, Page};
use crate::retry::{with_retry, RetryPolicy};
use crate::token::SharedCfg;

/// Call recordings — `/api/v2/recordings`, including bulk actions and per-recording flagging.
pub struct RecordingsResource {
    pub(crate) cfg: SharedCfg<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl RecordingsResource {
    /// List all recordings (auto-paginated).
    pub async fn list_all(&self) -> Result<Vec<models::Recording>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = recording_api::list_recordings(cfg, Some(page), None).await?;
            Ok((r.items, r.pagination.pages, r.pagination.current))
        })
        .await
    }

    /// List one page of recordings.
    pub async fn list_page(
        &self,
        page: i32,
        per_page: Option<i32>,
    ) -> Result<Page<models::Recording>, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        fetch_page(&self.retry, map_manager_err, || async move {
            let r = recording_api::list_recordings(cfg, Some(page), per_page).await?;
            Ok((
                r.items,
                r.pagination.pages,
                r.pagination.current,
                Some(r.pagination.total),
            ))
        })
        .await
    }

    /// Start a recording for a call.
    pub async fn start(
        &self,
        body: models::RecordingStartRequest,
    ) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            recording_api::start_recording(cfg, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

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

    /// Update a recording's metadata.
    pub async fn update(
        &self,
        id: &str,
        body: models::RecordingUpdateBody,
    ) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            recording_api::update_recording(cfg, id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete a recording.
    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, || {
            recording_api::delete_recording(cfg, id)
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Apply a bulk action to multiple recordings by id.
    pub async fn bulk_action(
        &self,
        action: &str,
        ids: Vec<String>,
    ) -> Result<models::BulkActionResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        let ids = ids
            .iter()
            .map(|id| {
                uuid::Uuid::parse_str(id)
                    .map_err(|e| ManagerError::InvalidArgument(format!("ids: {e}")))
            })
            .collect::<Result<Vec<_>, _>>()?;
        let body = models::BulkIdsRequest { ids };
        with_retry(&self.retry, false, || {
            recording_api::bulk_recording_action(cfg, action, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get a recording's flag state.
    pub async fn get_flag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, true, || {
            recording_api::get_recording_flag(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Flag a recording.
    pub async fn flag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            recording_api::flag_recording(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Unflag a recording.
    pub async fn unflag(&self, id: &str) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            recording_api::unflag_recording(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Toggle a recording's flag.
    pub async fn toggle_flag(
        &self,
        id: &str,
    ) -> Result<models::RecordingItemResponse, ManagerError> {
        let cfg = self.cfg.get().await?;
        let cfg = cfg.as_ref();
        with_retry(&self.retry, false, || {
            recording_api::toggle_recording_flag(cfg, id)
        })
        .await
        .map_err(map_manager_err)
    }
}