babelforce-manager-sdk 0.42.1

use std::sync::Arc;

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

/// User management — `/api/v2/users`.
pub struct UsersResource {
    pub(crate) cfg: Arc<Configuration>,
    pub(crate) retry: RetryPolicy,
}

impl UsersResource {
    /// Get the currently authenticated user.
    ///
    /// The underlying generated operation is marked deprecated upstream, but it remains part of the
    /// spec and is wrapped here for parity with the TypeScript/Go SDKs.
    #[allow(deprecated)]
    pub async fn me(&self) -> Result<models::GenericItemResponse, ManagerError> {
        with_retry(&self.retry, true, || manager_api::get_me(self.cfg.as_ref()))
            .await
            .map_err(map_manager_err)
    }

    /// Get a user by email.
    pub async fn get_by_email(
        &self,
        email: &str,
    ) -> Result<models::ManagedUserItemResponse, ManagerError> {
        with_retry(&self.retry, true, || {
            manager_api::get_user_by_email(self.cfg.as_ref(), email)
        })
        .await
        .map_err(map_manager_err)
    }

    /// List all users.
    pub async fn list_all(&self) -> Result<Vec<models::ManagedUser>, ManagerError> {
        let resp = with_retry(&self.retry, true, || {
            api::list_users(self.cfg.as_ref(), None)
        })
        .await
        .map_err(map_manager_err)?;
        Ok(resp.items)
    }

    /// Create a user.
    pub async fn create(
        &self,
        user: models::CreateManagedUserRequest,
    ) -> Result<models::ManagedUserItemResponse, ManagerError> {
        with_retry(&self.retry, false, || {
            api::create_user(self.cfg.as_ref(), Some(user.clone()))
        })
        .await
        .map_err(map_manager_err)
    }

    /// Enable the given users (by email).
    pub async fn enable(&self, emails: Vec<String>) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::enable_users(self.cfg.as_ref(), Some(email_list(&emails)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Disable the given users (by email).
    pub async fn disable(&self, emails: Vec<String>) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::disable_users(self.cfg.as_ref(), Some(email_list(&emails)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Delete the given users (by email).
    pub async fn delete(&self, emails: Vec<String>) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::delete_users(self.cfg.as_ref(), Some(email_list(&emails)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Trigger a password-reset email for the given users (by email).
    pub async fn reset_passwords(&self, emails: Vec<String>) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::reset_passwords(self.cfg.as_ref(), Some(email_list(&emails)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// List the role names that can be assigned to users.
    pub async fn list_roles(&self) -> Result<Vec<models::AccountRole>, ManagerError> {
        let resp = with_retry(&self.retry, true, || {
            api::list_available_roles(self.cfg.as_ref())
        })
        .await
        .map_err(map_manager_err)?;
        Ok(resp.items)
    }

    /// Grant the given roles to the given users (by email).
    pub async fn add_roles(
        &self,
        emails: Vec<String>,
        roles: Vec<models::AccountRole>,
    ) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::add_roles(self.cfg.as_ref(), Some(role_binding(&emails, &roles)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }

    /// Revoke the given roles from the given users (by email).
    pub async fn remove_roles(
        &self,
        emails: Vec<String>,
        roles: Vec<models::AccountRole>,
    ) -> Result<(), ManagerError> {
        with_retry(&self.retry, false, || {
            api::remove_roles(self.cfg.as_ref(), Some(role_binding(&emails, &roles)))
        })
        .await
        .map_err(map_manager_err)?;
        Ok(())
    }
}

fn email_list(emails: &[String]) -> models::EmailListRequest {
    models::EmailListRequest {
        emails: emails.to_vec(),
    }
}

fn role_binding(emails: &[String], roles: &[models::AccountRole]) -> models::EmailRoleBinding {
    models::EmailRoleBinding {
        emails: Some(emails.to_vec()),
        roles: Some(roles.to_vec()),
    }
}