babelforce-manager-sdk 0.46.0

use crate::auth::Auth;
use crate::error::ManagerError;
use crate::gen::auth::apis::configuration::Configuration as AuthConfig;
use crate::gen::manager::apis::configuration::Configuration as ManagerConfig;
use crate::gen::task_automation::apis::configuration::Configuration as TaskAutomationConfig;
use crate::gen::task_schedule::apis::configuration::Configuration as TaskScheduleConfig;
use crate::gen::user::apis::configuration::Configuration as UserConfig;
use crate::resources::agents::{AgentGroupsResource, AgentsResource};
use crate::resources::applications::{ApplicationsResource, LocalAutomationsResource};
use crate::resources::auth::AuthResource;
use crate::resources::automations::AutomationsResource;
use crate::resources::babeldesk::{BabeldeskResource, BabeldeskWidgetsResource};
use crate::resources::businesshours::BusinessHoursResource;
use crate::resources::calendars::CalendarsResource;
use crate::resources::calls::{CallsResource, ReportingResource};
use crate::resources::campaigns::CampaignsResource;
use crate::resources::conferences::ConferencesResource;
use crate::resources::conversations::ConversationsResource;
use crate::resources::dashboards::DashboardsResource;
use crate::resources::dialer::{DialerBehavioursResource, DialerResource};
use crate::resources::events::EventsResource;
use crate::resources::expressions::ExpressionsResource;
use crate::resources::files::FilesResource;
use crate::resources::integrations::IntegrationsResource;
use crate::resources::logs::LogsResource;
use crate::resources::me::MeResource;
use crate::resources::metrics::MetricsResource;
use crate::resources::numbers::NumbersResource;
use crate::resources::outbound::OutboundResource;
use crate::resources::phonebook::PhonebookResource;
use crate::resources::prompts::PromptsResource;
use crate::resources::queues::{QueueSelectionsResource, QueuesResource};
use crate::resources::recordings::RecordingsResource;
use crate::resources::routing::RoutingResource;
use crate::resources::schedules::TaskSchedulesResource;
use crate::resources::sessions::SessionsResource;
use crate::resources::settings::SettingsResource;
use crate::resources::sms::SmsResource;
use crate::resources::system::SystemResource;
use crate::resources::tasks::{
    TaskMetricsResource, TaskScriptsResource, TaskSecretsResource, TaskSelectionConfigResource,
    TasksResource,
};
use crate::resources::triggers::TriggersResource;
use crate::resources::users::UsersResource;
use crate::retry::{RetryMiddleware, RetryPolicy};
use crate::token::{SharedCfg, TokenManager};

/// Default babelforce API host. Override with [`ManagerClientBuilder::base_url`].
pub const DEFAULT_BASE_URL: &str = "https://services.babelforce.com";

