Struct datadog_api_client::datadogV1::api::api_webhooks_integration::WebhooksIntegrationAPI

pub struct WebhooksIntegrationAPI { /* private fields */ }

Configure your Datadog-Webhooks integration directly through the Datadog API. See the Webhooks integration page for more information.

Implementations

impl WebhooksIntegrationAPI

pub fn new() -> Self

pub fn with_config(config: Configuration) -> Self

Examples found in repository

examples/v1_webhooks-integration_get_webhooks_integration_custom_variable.rs (line 8)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api
        .get_webhooks_integration_custom_variable("custom_variable_name".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_webhooks-integration_get_webhooks_integration.rs (line 10)

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

examples/v1_webhooks-integration_delete_webhooks_integration.rs (line 10)

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

examples/v1_webhooks-integration_create_webhooks_integration.rs (line 13)

async fn main() {
    let body = WebhooksIntegration::new(
        "Example-Webhooks-Integration".to_string(),
        "https://example.com/webhook".to_string(),
    );
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api.create_webhooks_integration(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_webhooks-integration_create_webhooks_integration_custom_variable.rs (line 14)

async fn main() {
    let body = WebhooksIntegrationCustomVariable::new(
        true,
        "EXAMPLEWEBHOOKSINTEGRATION".to_string(),
        "CUSTOM_VARIABLE_VALUE".to_string(),
    );
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api.create_webhooks_integration_custom_variable(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

examples/v1_webhooks-integration_delete_webhooks_integration_custom_variable.rs (line 10)

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

Additional examples can be found in:

• examples/v1_webhooks-integration_update_webhooks_integration.rs
• examples/v1_webhooks-integration_update_webhooks_integration_custom_variable.rs

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

pub async fn create_webhooks_integration( &self, body: WebhooksIntegration, ) -> Result<WebhooksIntegration, Error<CreateWebhooksIntegrationError>>

Creates an endpoint with the name <WEBHOOK_NAME>.

Examples found in repository

examples/v1_webhooks-integration_create_webhooks_integration.rs (line 14)

async fn main() {
    let body = WebhooksIntegration::new(
        "Example-Webhooks-Integration".to_string(),
        "https://example.com/webhook".to_string(),
    );
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api.create_webhooks_integration(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_webhooks_integration_with_http_info( &self, body: WebhooksIntegration, ) -> Result<ResponseContent<WebhooksIntegration>, Error<CreateWebhooksIntegrationError>>

Creates an endpoint with the name <WEBHOOK_NAME>.

pub async fn create_webhooks_integration_custom_variable( &self, body: WebhooksIntegrationCustomVariable, ) -> Result<WebhooksIntegrationCustomVariableResponse, Error<CreateWebhooksIntegrationCustomVariableError>>

Creates an endpoint with the name <CUSTOM_VARIABLE_NAME>.

Examples found in repository

examples/v1_webhooks-integration_create_webhooks_integration_custom_variable.rs (line 15)

async fn main() {
    let body = WebhooksIntegrationCustomVariable::new(
        true,
        "EXAMPLEWEBHOOKSINTEGRATION".to_string(),
        "CUSTOM_VARIABLE_VALUE".to_string(),
    );
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api.create_webhooks_integration_custom_variable(body).await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn create_webhooks_integration_custom_variable_with_http_info( &self, body: WebhooksIntegrationCustomVariable, ) -> Result<ResponseContent<WebhooksIntegrationCustomVariableResponse>, Error<CreateWebhooksIntegrationCustomVariableError>>

Creates an endpoint with the name <CUSTOM_VARIABLE_NAME>.

pub async fn delete_webhooks_integration( &self, webhook_name: String, ) -> Result<(), Error<DeleteWebhooksIntegrationError>>

Deletes the endpoint with the name <WEBHOOK NAME>.

Examples found in repository

examples/v1_webhooks-integration_delete_webhooks_integration.rs (line 11)

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

pub async fn delete_webhooks_integration_with_http_info( &self, webhook_name: String, ) -> Result<ResponseContent<()>, Error<DeleteWebhooksIntegrationError>>

Deletes the endpoint with the name <WEBHOOK NAME>.

pub async fn delete_webhooks_integration_custom_variable( &self, custom_variable_name: String, ) -> Result<(), Error<DeleteWebhooksIntegrationCustomVariableError>>

Deletes the endpoint with the name <CUSTOM_VARIABLE_NAME>.

Examples found in repository

examples/v1_webhooks-integration_delete_webhooks_integration_custom_variable.rs (line 12)

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

pub async fn delete_webhooks_integration_custom_variable_with_http_info( &self, custom_variable_name: String, ) -> Result<ResponseContent<()>, Error<DeleteWebhooksIntegrationCustomVariableError>>

Deletes the endpoint with the name <CUSTOM_VARIABLE_NAME>.

pub async fn get_webhooks_integration( &self, webhook_name: String, ) -> Result<WebhooksIntegration, Error<GetWebhooksIntegrationError>>

Gets the content of the webhook with the name <WEBHOOK_NAME>.

Examples found in repository

examples/v1_webhooks-integration_get_webhooks_integration.rs (line 11)

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

pub async fn get_webhooks_integration_with_http_info( &self, webhook_name: String, ) -> Result<ResponseContent<WebhooksIntegration>, Error<GetWebhooksIntegrationError>>

Gets the content of the webhook with the name <WEBHOOK_NAME>.

pub async fn get_webhooks_integration_custom_variable( &self, custom_variable_name: String, ) -> Result<WebhooksIntegrationCustomVariableResponse, Error<GetWebhooksIntegrationCustomVariableError>>

Shows the content of the custom variable with the name <CUSTOM_VARIABLE_NAME>.

If the custom variable is secret, the value does not return in the response payload.

Examples found in repository

examples/v1_webhooks-integration_get_webhooks_integration_custom_variable.rs (line 10)

async fn main() {
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api
        .get_webhooks_integration_custom_variable("custom_variable_name".to_string())
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn get_webhooks_integration_custom_variable_with_http_info( &self, custom_variable_name: String, ) -> Result<ResponseContent<WebhooksIntegrationCustomVariableResponse>, Error<GetWebhooksIntegrationCustomVariableError>>

Shows the content of the custom variable with the name <CUSTOM_VARIABLE_NAME>.

If the custom variable is secret, the value does not return in the response payload.

pub async fn update_webhooks_integration( &self, webhook_name: String, body: WebhooksIntegrationUpdateRequest, ) -> Result<WebhooksIntegration, Error<UpdateWebhooksIntegrationError>>

Updates the endpoint with the name <WEBHOOK_NAME>.

Examples found in repository

examples/v1_webhooks-integration_update_webhooks_integration.rs (line 15)

async fn main() {
    // there is a valid "webhook" in the system
    let webhook_name = std::env::var("WEBHOOK_NAME").unwrap();
    let body = WebhooksIntegrationUpdateRequest::new()
        .url("https://example.com/webhook-updated".to_string());
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api
        .update_webhooks_integration(webhook_name.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_webhooks_integration_with_http_info( &self, webhook_name: String, body: WebhooksIntegrationUpdateRequest, ) -> Result<ResponseContent<WebhooksIntegration>, Error<UpdateWebhooksIntegrationError>>

Updates the endpoint with the name <WEBHOOK_NAME>.

pub async fn update_webhooks_integration_custom_variable( &self, custom_variable_name: String, body: WebhooksIntegrationCustomVariableUpdateRequest, ) -> Result<WebhooksIntegrationCustomVariableResponse, Error<UpdateWebhooksIntegrationCustomVariableError>>

Updates the endpoint with the name <CUSTOM_VARIABLE_NAME>.

Examples found in repository

examples/v1_webhooks-integration_update_webhooks_integration_custom_variable.rs (line 15)

async fn main() {
    // there is a valid "webhook_custom_variable" in the system
    let webhook_custom_variable_name = std::env::var("WEBHOOK_CUSTOM_VARIABLE_NAME").unwrap();
    let body =
        WebhooksIntegrationCustomVariableUpdateRequest::new().value("variable-updated".to_string());
    let configuration = datadog::Configuration::new();
    let api = WebhooksIntegrationAPI::with_config(configuration);
    let resp = api
        .update_webhooks_integration_custom_variable(webhook_custom_variable_name.clone(), body)
        .await;
    if let Ok(value) = resp {
        println!("{:#?}", value);
    } else {
        println!("{:#?}", resp.unwrap_err());
    }
}

pub async fn update_webhooks_integration_custom_variable_with_http_info( &self, custom_variable_name: String, body: WebhooksIntegrationCustomVariableUpdateRequest, ) -> Result<ResponseContent<WebhooksIntegrationCustomVariableResponse>, Error<UpdateWebhooksIntegrationCustomVariableError>>

Updates the endpoint with the name <CUSTOM_VARIABLE_NAME>.

Trait Implementations

impl Clone for WebhooksIntegrationAPI

fn clone(&self) -> WebhooksIntegrationAPI

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for WebhooksIntegrationAPI

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

Formats the value using the given formatter.

impl Default for WebhooksIntegrationAPI

fn default() -> Self

Returns the “default value” for a type.