babelforce_manager_sdk/resources/

integrations.rs

use std::sync::Arc;

use crate::error::{map_manager_err, ManagerError};
use crate::gen::manager::apis::action_api;
use crate::gen::manager::apis::configuration::Configuration;
use crate::gen::manager::apis::integration_api as api;
use crate::gen::manager::models;
use crate::http::{collect_all, fetch_page, Page};
use crate::retry::{with_retry, RetryPolicy};

/// Integrations — `/api/v2/integrations`.
pub struct IntegrationsResource {
    pub(crate) cfg: Arc<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl IntegrationsResource {
    /// List all configured integrations (auto-paginated).
    pub async fn list_all(&self) -> Result<Vec<models::Integration>, ManagerError> {
        collect_all(&self.retry, map_manager_err, |page| async move {
            let r = api::list_integrations(self.cfg.as_ref(), Some(page), None).await?;
            Ok((r.items, r.pagination.pages, r.pagination.current))
        })
        .await
    }

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

    /// Create an integration.
    pub async fn create(
        &self,
        body: models::IntegrationCreateRequest,
    ) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::create_integration(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get an integration by id.
    pub async fn get(&self, id: &str) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::get_integration(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update an integration.
    pub async fn update(
        &self,
        id: &str,
        body: models::IntegrationUpdateRequest,
    ) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::update_integration(self.cfg.as_ref(), id, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete an integration.
    pub async fn delete(&self, id: &str) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::delete_integration(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// List the integration providers available to this account.
    pub async fn available(
        &self,
    ) -> Result<models::IntegrationListAvailableIntegrationsResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_available_integrations(self.cfg.as_ref())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Associate an integration action with an object.
    pub async fn add_association(
        &self,
        integration_id: &str,
        association_id: &str,
        action_name: &str,
    ) -> Result<models::IntegrationAddAssociationResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::add_integration_association(
                self.cfg.as_ref(),
                integration_id,
                association_id,
                action_name,
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// Remove an integration action association.
    pub async fn remove_association(
        &self,
        integration_id: &str,
        association_id: &str,
        action_name: &str,
    ) -> Result<models::IntegrationRemoveAssociationResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::delete_integration_association(
                self.cfg.as_ref(),
                integration_id,
                association_id,
                action_name,
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get a provider's logo at a given size.
    pub async fn provider_logo(
        &self,
        provider_name: models::IntegrationProvider,
        size: &str,
    ) -> Result<models::GetIntegrationProviderLogoResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::get_integration_provider_logo(self.cfg.as_ref(), provider_name, size)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the session variables a provider's actions expose.
    pub async fn provider_session_variables(
        &self,
        provider: &str,
    ) -> Result<models::IntegrationSessionVariableItemsResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_provider_session_variables(self.cfg.as_ref(), provider)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Dispatch an integration action.
    pub async fn dispatch_action(
        &self,
        integration_id: &str,
        action: &str,
        body: models::IntegrationDispatchActionRequest,
    ) -> Result<models::IntegrationDispatchActionResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::dispatch_action(
                self.cfg.as_ref(),
                integration_id,
                action,
                None,
                None,
                Some(body.clone()),
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the variables a single provider action exposes.
    pub async fn action_variables(
        &self,
        provider: models::IntegrationProvider,
        action_name: &str,
    ) -> Result<models::VariableDefinitionItemsResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_single_action_session_variables(self.cfg.as_ref(), provider, action_name)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the available integration providers.
    pub async fn providers(&self) -> Result<models::IntegrationObjectListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_integration_providers(self.cfg.as_ref())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get a provider's config template.
    pub async fn provider_template(
        &self,
        provider: &str,
    ) -> Result<std::collections::HashMap<String, serde_json::Value>, ManagerError> {
        with_retry(&self.retry, true, || {
            api::get_integration_provider_template(self.cfg.as_ref(), provider)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get the config template for a given integration type and provider.
    pub async fn template(
        &self,
        r#type: &str,
        provider: &str,
    ) -> Result<std::collections::HashMap<String, serde_json::Value>, ManagerError> {
        with_retry(&self.retry, true, || {
            api::get_integration_template(self.cfg.as_ref(), r#type, provider)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Authorize an integration.
    pub async fn authorize(
        &self,
        id: &str,
        body: std::collections::HashMap<String, serde_json::Value>,
    ) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::authorize_integration(self.cfg.as_ref(), id, Some(body.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Clone an integration.
    pub async fn clone(&self, id: &str) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::clone_integration(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Run the integrate step for an integration.
    pub async fn integrate(
        &self,
        id: &str,
        body: std::collections::HashMap<String, serde_json::Value>,
    ) -> Result<models::IntegrationItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::integrate_integration(self.cfg.as_ref(), id, Some(body.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Update several integrations in one request.
    pub async fn bulk_update(
        &self,
        body: models::BulkUpdateIntegrationsRequest,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::bulk_update_integrations(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete several integrations in one request, given their ids.
    pub async fn bulk_delete(
        &self,
        ids: Vec<String>,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        for id in &ids {
            uuid::Uuid::parse_str(id)
                .map_err(|e| ManagerError::InvalidArgument(format!("id {id}: {e}")))?;
        }
        let body = models::IntegrationBulkIdsRequest { ids };
        with_retry(&self.retry, false, || {
            api::bulk_delete_integrations(self.cfg.as_ref(), body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the actions exposed by integrations of a given type.
    pub async fn type_actions(
        &self,
        r#type: &str,
    ) -> Result<models::IntegrationObjectListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_integration_type_actions(self.cfg.as_ref(), r#type)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Dispatch an action against an integration of a given type.
    pub async fn dispatch_type_action(
        &self,
        r#type: &str,
        id: &str,
        action: &str,
        body: std::collections::HashMap<String, serde_json::Value>,
    ) -> Result<std::collections::HashMap<String, serde_json::Value>, ManagerError> {
        with_retry(&self.retry, false, || {
            api::dispatch_integration_type_action(
                self.cfg.as_ref(),
                r#type,
                id,
                action,
                Some(body.clone()),
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// Proxy a GET request through an integration's API.
    pub async fn api_proxy_get(&self, integration_id: &str, uri: &str) -> Result<(), ManagerError> {
        with_retry(&self.retry, true, || {
            api::integration_api_proxy_get(self.cfg.as_ref(), integration_id, uri)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Proxy a POST request through an integration's API.
    pub async fn api_proxy_post(
        &self,
        integration_id: &str,
        uri: &str,
        body: std::collections::HashMap<String, serde_json::Value>,
    ) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::integration_api_proxy_post(
                self.cfg.as_ref(),
                integration_id,
                uri,
                Some(body.clone()),
            )
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the tokens issued for an integration.
    pub async fn list_tokens(
        &self,
        id: &str,
    ) -> Result<models::IntegrationTokenListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::list_integration_tokens(self.cfg.as_ref(), id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Get a single integration token.
    pub async fn get_token(
        &self,
        id: &str,
        token_id: &str,
    ) -> Result<models::IntegrationTokenItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::get_integration_token(self.cfg.as_ref(), id, token_id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Delete an integration token.
    pub async fn delete_token(
        &self,
        id: &str,
        token_id: &str,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::delete_integration_token(self.cfg.as_ref(), id, token_id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Refresh an integration token.
    pub async fn refresh_token(
        &self,
        id: &str,
        token_id: &str,
    ) -> Result<models::IntegrationTokenItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::refresh_integration_token(self.cfg.as_ref(), id, token_id)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List the available trigger/automation actions (catalog), optionally filtered by type.
    pub async fn list_actions(
        &self,
        r#type: Option<&str>,
    ) -> Result<models::ObjectListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            action_api::list_actions(self.cfg.as_ref(), r#type)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List an action's input parameters.
    pub async fn list_action_params(
        &self,
        provider_name: &str,
        provider_action_name: &str,
    ) -> Result<models::ObjectListResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            action_api::list_action_params(self.cfg.as_ref(), provider_name, provider_action_name)
        })
        .await
        .map_err(map_manager_err)
    }

    /// Execute a call/queue action directly.
    pub async fn execute_action(
        &self,
        action_type: &str,
        action_name: &str,
        body: Option<std::collections::HashMap<String, serde_json::Value>>,
    ) -> Result<models::DefaultV2MessageResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            action_api::execute_action(self.cfg.as_ref(), action_type, action_name, body.clone())
        })
        .await
        .map_err(map_manager_err)
    }

    /// Dispatch an integration action via GET.
    pub async fn dispatch_action_get(
        &self,
        integration_id: &str,
        action: &str,
        call_id: Option<&str>,
        session_id: Option<&str>,
    ) -> Result<models::IntegrationDispatchActionResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            api::dispatch_action_get(
                self.cfg.as_ref(),
                integration_id,
                action,
                call_id,
                session_id,
            )
        })
        .await
        .map_err(map_manager_err)
    }
}