/// The babelforce manager SDK client. Build one with [`ManagerClient::connect`] (or
/// [`ManagerClient::builder`]) and use its resource namespaces.
pub struct ManagerClient {
    /// User management — `/api/v2/users`.
    pub users: UsersResource,
    /// Agent management — `/api/v2/agents` (with a nested `groups` sub-resource).
    pub agents: AgentsResource,
    /// The authenticated principal — current user, accounts, password reset (`/api/v2/user`).
    pub me: MeResource,
    /// Call reporting & control — `/api/v2/calls` (with a nested `reporting` sub-resource).
    pub calls: CallsResource,
    /// SMS records — `/api/v2/sms`.
    pub sms: SmsResource,
    /// Service (phone) numbers — `/api/v2/numbers`.
    pub numbers: NumbersResource,
    /// Conferences — `/api/v2/conferences`.
    pub conferences: ConferencesResource,
    /// Queues — `/api/v2/queues` (with a nested `selections` sub-resource).
    pub queues: QueuesResource,
    /// Call recordings — `/api/v2/recordings` (bulk actions and per-recording flagging).
    pub recordings: RecordingsResource,
    /// Routing rules — `/api/v2/routings`.
    pub routing: RoutingResource,
    /// Workflow triggers — `/api/v2/triggers`.
    pub triggers: TriggersResource,
    /// Global automations (event triggers) — `/api/v2/events/triggers`.
    pub automations: AutomationsResource,
    /// Integrations — `/api/v2/integrations`.
    pub integrations: IntegrationsResource,
    /// Outbound lists & leads — `/api/v2/outbound/lists`.
    pub outbound: OutboundResource,
    /// Phonebook entries — `/api/v2/phonebook`.
    pub phonebook: PhonebookResource,
    /// Outbound campaigns — `/api/v2/outbound/campaigns`.
    pub campaigns: CampaignsResource,
    /// Business hours — `/api/v2/business-hours`.
    pub business_hours: BusinessHoursResource,
    /// Calendars — `/api/v2/calendars`.
    pub calendars: CalendarsResource,
    /// Conversations — `/api/v2/conversations` (with events & session variables).
    pub conversations: ConversationsResource,
    /// Reporting dashboards — `/api/v2/dashboards` (with per-dashboard user management).
    pub dashboards: DashboardsResource,
    /// Dialer runtime & reporting — `/api/v2/dialer` (with a nested `behaviours` sub-resource).
    pub dialer: DialerResource,
    /// Call/automation sessions — `/api/v2/sessions`.
    pub sessions: SessionsResource,
    /// Audio prompts — `/api/v2/prompts`.
    pub prompts: PromptsResource,
    /// Babeldesk dashboards — `/api/v2/babeldesk` (with a nested `widgets` sub-resource).
    pub babeldesk: BabeldeskResource,
    /// Event definitions & custom events — `/api/v2/events`.
    pub events: EventsResource,
    /// Expressions catalog & evaluator — `/api/v2/expressions`.
    pub expressions: ExpressionsResource,
    /// Stored files — `/api/v2/files` (recordings, prompts, backups).
    pub files: FilesResource,
    /// Audit & live logs.
    pub logs: LogsResource,
    /// Metrics — `/api/v2/metrics`.
    pub metrics: MetricsResource,
    /// System & reference data — health checks, server time, timezones, tags, templates.
    pub system: SystemResource,
    /// Global settings — `/api/v2/settings`, grouped by scope.
    pub settings: SettingsResource,
    /// Applications — `/api/v2/applications` (with a nested `local_automations` sub-resource).
    pub applications: ApplicationsResource,
    /// Task automation (v3) — `/api/v3/tasks` (with nested scripts/secrets/selection_config/metrics).
    pub tasks: TasksResource,
    /// Task schedules (v3) — `/api/v3/schedules`.
    pub schedules: TaskSchedulesResource,
    /// OAuth 2.0 — `/oauth/authorize`, `/oauth/token`, `/oauth/revoke`.
    pub auth: AuthResource,
}

impl ManagerClient {
    /// Connect with default settings (base URL [`DEFAULT_BASE_URL`], retries on).
    pub async fn connect(auth: Auth) -> Result<Self, ManagerError> {
        Self::builder(auth).connect().await
    }

    /// Start building a client to customise the base URL or retry policy.
    pub fn builder(auth: Auth) -> ManagerClientBuilder {
        ManagerClientBuilder {
            base_url: DEFAULT_BASE_URL.to_string(),
            auth,
            retry: RetryPolicy::default(),
        }
    }
}

/// Builder for [`ManagerClient`].
pub struct ManagerClientBuilder {
    base_url: String,
    auth: Auth,
    retry: RetryPolicy,
}

impl ManagerClientBuilder {
    /// Override the base URL (e.g. a per-customer host). Defaults to [`DEFAULT_BASE_URL`].
    pub fn base_url(mut self, url: impl Into<String>) -> Self {
        self.base_url = url.into();
        self
    }

    /// Override the retry policy. Defaults to [`RetryPolicy::default`].
    pub fn retry(mut self, policy: RetryPolicy) -> Self {
        self.retry = policy;
        self
    }

