bitwarden-sm 3.0.0

use bitwarden_api_api::models::ProjectResponseModelListResponseModel;
use bitwarden_core::key_management::KeySlotIds;
use bitwarden_crypto::KeyStoreContext;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::{SecretsManagerClient, error::SecretsManagerError, projects::ProjectResponse};

#[allow(missing_docs)]
#[derive(Serialize, Deserialize, Debug, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProjectsListRequest {
    /// Organization to retrieve all the projects from
    pub organization_id: Uuid,
}

pub(crate) async fn list_projects(
    client: &SecretsManagerClient,
    input: &ProjectsListRequest,
) -> Result<ProjectsResponse, SecretsManagerError> {
    let client = client.client();
    let config = client.internal.get_api_configurations();
    let res = config
        .api_client
        .projects_api()
        .list_by_organization(input.organization_id)
        .await?;

    let key_store = client.internal.get_key_store();

    ProjectsResponse::process_response(res, &mut key_store.context())
}

#[allow(missing_docs)]
#[derive(Serialize, Deserialize, Debug, JsonSchema)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
pub struct ProjectsResponse {
    pub data: Vec<ProjectResponse>,
}

impl ProjectsResponse {
    pub(crate) fn process_response(
        response: ProjectResponseModelListResponseModel,
        ctx: &mut KeyStoreContext<KeySlotIds>,
    ) -> Result<Self, SecretsManagerError> {
        let data = response.data.unwrap_or_default();

        Ok(ProjectsResponse {
            data: data
                .into_iter()
                .map(|r| ProjectResponse::process_response(r, ctx))
                .collect::<Result<_, _>>()?,
        })
    }
}