Struct datadog_api_client::datadogV2::api::api_authn_mappings::AuthNMappingsAPI

pub struct AuthNMappingsAPI { /* private fields */ }

The AuthN Mappings API is used to automatically map groups of users to roles in Datadog using attributes sent from Identity Providers. Use these endpoints to manage your AuthN Mappings.

Implementations

impl AuthNMappingsAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v2_authn-mappings_ListAuthNMappings.rs (line 9)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .list_authn_mappings(ListAuthNMappingsOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_authn-mappings_GetAuthNMapping.rs (line 10)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api.get_authn_mapping(authn_mapping_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_authn-mappings_DeleteAuthNMapping.rs (line 10)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .delete_authn_mapping(authn_mapping_data_id.clone())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_authn-mappings_CreateAuthNMapping.rs (line 38)

async fn main() {
    // there is a valid "role" in the system
    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
    let body = AuthNMappingCreateRequest::new(
        AuthNMappingCreateData::new(AuthNMappingsType::AUTHN_MAPPINGS)
            .attributes(
                AuthNMappingCreateAttributes::new()
                    .attribute_key("exampleauthnmapping".to_string())
                    .attribute_value("Example-AuthN-Mapping".to_string()),
            )
            .relationships(
                AuthNMappingCreateRelationships::AuthNMappingRelationshipToRole(Box::new(
                    AuthNMappingRelationshipToRole::new(
                        RelationshipToRole::new().data(
                            RelationshipToRoleData::new()
                                .id(role_data_id.clone())
                                .type_(RolesType::ROLES),
                        ),
                    ),
                )),
            ),
    );
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api.create_authn_mapping(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v2_authn-mappings_UpdateAuthNMapping.rs (line 44)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();

    // there is a valid "role" in the system
    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
    let body = AuthNMappingUpdateRequest::new(
        AuthNMappingUpdateData::new(
            authn_mapping_data_id.clone(),
            AuthNMappingsType::AUTHN_MAPPINGS,
        )
        .attributes(
            AuthNMappingUpdateAttributes::new()
                .attribute_key("member-of".to_string())
                .attribute_value("Development".to_string()),
        )
        .relationships(
            AuthNMappingUpdateRelationships::AuthNMappingRelationshipToRole(Box::new(
                AuthNMappingRelationshipToRole::new(
                    RelationshipToRole::new().data(
                        RelationshipToRoleData::new()
                            .id(role_data_id.clone())
                            .type_(RolesType::ROLES),
                    ),
                ),
            )),
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .update_authn_mapping(authn_mapping_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub fn with_client_and_config( config: Configuration, client: ClientWithMiddleware, ) -> Self

pub async fn create_authn_mapping( &self, body: AuthNMappingCreateRequest, ) -> Result<AuthNMappingResponse, Error<CreateAuthNMappingError>>

Create an AuthN Mapping.

Examples found in repository

examples/v2_authn-mappings_CreateAuthNMapping.rs (line 39)

async fn main() {
    // there is a valid "role" in the system
    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
    let body = AuthNMappingCreateRequest::new(
        AuthNMappingCreateData::new(AuthNMappingsType::AUTHN_MAPPINGS)
            .attributes(
                AuthNMappingCreateAttributes::new()
                    .attribute_key("exampleauthnmapping".to_string())
                    .attribute_value("Example-AuthN-Mapping".to_string()),
            )
            .relationships(
                AuthNMappingCreateRelationships::AuthNMappingRelationshipToRole(Box::new(
                    AuthNMappingRelationshipToRole::new(
                        RelationshipToRole::new().data(
                            RelationshipToRoleData::new()
                                .id(role_data_id.clone())
                                .type_(RolesType::ROLES),
                        ),
                    ),
                )),
            ),
    );
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api.create_authn_mapping(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_authn_mapping_with_http_info( &self, body: AuthNMappingCreateRequest, ) -> Result<ResponseContent<AuthNMappingResponse>, Error<CreateAuthNMappingError>>

Create an AuthN Mapping.

pub async fn delete_authn_mapping( &self, authn_mapping_id: String, ) -> Result<(), Error<DeleteAuthNMappingError>>

Delete an AuthN Mapping specified by AuthN Mapping UUID.

Examples found in repository

examples/v2_authn-mappings_DeleteAuthNMapping.rs (line 12)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .delete_authn_mapping(authn_mapping_data_id.clone())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn delete_authn_mapping_with_http_info( &self, authn_mapping_id: String, ) -> Result<ResponseContent<()>, Error<DeleteAuthNMappingError>>

Delete an AuthN Mapping specified by AuthN Mapping UUID.

pub async fn get_authn_mapping( &self, authn_mapping_id: String, ) -> Result<AuthNMappingResponse, Error<GetAuthNMappingError>>

Get an AuthN Mapping specified by the AuthN Mapping UUID.

Examples found in repository

examples/v2_authn-mappings_GetAuthNMapping.rs (line 11)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api.get_authn_mapping(authn_mapping_data_id.clone()).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn get_authn_mapping_with_http_info( &self, authn_mapping_id: String, ) -> Result<ResponseContent<AuthNMappingResponse>, Error<GetAuthNMappingError>>

Get an AuthN Mapping specified by the AuthN Mapping UUID.

pub async fn list_authn_mappings( &self, params: ListAuthNMappingsOptionalParams, ) -> Result<AuthNMappingsResponse, Error<ListAuthNMappingsError>>

List all AuthN Mappings in the org.

Examples found in repository

examples/v2_authn-mappings_ListAuthNMappings.rs (line 11)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .list_authn_mappings(ListAuthNMappingsOptionalParams::default())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn list_authn_mappings_with_http_info( &self, params: ListAuthNMappingsOptionalParams, ) -> Result<ResponseContent<AuthNMappingsResponse>, Error<ListAuthNMappingsError>>

List all AuthN Mappings in the org.

pub async fn update_authn_mapping( &self, authn_mapping_id: String, body: AuthNMappingUpdateRequest, ) -> Result<AuthNMappingResponse, Error<UpdateAuthNMappingError>>

Edit an AuthN Mapping.

Examples found in repository

examples/v2_authn-mappings_UpdateAuthNMapping.rs (line 46)

async fn main() {
    // there is a valid "authn_mapping" in the system
    let authn_mapping_data_id = std::env::var("AUTHN_MAPPING_DATA_ID").unwrap();

    // there is a valid "role" in the system
    let role_data_id = std::env::var("ROLE_DATA_ID").unwrap();
    let body = AuthNMappingUpdateRequest::new(
        AuthNMappingUpdateData::new(
            authn_mapping_data_id.clone(),
            AuthNMappingsType::AUTHN_MAPPINGS,
        )
        .attributes(
            AuthNMappingUpdateAttributes::new()
                .attribute_key("member-of".to_string())
                .attribute_value("Development".to_string()),
        )
        .relationships(
            AuthNMappingUpdateRelationships::AuthNMappingRelationshipToRole(Box::new(
                AuthNMappingRelationshipToRole::new(
                    RelationshipToRole::new().data(
                        RelationshipToRoleData::new()
                            .id(role_data_id.clone())
                            .type_(RolesType::ROLES),
                    ),
                ),
            )),
        ),
    );
    let configuration = datadog::Configuration::new();
    let api = AuthNMappingsAPI::with_config(configuration);
    let resp = api
        .update_authn_mapping(authn_mapping_data_id.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_authn_mapping_with_http_info( &self, authn_mapping_id: String, body: AuthNMappingUpdateRequest, ) -> Result<ResponseContent<AuthNMappingResponse>, Error<UpdateAuthNMappingError>>

Edit an AuthN Mapping.

Trait Implementations

impl Clone for AuthNMappingsAPI

fn clone(&self) -> AuthNMappingsAPI

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AuthNMappingsAPI

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AuthNMappingsAPI

fn default() -> Self

Returns the “default value” for a type.