    /// Build the client, resolving a grant into a bearer token if needed (kept fresh from then
    /// on — see [`Auth`]).
    pub async fn connect(self) -> Result<ManagerClient, ManagerError> {
        let base = self.base_url.trim_end_matches('/').to_string();

        // Static headers only ([`Auth::Bearer`]). Grant-resolved tokens travel per-request via
        // the configurations' `oauth_access_token`, so a mid-life re-grant never needs to
        // rebuild this client.
        let http = reqwest::Client::builder()
            .default_headers(self.auth.static_headers())
            .build()
            .map_err(|e| ManagerError::Network(e.to_string()))?;
        // Retries live in transport middleware (see `crate::retry`), so every request — generated
        // clients, raw JSON paths and `/oauth/token` grants — shares one retry behaviour,
        // matching the TS fetch wrapper / Go RoundTripper.
        let http = reqwest_middleware::ClientBuilder::new(http)
            .with(RetryMiddleware::new(self.retry.clone()))
            .build();

        // Resolve grant-based auth eagerly (fail fast at connect); the manager then re-grants
        // transparently whenever a call would use the token within 30s of expiry.
        let token_manager = TokenManager::connect(&base, &self.auth, http.clone()).await?;
        let (epoch, token) = match &token_manager {
            Some(manager) => {
                let (epoch, token) = manager.current().await?;
                (epoch, Some(token))
            }
            None => (0, None),
        };

        let user_agent =
            Some(concat!("babelforce-manager-sdk-rust/", env!("CARGO_PKG_VERSION")).to_string());

        let cfg = SharedCfg::new(
            ManagerConfig {
                base_path: base.clone(),
                user_agent: user_agent.clone(),
                client: http.clone(),
                basic_auth: None,
                oauth_access_token: token.clone(),
                bearer_access_token: None,
                api_key: None,
            },
            token_manager.clone(),
            epoch,
        );

        // The other specs live on the same host and share the reqwest client + token lifecycle.
        let user_cfg = SharedCfg::new(
            UserConfig {
                base_path: base.clone(),
                user_agent: user_agent.clone(),
                client: http.clone(),
                basic_auth: None,
                oauth_access_token: token.clone(),
                bearer_access_token: None,
                api_key: None,
            },
            token_manager.clone(),
            epoch,
        );
        let task_automation_cfg = SharedCfg::new(
            TaskAutomationConfig {
                base_path: base.clone(),
                user_agent: user_agent.clone(),
                client: http.clone(),
                basic_auth: None,
                oauth_access_token: token.clone(),
                bearer_access_token: None,
                api_key: None,
            },
            token_manager.clone(),
            epoch,
        );
        let task_schedule_cfg = SharedCfg::new(
            TaskScheduleConfig {
                base_path: base.clone(),
                user_agent: user_agent.clone(),
                client: http.clone(),
                basic_auth: None,
                oauth_access_token: token.clone(),
                bearer_access_token: None,
                api_key: None,
            },
            token_manager.clone(),
            epoch,
        );
        // OAuth endpoints carry their credentials in the request body, but share the same
        // host/client.
        let auth_cfg = SharedCfg::new(
            AuthConfig {
                base_path: base,
                user_agent,
                client: http,
                basic_auth: None,
                oauth_access_token: token,
                bearer_access_token: None,
                api_key: None,
            },
            token_manager,
            epoch,
        );

        Ok(ManagerClient {
            users: UsersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            agents: AgentsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                groups: AgentGroupsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            me: MeResource {
                cfg: user_cfg,
                retry: self.retry.clone(),
            },
            calls: CallsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                reporting: ReportingResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            sms: SmsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            numbers: NumbersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            conferences: ConferencesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            queues: QueuesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                selections: QueueSelectionsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            recordings: RecordingsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            routing: RoutingResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            triggers: TriggersResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            automations: AutomationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            integrations: IntegrationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            outbound: OutboundResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            phonebook: PhonebookResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            campaigns: CampaignsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            business_hours: BusinessHoursResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            calendars: CalendarsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            conversations: ConversationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            dashboards: DashboardsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            dialer: DialerResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                behaviours: DialerBehavioursResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            sessions: SessionsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            prompts: PromptsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            babeldesk: BabeldeskResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                widgets: BabeldeskWidgetsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            events: EventsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            expressions: ExpressionsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            files: FilesResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            logs: LogsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            metrics: MetricsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            system: SystemResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            settings: SettingsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
            },
            applications: ApplicationsResource {
                cfg: cfg.clone(),
                retry: self.retry.clone(),
                local_automations: LocalAutomationsResource {
                    cfg: cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            tasks: TasksResource {
                cfg: task_automation_cfg.clone(),
                retry: self.retry.clone(),
                scripts: TaskScriptsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                secrets: TaskSecretsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                selection_config: TaskSelectionConfigResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
                metrics: TaskMetricsResource {
                    cfg: task_automation_cfg.clone(),
                    retry: self.retry.clone(),
                },
            },
            schedules: TaskSchedulesResource {
                cfg: task_schedule_cfg,
                retry: self.retry.clone(),
            },
            auth: AuthResource {
                cfg: auth_cfg,
                retry: self.retry.clone(),
            },
        })
    }
}