#![allow(unused_mut)]
#![allow(unused_variables)]
#![allow(unused_imports)]
#![allow(clippy::redundant_clone)]
pub mod models;
#[derive(Clone)]
pub struct Client {
endpoint: String,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
pipeline: azure_core::Pipeline,
}
#[derive(Clone)]
pub struct ClientBuilder {
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
endpoint: Option<String>,
scopes: Option<Vec<String>>,
options: azure_core::ClientOptions,
}
pub const DEFAULT_ENDPOINT: &str = azure_core::resource_manager_endpoint::AZURE_PUBLIC_CLOUD;
impl ClientBuilder {
#[doc = "Create a new instance of `ClientBuilder`."]
#[must_use]
pub fn new(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> Self {
Self {
credential,
endpoint: None,
scopes: None,
options: azure_core::ClientOptions::default(),
}
}
#[doc = "Set the endpoint."]
#[must_use]
pub fn endpoint(mut self, endpoint: impl Into<String>) -> Self {
self.endpoint = Some(endpoint.into());
self
}
#[doc = "Set the scopes."]
#[must_use]
pub fn scopes(mut self, scopes: &[&str]) -> Self {
self.scopes = Some(scopes.iter().map(|scope| (*scope).to_owned()).collect());
self
}
#[doc = "Set the retry options."]
#[must_use]
pub fn retry(mut self, retry: impl Into<azure_core::RetryOptions>) -> Self {
self.options = self.options.retry(retry);
self
}
#[doc = "Set the transport options."]
#[must_use]
pub fn transport(mut self, transport: impl Into<azure_core::TransportOptions>) -> Self {
self.options = self.options.transport(transport);
self
}
#[doc = "Convert the builder into a `Client` instance."]
#[must_use]
pub fn build(self) -> Client {
let endpoint = self.endpoint.unwrap_or_else(|| DEFAULT_ENDPOINT.to_owned());
let scopes = self.scopes.unwrap_or_else(|| vec![format!("{}/", endpoint)]);
Client::new(endpoint, self.credential, scopes, self.options)
}
}
impl Client {
pub(crate) fn endpoint(&self) -> &str {
self.endpoint.as_str()
}
pub(crate) fn token_credential(&self) -> &dyn azure_core::auth::TokenCredential {
self.credential.as_ref()
}
pub(crate) fn scopes(&self) -> Vec<&str> {
self.scopes.iter().map(String::as_str).collect()
}
pub(crate) async fn send(&self, request: &mut azure_core::Request) -> azure_core::Result<azure_core::Response> {
let mut context = azure_core::Context::default();
self.pipeline.send(&mut context, request).await
}
#[doc = "Create a new `ClientBuilder`."]
#[must_use]
pub fn builder(credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>) -> ClientBuilder {
ClientBuilder::new(credential)
}
#[doc = "Create a new `Client`."]
#[must_use]
pub fn new(
endpoint: impl Into<String>,
credential: std::sync::Arc<dyn azure_core::auth::TokenCredential>,
scopes: Vec<String>,
options: azure_core::ClientOptions,
) -> Self {
let endpoint = endpoint.into();
let pipeline = azure_core::Pipeline::new(
option_env!("CARGO_PKG_NAME"),
option_env!("CARGO_PKG_VERSION"),
options,
Vec::new(),
Vec::new(),
);
Self {
endpoint,
credential,
scopes,
pipeline,
}
}
pub fn app_service_certificate_orders_client(&self) -> app_service_certificate_orders::Client {
app_service_certificate_orders::Client(self.clone())
}
pub fn app_service_environments_client(&self) -> app_service_environments::Client {
app_service_environments::Client(self.clone())
}
pub fn app_service_plans_client(&self) -> app_service_plans::Client {
app_service_plans::Client(self.clone())
}
pub fn certificate_orders_diagnostics_client(&self) -> certificate_orders_diagnostics::Client {
certificate_orders_diagnostics::Client(self.clone())
}
pub fn certificate_registration_provider_client(&self) -> certificate_registration_provider::Client {
certificate_registration_provider::Client(self.clone())
}
pub fn certificates_client(&self) -> certificates::Client {
certificates::Client(self.clone())
}
pub fn container_apps_client(&self) -> container_apps::Client {
container_apps::Client(self.clone())
}
pub fn container_apps_revisions_client(&self) -> container_apps_revisions::Client {
container_apps_revisions::Client(self.clone())
}
pub fn deleted_web_apps_client(&self) -> deleted_web_apps::Client {
deleted_web_apps::Client(self.clone())
}
pub fn diagnostics_client(&self) -> diagnostics::Client {
diagnostics::Client(self.clone())
}
pub fn domain_registration_provider_client(&self) -> domain_registration_provider::Client {
domain_registration_provider::Client(self.clone())
}
pub fn domains_client(&self) -> domains::Client {
domains::Client(self.clone())
}
pub fn global_client(&self) -> global::Client {
global::Client(self.clone())
}
pub fn kube_environments_client(&self) -> kube_environments::Client {
kube_environments::Client(self.clone())
}
pub fn provider_client(&self) -> provider::Client {
provider::Client(self.clone())
}
pub fn recommendations_client(&self) -> recommendations::Client {
recommendations::Client(self.clone())
}
pub fn resource_health_metadata_client(&self) -> resource_health_metadata::Client {
resource_health_metadata::Client(self.clone())
}
pub fn static_sites_client(&self) -> static_sites::Client {
static_sites::Client(self.clone())
}
pub fn top_level_domains_client(&self) -> top_level_domains::Client {
top_level_domains::Client(self.clone())
}
pub fn web_apps_client(&self) -> web_apps::Client {
web_apps::Client(self.clone())
}
pub fn workflow_run_action_repetitions_client(&self) -> workflow_run_action_repetitions::Client {
workflow_run_action_repetitions::Client(self.clone())
}
pub fn workflow_run_action_repetitions_request_histories_client(&self) -> workflow_run_action_repetitions_request_histories::Client {
workflow_run_action_repetitions_request_histories::Client(self.clone())
}
pub fn workflow_run_action_scope_repetitions_client(&self) -> workflow_run_action_scope_repetitions::Client {
workflow_run_action_scope_repetitions::Client(self.clone())
}
pub fn workflow_run_actions_client(&self) -> workflow_run_actions::Client {
workflow_run_actions::Client(self.clone())
}
pub fn workflow_runs_client(&self) -> workflow_runs::Client {
workflow_runs::Client(self.clone())
}
pub fn workflow_trigger_histories_client(&self) -> workflow_trigger_histories::Client {
workflow_trigger_histories::Client(self.clone())
}
pub fn workflow_triggers_client(&self) -> workflow_triggers::Client {
workflow_triggers::Client(self.clone())
}
pub fn workflow_versions_client(&self) -> workflow_versions::Client {
workflow_versions::Client(self.clone())
}
pub fn workflows_client(&self) -> workflows::Client {
workflows::Client(self.clone())
}
}
pub mod app_service_certificate_orders {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List all certificate orders in a subscription."]
#[doc = "Description for List all certificate orders in a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validate information for a certificate order."]
#[doc = "Description for Validate information for a certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `app_service_certificate_order`: Information for a certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate_purchase_information(
&self,
app_service_certificate_order: impl Into<models::AppServiceCertificateOrder>,
subscription_id: impl Into<String>,
) -> validate_purchase_information::RequestBuilder {
validate_purchase_information::RequestBuilder {
client: self.0.clone(),
app_service_certificate_order: app_service_certificate_order.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get certificate orders in a resource group."]
#[doc = "Description for Get certificate orders in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a certificate order."]
#[doc = "Description for Get a certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order.."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a certificate purchase order."]
#[doc = "Description for Create or update a certificate purchase order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `certificate_distinguished_name`: Distinguished name to use for the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
certificate_distinguished_name: impl Into<models::AppServiceCertificateOrder>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
certificate_distinguished_name: certificate_distinguished_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a certificate purchase order."]
#[doc = "Description for Create or update a certificate purchase order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `certificate_distinguished_name`: Distinguished name to use for the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
certificate_distinguished_name: impl Into<models::AppServiceCertificateOrderPatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
certificate_distinguished_name: certificate_distinguished_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete an existing certificate order."]
#[doc = "Description for Delete an existing certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all certificates associated with a certificate order."]
#[doc = "Description for List all certificates associated with a certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_certificates(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_certificates::RequestBuilder {
list_certificates::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the certificate associated with a certificate order."]
#[doc = "Description for Get the certificate associated with a certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_certificate(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_certificate::RequestBuilder {
get_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a certificate and associates with key vault secret."]
#[doc = "Description for Creates or updates a certificate and associates with key vault secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `key_vault_certificate`: Key vault certificate resource Id."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_certificate(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
name: impl Into<String>,
key_vault_certificate: impl Into<models::AppServiceCertificateResource>,
subscription_id: impl Into<String>,
) -> create_or_update_certificate::RequestBuilder {
create_or_update_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
name: name.into(),
key_vault_certificate: key_vault_certificate.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a certificate and associates with key vault secret."]
#[doc = "Description for Creates or updates a certificate and associates with key vault secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `key_vault_certificate`: Key vault certificate resource Id."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_certificate(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
name: impl Into<String>,
key_vault_certificate: impl Into<models::AppServiceCertificatePatchResource>,
subscription_id: impl Into<String>,
) -> update_certificate::RequestBuilder {
update_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
name: name.into(),
key_vault_certificate: key_vault_certificate.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete the certificate associated with a certificate order."]
#[doc = "Description for Delete the certificate associated with a certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_certificate(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_certificate::RequestBuilder {
delete_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reissue an existing certificate order."]
#[doc = "Description for Reissue an existing certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `reissue_certificate_order_request`: Parameters for the reissue."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reissue(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
reissue_certificate_order_request: impl Into<models::ReissueCertificateOrderRequest>,
subscription_id: impl Into<String>,
) -> reissue::RequestBuilder {
reissue::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
reissue_certificate_order_request: reissue_certificate_order_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Renew an existing certificate order."]
#[doc = "Description for Renew an existing certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `renew_certificate_order_request`: Renew parameters"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn renew(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
renew_certificate_order_request: impl Into<models::RenewCertificateOrderRequest>,
subscription_id: impl Into<String>,
) -> renew::RequestBuilder {
renew::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
renew_certificate_order_request: renew_certificate_order_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resend certificate email."]
#[doc = "Description for Resend certificate email."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn resend_email(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> resend_email::RequestBuilder {
resend_email::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resend domain verification email to customer for this certificate order"]
#[doc = "Resend domain verification ownership email containing steps on how to verify a domain for a given certificate order"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `name_identifier`: Email address"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn resend_request_emails(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
name_identifier: impl Into<models::NameIdentifier>,
subscription_id: impl Into<String>,
) -> resend_request_emails::RequestBuilder {
resend_request_emails::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
name_identifier: name_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "This method is used to obtain the site seal information for an issued certificate. "]
#[doc = "This method is used to obtain the site seal information for an issued certificate. A site seal is a graphic that the certificate purchaser can embed on their web site to show their visitors information about their SSL certificate. If a web site visitor clicks on the site seal image, a pop-up page is displayed that contains detailed information about the SSL certificate. The site seal token is used to link the site seal graphic image to the appropriate certificate details pop-up page display when a user clicks on the site seal. The site seal images are expected to be static images and hosted by the reseller, to minimize delays for customer page load times."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `site_seal_request`: Site seal request."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn retrieve_site_seal(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
site_seal_request: impl Into<models::SiteSealRequest>,
subscription_id: impl Into<String>,
) -> retrieve_site_seal::RequestBuilder {
retrieve_site_seal::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
site_seal_request: site_seal_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Verify domain ownership for this certificate order."]
#[doc = "Description for Verify domain ownership for this certificate order."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn verify_domain_ownership(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> verify_domain_ownership::RequestBuilder {
verify_domain_ownership::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieve the list of certificate actions."]
#[doc = "Description for Retrieve the list of certificate actions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn retrieve_certificate_actions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> retrieve_certificate_actions::RequestBuilder {
retrieve_certificate_actions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieve email history."]
#[doc = "Description for Retrieve email history."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate order."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn retrieve_certificate_email_history(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> retrieve_certificate_email_history::RequestBuilder {
retrieve_certificate_email_history::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateOrderCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateOrderCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServiceCertificateOrderCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.CertificateRegistration/certificateOrders",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod validate_purchase_information {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) app_service_certificate_order: models::AppServiceCertificateOrder,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.CertificateRegistration/validateCertificateRegistrationInformation",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_service_certificate_order)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateOrderCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateOrderCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServiceCertificateOrderCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateOrder> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateOrder = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.certificate_order_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateOrder>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateOrder> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateOrder = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) certificate_distinguished_name: models::AppServiceCertificateOrder,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.certificate_order_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.certificate_distinguished_name)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateOrder>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateOrder> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateOrder = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) certificate_distinguished_name: models::AppServiceCertificateOrderPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.certificate_order_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.certificate_distinguished_name)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateOrder>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.certificate_order_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_certificates {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServiceCertificateCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/certificates" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_certificate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/certificates/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_certificate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) name: String,
pub(crate) key_vault_certificate: models::AppServiceCertificateResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/certificates/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key_vault_certificate)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_certificate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceCertificateResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceCertificateResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) name: String,
pub(crate) key_vault_certificate: models::AppServiceCertificatePatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/certificates/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key_vault_certificate)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceCertificateResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_certificate {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/certificates/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod reissue {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) reissue_certificate_order_request: models::ReissueCertificateOrderRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/reissue" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.reissue_certificate_order_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod renew {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) renew_certificate_order_request: models::RenewCertificateOrderRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/renew",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.certificate_order_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.renew_certificate_order_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod resend_email {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/resendEmail" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod resend_request_emails {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) name_identifier: models::NameIdentifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/resendRequestEmails" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.name_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod retrieve_site_seal {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSeal> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSeal = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) site_seal_request: models::SiteSealRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/retrieveSiteSeal" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_seal_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSeal>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod verify_domain_ownership {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/verifyDomainOwnership" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod retrieve_certificate_actions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::CertificateOrderAction>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::CertificateOrderAction> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/retrieveCertificateActions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::CertificateOrderAction>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod retrieve_certificate_email_history {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::CertificateEmail>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::CertificateEmail> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/retrieveEmailHistory" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::CertificateEmail>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod certificate_orders_diagnostics {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Microsoft.CertificateRegistration to get the list of detectors for this RP."]
#[doc = "Description for Microsoft.CertificateRegistration to get the list of detectors for this RP."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: The certificate order name for which the response is needed."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_app_service_certificate_order_detector_response(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_app_service_certificate_order_detector_response::RequestBuilder {
list_app_service_certificate_order_detector_response::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Microsoft.CertificateRegistration call to get a detector response from App Lens."]
#[doc = "Description for Microsoft.CertificateRegistration call to get a detector response from App Lens."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `certificate_order_name`: The certificate order name for which the response is needed."]
#[doc = "* `detector_name`: The detector name which needs to be run."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_app_service_certificate_order_detector_response(
&self,
resource_group_name: impl Into<String>,
certificate_order_name: impl Into<String>,
detector_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_app_service_certificate_order_detector_response::RequestBuilder {
get_app_service_certificate_order_detector_response::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
certificate_order_name: certificate_order_name.into(),
detector_name: detector_name.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
}
pub mod list_app_service_certificate_order_detector_response {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponseCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponseCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DetectorResponseCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/detectors" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_app_service_certificate_order_detector_response {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) certificate_order_name: String,
pub(crate) detector_name: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "The start time for detector response."]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "The end time for the detector response."]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "The time grain for the detector response."]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.CertificateRegistration/certificateOrders/{}/detectors/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . certificate_order_name , & this . detector_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod certificate_registration_provider {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Implements Csm operations Api to exposes the list of available Csm Apis under the resource provider"]
#[doc = "Description for Implements Csm operations Api to exposes the list of available Csm Apis under the resource provider"]
pub fn list_operations(&self) -> list_operations::RequestBuilder {
list_operations::RequestBuilder { client: self.0.clone() }
}
}
pub mod list_operations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmOperationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmOperationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CsmOperationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.CertificateRegistration/operations",
this.client.endpoint(),
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod domains {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Check if a domain is available for registration."]
#[doc = "Description for Check if a domain is available for registration."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `identifier`: Name of the domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn check_availability(
&self,
identifier: impl Into<models::NameIdentifier>,
subscription_id: impl Into<String>,
) -> check_availability::RequestBuilder {
check_availability::RequestBuilder {
client: self.0.clone(),
identifier: identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all domains in a subscription."]
#[doc = "Description for Get all domains in a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Generate a single sign-on request for the domain management portal."]
#[doc = "Description for Generate a single sign-on request for the domain management portal."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_control_center_sso_request(&self, subscription_id: impl Into<String>) -> get_control_center_sso_request::RequestBuilder {
get_control_center_sso_request::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get domain name recommendations based on keywords."]
#[doc = "Description for Get domain name recommendations based on keywords."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `parameters`: Search parameters for domain name recommendations."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_recommendations(
&self,
parameters: impl Into<models::DomainRecommendationSearchParameters>,
subscription_id: impl Into<String>,
) -> list_recommendations::RequestBuilder {
list_recommendations::RequestBuilder {
client: self.0.clone(),
parameters: parameters.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all domains in a resource group."]
#[doc = "Description for Get all domains in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a domain."]
#[doc = "Description for Get a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of the domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a domain."]
#[doc = "Description for Creates or updates a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of the domain."]
#[doc = "* `domain`: Domain registration information."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
domain: impl Into<models::Domain>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
domain: domain.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a domain."]
#[doc = "Description for Creates or updates a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of the domain."]
#[doc = "* `domain`: Domain registration information."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
domain: impl Into<models::DomainPatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
domain: domain.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a domain."]
#[doc = "Description for Delete a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of the domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
force_hard_delete_domain: None,
}
}
#[doc = "Lists domain ownership identifiers."]
#[doc = "Description for Lists domain ownership identifiers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_ownership_identifiers(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_ownership_identifiers::RequestBuilder {
list_ownership_identifiers::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get ownership identifier for domain"]
#[doc = "Description for Get ownership identifier for domain"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `name`: Name of identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ownership_identifier::RequestBuilder {
get_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates an ownership identifier for a domain or updates identifier details for an existing identifier"]
#[doc = "Description for Creates an ownership identifier for a domain or updates identifier details for an existing identifier"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `name`: Name of identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier: impl Into<models::DomainOwnershipIdentifier>,
subscription_id: impl Into<String>,
) -> create_or_update_ownership_identifier::RequestBuilder {
create_or_update_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
name: name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates an ownership identifier for a domain or updates identifier details for an existing identifier"]
#[doc = "Description for Creates an ownership identifier for a domain or updates identifier details for an existing identifier"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `name`: Name of identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier: impl Into<models::DomainOwnershipIdentifier>,
subscription_id: impl Into<String>,
) -> update_ownership_identifier::RequestBuilder {
update_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
name: name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete ownership identifier for domain"]
#[doc = "Description for Delete ownership identifier for domain"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `name`: Name of identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_ownership_identifier::RequestBuilder {
delete_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Renew a domain."]
#[doc = "Description for Renew a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of the domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn renew(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> renew::RequestBuilder {
renew::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Transfer out domain to another registrar"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `domain_name`: Name of domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn transfer_out(
&self,
resource_group_name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> transfer_out::RequestBuilder {
transfer_out::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod check_availability {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainAvailabilityCheckResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainAvailabilityCheckResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) identifier: models::NameIdentifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/checkDomainAvailability",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DomainAvailabilityCheckResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DomainCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/domains",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_control_center_sso_request {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainControlCenterSsoRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainControlCenterSsoRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/generateSsoRequest",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DomainControlCenterSsoRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_recommendations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::NameIdentifierCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::NameIdentifierCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) parameters: models::DomainRecommendationSearchParameters,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::NameIdentifierCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/listDomainRecommendations",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DomainCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Domain> {
let bytes = self.0.into_body().collect().await?;
let body: models::Domain = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Domain>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Domain> {
let bytes = self.0.into_body().collect().await?;
let body: models::Domain = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) domain: models::Domain,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Domain>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Domain> {
let bytes = self.0.into_body().collect().await?;
let body: models::Domain = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) domain: models::DomainPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Domain>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
pub(crate) force_hard_delete_domain: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to delete the domain immediately. The default is <code>false</code> which deletes the domain after 24 hours."]
pub fn force_hard_delete_domain(mut self, force_hard_delete_domain: bool) -> Self {
self.force_hard_delete_domain = Some(force_hard_delete_domain);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(force_hard_delete_domain) = &this.force_hard_delete_domain {
req.url_mut()
.query_pairs_mut()
.append_pair("forceHardDeleteDomain", &force_hard_delete_domain.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_ownership_identifiers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainOwnershipIdentifierCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainOwnershipIdentifierCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DomainOwnershipIdentifierCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/domainOwnershipIdentifiers" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . domain_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainOwnershipIdentifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainOwnershipIdentifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/domainOwnershipIdentifiers/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . domain_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DomainOwnershipIdentifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainOwnershipIdentifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainOwnershipIdentifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier: models::DomainOwnershipIdentifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/domainOwnershipIdentifiers/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . domain_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DomainOwnershipIdentifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DomainOwnershipIdentifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::DomainOwnershipIdentifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier: models::DomainOwnershipIdentifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/domainOwnershipIdentifiers/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . domain_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DomainOwnershipIdentifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/domainOwnershipIdentifiers/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . domain_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod renew {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/renew",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod transfer_out {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Domain> {
let bytes = self.0.into_body().collect().await?;
let body: models::Domain = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.DomainRegistration/domains/{}/transferOut",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Domain>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod top_level_domains {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all top-level domains supported for registration."]
#[doc = "Description for Get all top-level domains supported for registration."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get details of a top-level domain."]
#[doc = "Description for Get details of a top-level domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: Name of the top-level domain."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(&self, name: impl Into<String>, subscription_id: impl Into<String>) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all legal agreements that user needs to accept before purchasing a domain."]
#[doc = "Description for Gets all legal agreements that user needs to accept before purchasing a domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: Name of the top-level domain."]
#[doc = "* `agreement_option`: Domain agreement options."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_agreements(
&self,
name: impl Into<String>,
agreement_option: impl Into<models::TopLevelDomainAgreementOption>,
subscription_id: impl Into<String>,
) -> list_agreements::RequestBuilder {
list_agreements::RequestBuilder {
client: self.0.clone(),
name: name.into(),
agreement_option: agreement_option.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TopLevelDomainCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TopLevelDomainCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TopLevelDomainCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/topLevelDomains",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TopLevelDomain> {
let bytes = self.0.into_body().collect().await?;
let body: models::TopLevelDomain = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/topLevelDomains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TopLevelDomain>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_agreements {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TldLegalAgreementCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TldLegalAgreementCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) name: String,
pub(crate) agreement_option: models::TopLevelDomainAgreementOption,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TldLegalAgreementCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.DomainRegistration/topLevelDomains/{}/listAgreements",
this.client.endpoint(),
&this.subscription_id,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.agreement_option)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod domain_registration_provider {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Implements Csm operations Api to exposes the list of available Csm Apis under the resource provider"]
#[doc = "Description for Implements Csm operations Api to exposes the list of available Csm Apis under the resource provider"]
pub fn list_operations(&self) -> list_operations::RequestBuilder {
list_operations::RequestBuilder { client: self.0.clone() }
}
}
pub mod list_operations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmOperationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmOperationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CsmOperationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.DomainRegistration/operations",
this.client.endpoint(),
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod app_service_environments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all App Service Environments for a subscription."]
#[doc = "Description for Get all App Service Environments for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all App Service Environments in a resource group."]
#[doc = "Description for Get all App Service Environments in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the properties of an App Service Environment."]
#[doc = "Description for Get the properties of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update an App Service Environment."]
#[doc = "Description for Create or update an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `hosting_environment_envelope`: Configuration details of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
hosting_environment_envelope: impl Into<models::AppServiceEnvironmentResource>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
hosting_environment_envelope: hosting_environment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update an App Service Environment."]
#[doc = "Description for Create or update an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `hosting_environment_envelope`: Configuration details of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
hosting_environment_envelope: impl Into<models::AppServiceEnvironmentPatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
hosting_environment_envelope: hosting_environment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete an App Service Environment."]
#[doc = "Description for Delete an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
force_delete: None,
}
}
#[doc = "Get the used, available, and total worker capacity an App Service Environment."]
#[doc = "Description for Get the used, available, and total worker capacity an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_capacities(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_capacities::RequestBuilder {
list_capacities::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get IP addresses assigned to an App Service Environment."]
#[doc = "Description for Get IP addresses assigned to an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vip_info(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vip_info::RequestBuilder {
get_vip_info::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Move an App Service Environment to a different VNET."]
#[doc = "Description for Move an App Service Environment to a different VNET."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `vnet_info`: Details for the new virtual network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn change_vnet(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_info: impl Into<models::VirtualNetworkProfile>,
subscription_id: impl Into<String>,
) -> change_vnet::RequestBuilder {
change_vnet::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_info: vnet_info.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Custom Dns Suffix configuration of an App Service Environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ase_custom_dns_suffix_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ase_custom_dns_suffix_configuration::RequestBuilder {
get_ase_custom_dns_suffix_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Update Custom Dns Suffix configuration of an App Service Environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_ase_custom_dns_suffix_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
custom_dns_suffix_configuration: impl Into<models::CustomDnsSuffixConfiguration>,
subscription_id: impl Into<String>,
) -> update_ase_custom_dns_suffix_configuration::RequestBuilder {
update_ase_custom_dns_suffix_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
custom_dns_suffix_configuration: custom_dns_suffix_configuration.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete Custom Dns Suffix configuration of an App Service Environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_ase_custom_dns_suffix_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_ase_custom_dns_suffix_configuration::RequestBuilder {
delete_ase_custom_dns_suffix_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get networking configuration of an App Service Environment"]
#[doc = "Description for Get networking configuration of an App Service Environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ase_v3_networking_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ase_v3_networking_configuration::RequestBuilder {
get_ase_v3_networking_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Update networking configuration of an App Service Environment"]
#[doc = "Description for Update networking configuration of an App Service Environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_ase_networking_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
ase_networking_configuration: impl Into<models::AseV3NetworkingConfiguration>,
subscription_id: impl Into<String>,
) -> update_ase_networking_configuration::RequestBuilder {
update_ase_networking_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
ase_networking_configuration: ase_networking_configuration.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get diagnostic information for an App Service Environment."]
#[doc = "Description for Get diagnostic information for an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_diagnostics(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_diagnostics::RequestBuilder {
list_diagnostics::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a diagnostics item for an App Service Environment."]
#[doc = "Description for Get a diagnostics item for an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `diagnostics_name`: Name of the diagnostics item."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_diagnostics_item(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
diagnostics_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_diagnostics_item::RequestBuilder {
get_diagnostics_item::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
diagnostics_name: diagnostics_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the network endpoints of all inbound dependencies of an App Service Environment."]
#[doc = "Description for Get the network endpoints of all inbound dependencies of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_inbound_network_dependencies_endpoints(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_inbound_network_dependencies_endpoints::RequestBuilder {
get_inbound_network_dependencies_endpoints::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all multi-role pools."]
#[doc = "Description for Get all multi-role pools."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_multi_role_pools(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_multi_role_pools::RequestBuilder {
list_multi_role_pools::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get properties of a multi-role pool."]
#[doc = "Description for Get properties of a multi-role pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_multi_role_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_multi_role_pool::RequestBuilder {
get_multi_role_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a multi-role pool."]
#[doc = "Description for Create or update a multi-role pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `multi_role_pool_envelope`: Properties of the multi-role pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_multi_role_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
multi_role_pool_envelope: impl Into<models::WorkerPoolResource>,
subscription_id: impl Into<String>,
) -> create_or_update_multi_role_pool::RequestBuilder {
create_or_update_multi_role_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
multi_role_pool_envelope: multi_role_pool_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a multi-role pool."]
#[doc = "Description for Create or update a multi-role pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `multi_role_pool_envelope`: Properties of the multi-role pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_multi_role_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
multi_role_pool_envelope: impl Into<models::WorkerPoolResource>,
subscription_id: impl Into<String>,
) -> update_multi_role_pool::RequestBuilder {
update_multi_role_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
multi_role_pool_envelope: multi_role_pool_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get metric definitions for a specific instance of a multi-role pool of an App Service Environment."]
#[doc = "Description for Get metric definitions for a specific instance of a multi-role pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `instance`: Name of the instance in the multi-role pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_multi_role_pool_instance_metric_definitions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_multi_role_pool_instance_metric_definitions::RequestBuilder {
list_multi_role_pool_instance_metric_definitions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance: instance.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get metric definitions for a multi-role pool of an App Service Environment."]
#[doc = "Description for Get metric definitions for a multi-role pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_multi_role_metric_definitions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_multi_role_metric_definitions::RequestBuilder {
list_multi_role_metric_definitions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get available SKUs for scaling a multi-role pool."]
#[doc = "Description for Get available SKUs for scaling a multi-role pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_multi_role_pool_skus(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_multi_role_pool_skus::RequestBuilder {
list_multi_role_pool_skus::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Send a test notification that an upgrade is available for this App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn test_upgrade_available_notification(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> test_upgrade_available_notification::RequestBuilder {
test_upgrade_available_notification::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Initiate an upgrade of an App Service Environment if one is available."]
#[doc = "Description for Initiate an upgrade of an App Service Environment if one is available."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn upgrade(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> upgrade::RequestBuilder {
upgrade::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get usage metrics for a multi-role pool of an App Service Environment."]
#[doc = "Description for Get usage metrics for a multi-role pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_multi_role_usages(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_multi_role_usages::RequestBuilder {
list_multi_role_usages::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all currently running operations on the App Service Environment."]
#[doc = "Description for List all currently running operations on the App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_operations(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_operations::RequestBuilder {
list_operations::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the network endpoints of all outbound dependencies of an App Service Environment."]
#[doc = "Description for Get the network endpoints of all outbound dependencies of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_outbound_network_dependencies_endpoints(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_outbound_network_dependencies_endpoints::RequestBuilder {
get_outbound_network_dependencies_endpoints::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the list of private endpoints associated with a hosting environment"]
#[doc = "Description for Gets the list of private endpoints associated with a hosting environment"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection_list(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection_list::RequestBuilder {
get_private_endpoint_connection_list::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a private endpoint connection"]
#[doc = "Description for Gets a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection::RequestBuilder {
get_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Approves or rejects a private endpoint connection"]
#[doc = "Description for Approves or rejects a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn approve_or_reject_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
private_endpoint_wrapper: impl Into<models::PrivateLinkConnectionApprovalRequestResource>,
subscription_id: impl Into<String>,
) -> approve_or_reject_private_endpoint_connection::RequestBuilder {
approve_or_reject_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
private_endpoint_wrapper: private_endpoint_wrapper.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a private endpoint connection"]
#[doc = "Description for Deletes a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_private_endpoint_connection::RequestBuilder {
delete_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the private link resources"]
#[doc = "Description for Gets the private link resources"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_link_resources(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_link_resources::RequestBuilder {
get_private_link_resources::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reboot all machines in an App Service Environment."]
#[doc = "Description for Reboot all machines in an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reboot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> reboot::RequestBuilder {
reboot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resume an App Service Environment."]
#[doc = "Description for Resume an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn resume(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> resume::RequestBuilder {
resume::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all App Service plans in an App Service Environment."]
#[doc = "Description for Get all App Service plans in an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_app_service_plans(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_app_service_plans::RequestBuilder {
list_app_service_plans::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all apps in an App Service Environment."]
#[doc = "Description for Get all apps in an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_apps(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_apps::RequestBuilder {
list_web_apps::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
properties_to_include: None,
}
}
#[doc = "Suspend an App Service Environment."]
#[doc = "Description for Suspend an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn suspend(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> suspend::RequestBuilder {
suspend::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get global usage metrics of an App Service Environment."]
#[doc = "Description for Get global usage metrics of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_usages(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_usages::RequestBuilder {
list_usages::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Get all worker pools of an App Service Environment."]
#[doc = "Description for Get all worker pools of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_worker_pools(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_worker_pools::RequestBuilder {
list_worker_pools::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get properties of a worker pool."]
#[doc = "Description for Get properties of a worker pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_worker_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_worker_pool::RequestBuilder {
get_worker_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a worker pool."]
#[doc = "Description for Create or update a worker pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `worker_pool_envelope`: Properties of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_worker_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
worker_pool_envelope: impl Into<models::WorkerPoolResource>,
subscription_id: impl Into<String>,
) -> create_or_update_worker_pool::RequestBuilder {
create_or_update_worker_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
worker_pool_envelope: worker_pool_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a worker pool."]
#[doc = "Description for Create or update a worker pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `worker_pool_envelope`: Properties of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_worker_pool(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
worker_pool_envelope: impl Into<models::WorkerPoolResource>,
subscription_id: impl Into<String>,
) -> update_worker_pool::RequestBuilder {
update_worker_pool::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
worker_pool_envelope: worker_pool_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get metric definitions for a specific instance of a worker pool of an App Service Environment."]
#[doc = "Description for Get metric definitions for a specific instance of a worker pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `instance`: Name of the instance in the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_worker_pool_instance_metric_definitions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
instance: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_worker_pool_instance_metric_definitions::RequestBuilder {
list_worker_pool_instance_metric_definitions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
instance: instance.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get metric definitions for a worker pool of an App Service Environment."]
#[doc = "Description for Get metric definitions for a worker pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_worker_metric_definitions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_worker_metric_definitions::RequestBuilder {
list_web_worker_metric_definitions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get available SKUs for scaling a worker pool."]
#[doc = "Description for Get available SKUs for scaling a worker pool."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_worker_pool_skus(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_worker_pool_skus::RequestBuilder {
list_worker_pool_skus::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get usage metrics for a worker pool of an App Service Environment."]
#[doc = "Description for Get usage metrics for a worker pool of an App Service Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service Environment."]
#[doc = "* `worker_pool_name`: Name of the worker pool."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_worker_usages(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_pool_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_worker_usages::RequestBuilder {
list_web_worker_usages::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_pool_name: worker_pool_name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceEnvironmentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceEnvironmentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServiceEnvironmentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/hostingEnvironments",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceEnvironmentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceEnvironmentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServiceEnvironmentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceEnvironmentResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceEnvironmentResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceEnvironmentResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceEnvironmentResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceEnvironmentResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) hosting_environment_envelope: models::AppServiceEnvironmentResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.hosting_environment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceEnvironmentResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServiceEnvironmentResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServiceEnvironmentResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) hosting_environment_envelope: models::AppServiceEnvironmentPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.hosting_environment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServiceEnvironmentResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) force_delete: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to force the deletion even if the App Service Environment contains resources. The default is <code>false</code>."]
pub fn force_delete(mut self, force_delete: bool) -> Self {
self.force_delete = Some(force_delete);
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(force_delete) = &this.force_delete {
req.url_mut()
.query_pairs_mut()
.append_pair("forceDelete", &force_delete.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_capacities {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StampCapacityCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StampCapacityCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StampCapacityCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/capacities/compute",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_vip_info {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AddressResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::AddressResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/capacities/virtualip",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AddressResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod change_vnet {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_info: models::VirtualNetworkProfile,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/changeVirtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.vnet_info)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
azure_core::StatusCode::Accepted => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_ase_custom_dns_suffix_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomDnsSuffixConfiguration> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomDnsSuffixConfiguration = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/configurations/customdnssuffix" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomDnsSuffixConfiguration>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_ase_custom_dns_suffix_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomDnsSuffixConfiguration> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomDnsSuffixConfiguration = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) custom_dns_suffix_configuration: models::CustomDnsSuffixConfiguration,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/configurations/customdnssuffix" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.custom_dns_suffix_configuration)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomDnsSuffixConfiguration>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_ase_custom_dns_suffix_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/configurations/customdnssuffix" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_ase_v3_networking_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AseV3NetworkingConfiguration> {
let bytes = self.0.into_body().collect().await?;
let body: models::AseV3NetworkingConfiguration = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/configurations/networking" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AseV3NetworkingConfiguration>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_ase_networking_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AseV3NetworkingConfiguration> {
let bytes = self.0.into_body().collect().await?;
let body: models::AseV3NetworkingConfiguration = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) ase_networking_configuration: models::AseV3NetworkingConfiguration,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/configurations/networking" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.ase_networking_configuration)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AseV3NetworkingConfiguration>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_diagnostics {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::HostingEnvironmentDiagnostics>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::HostingEnvironmentDiagnostics> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/diagnostics",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::HostingEnvironmentDiagnostics>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_diagnostics_item {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostingEnvironmentDiagnostics> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostingEnvironmentDiagnostics = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) diagnostics_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/diagnostics/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.diagnostics_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostingEnvironmentDiagnostics>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_inbound_network_dependencies_endpoints {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::InboundEnvironmentEndpointCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::InboundEnvironmentEndpointCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::InboundEnvironmentEndpointCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/inboundNetworkDependenciesEndpoints" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_multi_role_pools {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WorkerPoolCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_multi_role_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_multi_role_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) multi_role_pool_envelope: models::WorkerPoolResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.multi_role_pool_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_multi_role_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) multi_role_pool_envelope: models::WorkerPoolResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.multi_role_pool_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_multi_role_pool_instance_metric_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceMetricDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceMetricDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceMetricDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default/instances/{}/metricdefinitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . instance)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_multi_role_metric_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceMetricDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceMetricDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceMetricDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default/metricdefinitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_multi_role_pool_skus {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SkuInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SkuInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SkuInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default/skus" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod test_upgrade_available_notification {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/testUpgradeAvailableNotification" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod upgrade {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/upgrade",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_multi_role_usages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::UsageCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::UsageCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::UsageCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/multiRolePools/default/usages" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_operations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::Operation>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::Operation> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/operations",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::Operation>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_outbound_network_dependencies_endpoints {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::OutboundEnvironmentEndpointCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::OutboundEnvironmentEndpointCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::OutboundEnvironmentEndpointCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/outboundNetworkDependenciesEndpoints" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_private_endpoint_connection_list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnectionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateEndpointConnectionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PrivateEndpointConnectionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/privateEndpointConnections" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/privateEndpointConnections/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . private_endpoint_connection_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod approve_or_reject_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) private_endpoint_wrapper: models::PrivateLinkConnectionApprovalRequestResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/privateEndpointConnections/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . private_endpoint_connection_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.private_endpoint_wrapper)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/privateEndpointConnections/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . private_endpoint_connection_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_link_resources {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResourcesWrapper> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateLinkResourcesWrapper = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/privateLinkResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateLinkResourcesWrapper>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod reboot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/reboot",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod resume {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/resume",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
azure_core::StatusCode::Accepted => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_app_service_plans {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlanCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlanCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServicePlanCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/serverfarms",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_web_apps {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) properties_to_include: Option<String>,
}
impl RequestBuilder {
#[doc = "Comma separated list of app properties to include."]
pub fn properties_to_include(mut self, properties_to_include: impl Into<String>) -> Self {
self.properties_to_include = Some(properties_to_include.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/sites",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(properties_to_include) = &this.properties_to_include {
req.url_mut()
.query_pairs_mut()
.append_pair("propertiesToInclude", properties_to_include);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod suspend {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/suspend",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
azure_core::StatusCode::Accepted => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_usages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmUsageQuotaCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmUsageQuotaCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only usages/metrics specified in the filter. Filter conforms to odata syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[Hour|Minute|Day]'."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CsmUsageQuotaCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/usages",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_worker_pools {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WorkerPoolCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_worker_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_pool_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_worker_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) worker_pool_envelope: models::WorkerPoolResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_pool_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.worker_pool_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_worker_pool {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkerPoolResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkerPoolResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) worker_pool_envelope: models::WorkerPoolResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_pool_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.worker_pool_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkerPoolResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_worker_pool_instance_metric_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceMetricDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceMetricDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) instance: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceMetricDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}/instances/{}/metricdefinitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . worker_pool_name , & this . instance)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_web_worker_metric_definitions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceMetricDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceMetricDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceMetricDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}/metricdefinitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . worker_pool_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_worker_pool_skus {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SkuInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SkuInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SkuInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}/skus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_pool_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_web_worker_usages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::UsageCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::UsageCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_pool_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::UsageCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/workerPools/{}/usages",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_pool_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod app_service_plans {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all App Service plans for a subscription."]
#[doc = "Description for Get all App Service plans for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
detailed: None,
}
}
#[doc = "Get all App Service plans in a resource group."]
#[doc = "Description for Get all App Service plans in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get an App Service plan."]
#[doc = "Description for Get an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates an App Service Plan."]
#[doc = "Description for Creates or updates an App Service Plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `app_service_plan`: Details of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_service_plan: impl Into<models::AppServicePlan>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_service_plan: app_service_plan.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates an App Service Plan."]
#[doc = "Description for Creates or updates an App Service Plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `app_service_plan`: Details of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_service_plan: impl Into<models::AppServicePlanPatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_service_plan: app_service_plan.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete an App Service plan."]
#[doc = "Description for Delete an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all capabilities of an App Service plan."]
#[doc = "Description for List all capabilities of an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_capabilities(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_capabilities::RequestBuilder {
list_capabilities::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieve a Hybrid Connection in use in an App Service plan."]
#[doc = "Description for Retrieve a Hybrid Connection in use in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `namespace_name`: Name of the Service Bus namespace."]
#[doc = "* `relay_name`: Name of the Service Bus relay."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_hybrid_connection::RequestBuilder {
get_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a Hybrid Connection in use in an App Service plan."]
#[doc = "Description for Delete a Hybrid Connection in use in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `namespace_name`: Name of the Service Bus namespace."]
#[doc = "* `relay_name`: Name of the Service Bus relay."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_hybrid_connection::RequestBuilder {
delete_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the send key name and value of a Hybrid Connection."]
#[doc = "Description for Get the send key name and value of a Hybrid Connection."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `namespace_name`: The name of the Service Bus namespace."]
#[doc = "* `relay_name`: The name of the Service Bus relay."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_hybrid_connection_keys(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_hybrid_connection_keys::RequestBuilder {
list_hybrid_connection_keys::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all apps that use a Hybrid Connection in an App Service Plan."]
#[doc = "Description for Get all apps that use a Hybrid Connection in an App Service Plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `namespace_name`: Name of the Hybrid Connection namespace."]
#[doc = "* `relay_name`: Name of the Hybrid Connection relay."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_apps_by_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_apps_by_hybrid_connection::RequestBuilder {
list_web_apps_by_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the maximum number of Hybrid Connections allowed in an App Service plan."]
#[doc = "Description for Get the maximum number of Hybrid Connections allowed in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_hybrid_connection_plan_limit(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_hybrid_connection_plan_limit::RequestBuilder {
get_hybrid_connection_plan_limit::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieve all Hybrid Connections in use in an App Service plan."]
#[doc = "Description for Retrieve all Hybrid Connections in use in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_hybrid_connections(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_hybrid_connections::RequestBuilder {
list_hybrid_connections::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restart all apps in an App Service plan."]
#[doc = "Description for Restart all apps in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restart_web_apps(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> restart_web_apps::RequestBuilder {
restart_web_apps::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
soft_restart: None,
}
}
#[doc = "Get all apps associated with an App Service plan."]
#[doc = "Description for Get all apps associated with an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_apps(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_apps::RequestBuilder {
list_web_apps::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
skip_token: None,
filter: None,
top: None,
}
}
#[doc = "Gets all selectable SKUs for a given App Service Plan"]
#[doc = "Description for Gets all selectable SKUs for a given App Service Plan"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of App Service Plan"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_server_farm_skus(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_server_farm_skus::RequestBuilder {
get_server_farm_skus::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets server farm usage information"]
#[doc = "Description for Gets server farm usage information"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of App Service Plan"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_usages(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_usages::RequestBuilder {
list_usages::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Get all Virtual Networks associated with an App Service plan."]
#[doc = "Description for Get all Virtual Networks associated with an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_vnets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_vnets::RequestBuilder {
list_vnets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a Virtual Network associated with an App Service plan."]
#[doc = "Description for Get a Virtual Network associated with an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_from_server_farm(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_from_server_farm::RequestBuilder {
get_vnet_from_server_farm::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a Virtual Network gateway."]
#[doc = "Description for Get a Virtual Network gateway."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Only the 'primary' gateway is supported."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_gateway(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_gateway::RequestBuilder {
get_vnet_gateway::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Update a Virtual Network gateway."]
#[doc = "Description for Update a Virtual Network gateway."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Only the 'primary' gateway is supported."]
#[doc = "* `connection_envelope`: Definition of the gateway."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_gateway(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
connection_envelope: impl Into<models::VnetGateway>,
subscription_id: impl Into<String>,
) -> update_vnet_gateway::RequestBuilder {
update_vnet_gateway::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all routes that are associated with a Virtual Network in an App Service plan."]
#[doc = "Description for Get all routes that are associated with a Virtual Network in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_routes_for_vnet(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_routes_for_vnet::RequestBuilder {
list_routes_for_vnet::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a Virtual Network route in an App Service plan."]
#[doc = "Description for Get a Virtual Network route in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `route_name`: Name of the Virtual Network route."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_route_for_vnet(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
route_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_route_for_vnet::RequestBuilder {
get_route_for_vnet::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
route_name: route_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a Virtual Network route in an App Service plan."]
#[doc = "Description for Create or update a Virtual Network route in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `route_name`: Name of the Virtual Network route."]
#[doc = "* `route`: Definition of the Virtual Network route."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_vnet_route(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
route_name: impl Into<String>,
route: impl Into<models::VnetRoute>,
subscription_id: impl Into<String>,
) -> create_or_update_vnet_route::RequestBuilder {
create_or_update_vnet_route::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
route_name: route_name.into(),
route: route.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a Virtual Network route in an App Service plan."]
#[doc = "Description for Create or update a Virtual Network route in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `route_name`: Name of the Virtual Network route."]
#[doc = "* `route`: Definition of the Virtual Network route."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_route(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
route_name: impl Into<String>,
route: impl Into<models::VnetRoute>,
subscription_id: impl Into<String>,
) -> update_vnet_route::RequestBuilder {
update_vnet_route::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
route_name: route_name.into(),
route: route.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a Virtual Network route in an App Service plan."]
#[doc = "Description for Delete a Virtual Network route in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `route_name`: Name of the Virtual Network route."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_vnet_route(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
route_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_vnet_route::RequestBuilder {
delete_vnet_route::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
route_name: route_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reboot a worker machine in an App Service plan."]
#[doc = "Description for Reboot a worker machine in an App Service plan."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the App Service plan."]
#[doc = "* `worker_name`: Name of worker machine, which typically starts with RD."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reboot_worker(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
worker_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> reboot_worker::RequestBuilder {
reboot_worker::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
worker_name: worker_name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlanCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlanCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) detailed: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to return all App Service plan properties. The default is <code>false</code>, which returns a subset of the properties.\n Retrieval of all properties may increase the API latency."]
pub fn detailed(mut self, detailed: bool) -> Self {
self.detailed = Some(detailed);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::AppServicePlanCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/serverfarms",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(detailed) = &this.detailed {
req.url_mut().query_pairs_mut().append_pair("detailed", &detailed.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlanCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlanCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::AppServicePlanCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlan> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlan = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServicePlan>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlan> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlan = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_service_plan: models::AppServicePlan,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_service_plan)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServicePlan>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AppServicePlan> {
let bytes = self.0.into_body().collect().await?;
let body: models::AppServicePlan = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_service_plan: models::AppServicePlanPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_service_plan)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AppServicePlan>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_capabilities {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::Capability>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::Capability> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/capabilities",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::Capability>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_hybrid_connection_keys {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnectionKey> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnectionKey = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionNamespaces/{}/relays/{}/listKeys" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnectionKey>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_web_apps_by_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionNamespaces/{}/relays/{}/sites" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_hybrid_connection_plan_limit {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnectionLimits> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnectionLimits = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionPlanLimits/limit",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnectionLimits>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_hybrid_connections {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnectionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnectionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::HybridConnectionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/hybridConnectionRelays",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod restart_web_apps {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) soft_restart: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to perform a soft restart, applies the configuration settings and restarts the apps if necessary. The default is <code>false</code>, which always restarts and reprovisions the apps"]
pub fn soft_restart(mut self, soft_restart: bool) -> Self {
self.soft_restart = Some(soft_restart);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/restartSites",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(soft_restart) = &this.soft_restart {
req.url_mut()
.query_pairs_mut()
.append_pair("softRestart", &soft_restart.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_web_apps {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) skip_token: Option<String>,
pub(crate) filter: Option<String>,
pub(crate) top: Option<String>,
}
impl RequestBuilder {
#[doc = "Skip to a web app in the list of webapps associated with app service plan. If specified, the resulting list will contain web apps starting from (including) the skipToken. Otherwise, the resulting list contains web apps from the start of the list"]
pub fn skip_token(mut self, skip_token: impl Into<String>) -> Self {
self.skip_token = Some(skip_token.into());
self
}
#[doc = "Supported filter: $filter=state eq running. Returns only web apps that are currently running"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
#[doc = "List page size. If specified, results are paged."]
pub fn top(mut self, top: impl Into<String>) -> Self {
self.top = Some(top.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/sites",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(skip_token) = &this.skip_token {
req.url_mut().query_pairs_mut().append_pair("$skipToken", skip_token);
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", top);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_server_farm_skus {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/skus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_usages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmUsageQuotaCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmUsageQuotaCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only usages/metrics specified in the filter. Filter conforms to odata syntax. Example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2')."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CsmUsageQuotaCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/usages",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_vnets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::VnetInfoResource>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::VnetInfoResource> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::VnetInfoResource>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_vnet_from_server_farm {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_vnet_gateway {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_gateway {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) connection_envelope: models::VnetGateway,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_routes_for_vnet {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::VnetRoute>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::VnetRoute> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/routes" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::VnetRoute>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_route_for_vnet {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::VnetRoute>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::VnetRoute> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) route_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/routes/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . route_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::VnetRoute>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_vnet_route {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetRoute> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetRoute = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) route_name: String,
pub(crate) route: models::VnetRoute,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/routes/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . route_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.route)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetRoute>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_route {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetRoute> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetRoute = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) route_name: String,
pub(crate) route: models::VnetRoute,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/routes/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . route_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.route)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetRoute>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_vnet_route {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) route_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/virtualNetworkConnections/{}/routes/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . route_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod reboot_worker {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) worker_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/serverfarms/{}/workers/{}/reboot",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.worker_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod certificates {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all certificates for a subscription."]
#[doc = "Description for Get all certificates for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Get all certificates in a resource group."]
#[doc = "Description for Get all certificates in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a certificate."]
#[doc = "Description for Get a certificate."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a certificate."]
#[doc = "Description for Create or update a certificate."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `certificate_envelope`: Details of certificate, if it exists already."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
certificate_envelope: impl Into<models::Certificate>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
certificate_envelope: certificate_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a certificate."]
#[doc = "Description for Create or update a certificate."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `certificate_envelope`: Details of certificate, if it exists already."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
certificate_envelope: impl Into<models::CertificatePatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
certificate_envelope: certificate_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a certificate."]
#[doc = "Description for Delete a certificate."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the certificate."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CertificateCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CertificateCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only information specified in the filter (using OData syntax). For example: $filter=KeyVaultId eq 'KeyVaultId'"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CertificateCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/certificates",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CertificateCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CertificateCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CertificateCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/certificates",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Certificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::Certificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/certificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Certificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Certificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::Certificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) certificate_envelope: models::Certificate,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/certificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.certificate_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Certificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Certificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::Certificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) certificate_envelope: models::CertificatePatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/certificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.certificate_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Certificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/certificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod container_apps {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get the Container Apps in a given subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_subscription(&self, subscription_id: impl Into<String>) -> list_by_subscription::RequestBuilder {
list_by_subscription::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the Container Apps in a given resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the properties of a Container App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Container App."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create or update a Container App."]
#[doc = "Description for Create or update a Container App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Container App."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
container_app_envelope: impl Into<models::ContainerApp>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
container_app_envelope: container_app_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a Container App."]
#[doc = "Description for Delete a Container App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Container App."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List secrets for a container app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `name`: Name of the Container App."]
pub fn list_secrets(&self, subscription_id: impl Into<String>, name: impl Into<String>) -> list_secrets::RequestBuilder {
list_secrets::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
name: name.into(),
}
}
}
pub mod list_by_subscription {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContainerAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContainerAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ContainerAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/containerApps",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContainerAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContainerAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ContainerAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContainerApp> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContainerApp = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ContainerApp>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContainerApp> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContainerApp = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) container_app_envelope: models::ContainerApp,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.container_app_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ContainerApp>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SecretsCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SecretsCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/containerApps/{}/listSecrets",
this.client.endpoint(),
&this.subscription_id,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SecretsCollection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod container_apps_revisions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get the Revisions for a given Container App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `container_app_name`: Name of the Container App for which Revisions are needed."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_revisions(
&self,
resource_group_name: impl Into<String>,
container_app_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_revisions::RequestBuilder {
list_revisions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
container_app_name: container_app_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a revision of a Container App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `container_app_name`: Name of the Container App."]
#[doc = "* `name`: Name of the Container App Revision."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_revision(
&self,
resource_group_name: impl Into<String>,
container_app_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_revision::RequestBuilder {
get_revision::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
container_app_name: container_app_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Activates a revision for a Container App"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `container_app_name`: Name of the Container App."]
#[doc = "* `name`: Name of the Container App Revision to activate"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn activate_revision(
&self,
resource_group_name: impl Into<String>,
container_app_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> activate_revision::RequestBuilder {
activate_revision::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
container_app_name: container_app_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deactivates a revision for a Container App"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `container_app_name`: Name of the Container App."]
#[doc = "* `name`: Name of the Container App Revision to deactivate"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn deactivate_revision(
&self,
resource_group_name: impl Into<String>,
container_app_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> deactivate_revision::RequestBuilder {
deactivate_revision::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
container_app_name: container_app_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restarts a revision for a Container App"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `container_app_name`: Name of the Container App."]
#[doc = "* `name`: Name of the Container App Revision to restart"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restart_revision(
&self,
resource_group_name: impl Into<String>,
container_app_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> restart_revision::RequestBuilder {
restart_revision::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
container_app_name: container_app_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list_revisions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RevisionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RevisionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) container_app_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::RevisionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}/revisions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.container_app_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_revision {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Revision> {
let bytes = self.0.into_body().collect().await?;
let body: models::Revision = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) container_app_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}/revisions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.container_app_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Revision>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod activate_revision {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) container_app_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}/revisions/{}/activate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.container_app_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod deactivate_revision {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) container_app_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}/revisions/{}/deactivate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.container_app_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restart_revision {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) container_app_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/containerApps/{}/revisions/{}/restart",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.container_app_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod deleted_web_apps {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all deleted apps for a subscription."]
#[doc = "Description for Get all deleted apps for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all deleted apps for a subscription at location"]
#[doc = "Description for Get all deleted apps for a subscription at location"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_location(
&self,
location: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_location::RequestBuilder {
list_by_location::RequestBuilder {
client: self.0.clone(),
location: location.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get deleted app for a subscription at location."]
#[doc = "Description for Get deleted app for a subscription at location."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `deleted_site_id`: The numeric ID of the deleted app, e.g. 12345"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_deleted_web_app_by_location(
&self,
location: impl Into<String>,
deleted_site_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_deleted_web_app_by_location::RequestBuilder {
get_deleted_web_app_by_location::RequestBuilder {
client: self.0.clone(),
location: location.into(),
deleted_site_id: deleted_site_id.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeletedWebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeletedWebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DeletedWebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/deletedSites",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_location {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeletedWebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeletedWebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DeletedWebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/locations/{}/deletedSites",
this.client.endpoint(),
&this.subscription_id,
&this.location
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_deleted_web_app_by_location {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeletedSite> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeletedSite = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) deleted_site_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/locations/{}/deletedSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.location,
&this.deleted_site_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DeletedSite>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod diagnostics {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List Hosting Environment Detector Responses"]
#[doc = "Description for List Hosting Environment Detector Responses"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_hosting_environment_detector_responses(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_hosting_environment_detector_responses::RequestBuilder {
list_hosting_environment_detector_responses::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Hosting Environment Detector Response"]
#[doc = "Description for Get Hosting Environment Detector Response"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: App Service Environment Name"]
#[doc = "* `detector_name`: Detector Resource Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_hosting_environment_detector_response(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
detector_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_hosting_environment_detector_response::RequestBuilder {
get_hosting_environment_detector_response::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
detector_name: detector_name.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "List Site Detector Responses"]
#[doc = "Description for List Site Detector Responses"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_detector_responses(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_detector_responses::RequestBuilder {
list_site_detector_responses::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get site detector response"]
#[doc = "Description for Get site detector response"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `detector_name`: Detector Resource Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_detector_response(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
detector_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_detector_response::RequestBuilder {
get_site_detector_response::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
detector_name: detector_name.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "Get Diagnostics Categories"]
#[doc = "Description for Get Diagnostics Categories"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_diagnostic_categories(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_diagnostic_categories::RequestBuilder {
list_site_diagnostic_categories::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Diagnostics Category"]
#[doc = "Description for Get Diagnostics Category"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_diagnostic_category(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_diagnostic_category::RequestBuilder {
get_site_diagnostic_category::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Site Analyses"]
#[doc = "Description for Get Site Analyses"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_analyses(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_analyses::RequestBuilder {
list_site_analyses::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Site Analysis"]
#[doc = "Description for Get Site Analysis"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `analysis_name`: Analysis Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_analysis(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
analysis_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_analysis::RequestBuilder {
get_site_analysis::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
analysis_name: analysis_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Execute Analysis"]
#[doc = "Description for Execute Analysis"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Category Name"]
#[doc = "* `analysis_name`: Analysis Resource Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn execute_site_analysis(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
analysis_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> execute_site_analysis::RequestBuilder {
execute_site_analysis::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
analysis_name: analysis_name.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "Get Detectors"]
#[doc = "Description for Get Detectors"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_detectors(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_detectors::RequestBuilder {
list_site_detectors::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Detector"]
#[doc = "Description for Get Detector"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `detector_name`: Detector Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_detector(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
detector_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_detector::RequestBuilder {
get_site_detector::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
detector_name: detector_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Execute Detector"]
#[doc = "Description for Execute Detector"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `detector_name`: Detector Resource Name"]
#[doc = "* `diagnostic_category`: Category Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn execute_site_detector(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
detector_name: impl Into<String>,
diagnostic_category: impl Into<String>,
subscription_id: impl Into<String>,
) -> execute_site_detector::RequestBuilder {
execute_site_detector::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
detector_name: detector_name.into(),
diagnostic_category: diagnostic_category.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "List Site Detector Responses"]
#[doc = "Description for List Site Detector Responses"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_detector_responses_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_detector_responses_slot::RequestBuilder {
list_site_detector_responses_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get site detector response"]
#[doc = "Description for Get site detector response"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `detector_name`: Detector Resource Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_detector_response_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
detector_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_detector_response_slot::RequestBuilder {
get_site_detector_response_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
detector_name: detector_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "Get Diagnostics Categories"]
#[doc = "Description for Get Diagnostics Categories"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_diagnostic_categories_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_diagnostic_categories_slot::RequestBuilder {
list_site_diagnostic_categories_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Diagnostics Category"]
#[doc = "Description for Get Diagnostics Category"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_diagnostic_category_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_diagnostic_category_slot::RequestBuilder {
get_site_diagnostic_category_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Site Analyses"]
#[doc = "Description for Get Site Analyses"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_analyses_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_analyses_slot::RequestBuilder {
list_site_analyses_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Site Analysis"]
#[doc = "Description for Get Site Analysis"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `analysis_name`: Analysis Name"]
#[doc = "* `slot`: Slot - optional"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_analysis_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
analysis_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_analysis_slot::RequestBuilder {
get_site_analysis_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
analysis_name: analysis_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Execute Analysis"]
#[doc = "Description for Execute Analysis"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Category Name"]
#[doc = "* `analysis_name`: Analysis Resource Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn execute_site_analysis_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
analysis_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> execute_site_analysis_slot::RequestBuilder {
execute_site_analysis_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
analysis_name: analysis_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
#[doc = "Get Detectors"]
#[doc = "Description for Get Detectors"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_detectors_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_detectors_slot::RequestBuilder {
list_site_detectors_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get Detector"]
#[doc = "Description for Get Detector"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `diagnostic_category`: Diagnostic Category"]
#[doc = "* `detector_name`: Detector Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_detector_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
diagnostic_category: impl Into<String>,
detector_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_detector_slot::RequestBuilder {
get_site_detector_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
diagnostic_category: diagnostic_category.into(),
detector_name: detector_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Execute Detector"]
#[doc = "Description for Execute Detector"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site Name"]
#[doc = "* `detector_name`: Detector Resource Name"]
#[doc = "* `diagnostic_category`: Category Name"]
#[doc = "* `slot`: Slot Name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn execute_site_detector_slot(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
detector_name: impl Into<String>,
diagnostic_category: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> execute_site_detector_slot::RequestBuilder {
execute_site_detector_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
detector_name: detector_name.into(),
diagnostic_category: diagnostic_category.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
start_time: None,
end_time: None,
time_grain: None,
}
}
}
pub mod list_hosting_environment_detector_responses {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponseCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponseCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DetectorResponseCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/detectors",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_hosting_environment_detector_response {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) detector_name: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/detectors/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_detector_responses {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponseCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponseCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DetectorResponseCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/detectors",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_detector_response {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) detector_name: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/detectors/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_diagnostic_categories {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticCategoryCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticCategoryCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticCategoryCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_diagnostic_category {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticCategory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_analyses {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticAnalysisCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticAnalysisCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticAnalysisCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/analyses",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_analysis {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AnalysisDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::AnalysisDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) analysis_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/analyses/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category,
&this.analysis_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AnalysisDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod execute_site_analysis {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticAnalysis> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticAnalysis = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) analysis_name: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/analyses/{}/execute",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category,
&this.analysis_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticAnalysis>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_detectors {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticDetectorCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticDetectorCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticDetectorCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/detectors",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_detector {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorDefinitionResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorDefinitionResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) detector_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/detectors/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorDefinitionResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod execute_site_detector {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticDetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticDetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) detector_name: String,
pub(crate) diagnostic_category: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/diagnostics/{}/detectors/{}/execute",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.diagnostic_category,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticDetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_detector_responses_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponseCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponseCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DetectorResponseCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/detectors",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_detector_response_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) detector_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/detectors/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_diagnostic_categories_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticCategoryCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticCategoryCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticCategoryCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_diagnostic_category_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticCategory> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticCategory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.diagnostic_category
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticCategory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_analyses_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticAnalysisCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticAnalysisCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticAnalysisCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/analyses",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.diagnostic_category
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_analysis_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AnalysisDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::AnalysisDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) analysis_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/analyses/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.diagnostic_category,
&this.analysis_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::AnalysisDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod execute_site_analysis_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticAnalysis> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticAnalysis = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) analysis_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/analyses/{}/execute" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . site_name , & this . slot , & this . diagnostic_category , & this . analysis_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticAnalysis>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_detectors_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticDetectorCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticDetectorCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DiagnosticDetectorCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/detectors",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.diagnostic_category
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_detector_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DetectorDefinitionResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::DetectorDefinitionResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) diagnostic_category: String,
pub(crate) detector_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/detectors/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.slot,
&this.diagnostic_category,
&this.detector_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DetectorDefinitionResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod execute_site_detector_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DiagnosticDetectorResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::DiagnosticDetectorResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) detector_name: String,
pub(crate) diagnostic_category: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) start_time: Option<time::OffsetDateTime>,
pub(crate) end_time: Option<time::OffsetDateTime>,
pub(crate) time_grain: Option<String>,
}
impl RequestBuilder {
#[doc = "Start Time"]
pub fn start_time(mut self, start_time: impl Into<time::OffsetDateTime>) -> Self {
self.start_time = Some(start_time.into());
self
}
#[doc = "End Time"]
pub fn end_time(mut self, end_time: impl Into<time::OffsetDateTime>) -> Self {
self.end_time = Some(end_time.into());
self
}
#[doc = "Time Grain"]
pub fn time_grain(mut self, time_grain: impl Into<String>) -> Self {
self.time_grain = Some(time_grain.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/diagnostics/{}/detectors/{}/execute" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . site_name , & this . slot , & this . diagnostic_category , & this . detector_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(start_time) = &this.start_time {
req.url_mut().query_pairs_mut().append_pair("startTime", &start_time.to_string());
}
if let Some(end_time) = &this.end_time {
req.url_mut().query_pairs_mut().append_pair("endTime", &end_time.to_string());
}
if let Some(time_grain) = &this.time_grain {
req.url_mut().query_pairs_mut().append_pair("timeGrain", time_grain);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DiagnosticDetectorResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod global {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get deleted app for a subscription."]
#[doc = "Description for Get deleted app for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `deleted_site_id`: The numeric ID of the deleted app, e.g. 12345"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_deleted_web_app(
&self,
deleted_site_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_deleted_web_app::RequestBuilder {
get_deleted_web_app::RequestBuilder {
client: self.0.clone(),
deleted_site_id: deleted_site_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all deleted apps for a subscription."]
#[doc = "Description for Get all deleted apps for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `deleted_site_id`: The numeric ID of the deleted app, e.g. 12345"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_deleted_web_app_snapshots(
&self,
deleted_site_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_deleted_web_app_snapshots::RequestBuilder {
get_deleted_web_app_snapshots::RequestBuilder {
client: self.0.clone(),
deleted_site_id: deleted_site_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets an operation in a subscription and given region"]
#[doc = "Description for Gets an operation in a subscription and given region"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `location`: Location name"]
#[doc = "* `operation_id`: Operation Id"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_subscription_operation_with_async_response(
&self,
location: impl Into<String>,
operation_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_subscription_operation_with_async_response::RequestBuilder {
get_subscription_operation_with_async_response::RequestBuilder {
client: self.0.clone(),
location: location.into(),
operation_id: operation_id.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod get_deleted_web_app {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeletedSite> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeletedSite = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) deleted_site_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/deletedSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.deleted_site_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DeletedSite>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_deleted_web_app_snapshots {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::Snapshot>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::Snapshot> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) deleted_site_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/deletedSites/{}/snapshots",
this.client.endpoint(),
&this.subscription_id,
&this.deleted_site_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::Snapshot>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_subscription_operation_with_async_response {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) operation_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/locations/{}/operations/{}",
this.client.endpoint(),
&this.subscription_id,
&this.location,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod kube_environments {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all Kubernetes Environments for a subscription."]
#[doc = "Description for Get all Kubernetes Environments for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_subscription(&self, subscription_id: impl Into<String>) -> list_by_subscription::RequestBuilder {
list_by_subscription::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all the Kubernetes Environments in a resource group."]
#[doc = "Description for Get all the Kubernetes Environments in a resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the properties of a Kubernetes Environment."]
#[doc = "Description for Get the properties of a Kubernetes Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Kubernetes Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a Kubernetes Environment."]
#[doc = "Description for Creates or updates a Kubernetes Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Kubernetes Environment."]
#[doc = "* `kube_environment_envelope`: Configuration details of the Kubernetes Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
kube_environment_envelope: impl Into<models::KubeEnvironment>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
kube_environment_envelope: kube_environment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates a Kubernetes Environment."]
#[doc = "Description for Creates or updates a Kubernetes Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Kubernetes Environment."]
#[doc = "* `kube_environment_envelope`: Configuration details of the Kubernetes Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
kube_environment_envelope: impl Into<models::KubeEnvironmentPatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
kube_environment_envelope: kube_environment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a Kubernetes Environment."]
#[doc = "Description for Delete a Kubernetes Environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the Kubernetes Environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list_by_subscription {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KubeEnvironmentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::KubeEnvironmentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::KubeEnvironmentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/kubeEnvironments",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KubeEnvironmentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::KubeEnvironmentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::KubeEnvironmentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/kubeEnvironments",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KubeEnvironment> {
let bytes = self.0.into_body().collect().await?;
let body: models::KubeEnvironment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/kubeEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KubeEnvironment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KubeEnvironment> {
let bytes = self.0.into_body().collect().await?;
let body: models::KubeEnvironment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) kube_environment_envelope: models::KubeEnvironment,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/kubeEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.kube_environment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KubeEnvironment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KubeEnvironment> {
let bytes = self.0.into_body().collect().await?;
let body: models::KubeEnvironment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) kube_environment_envelope: models::KubeEnvironmentPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/kubeEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.kube_environment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KubeEnvironment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/kubeEnvironments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod provider {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get available application frameworks and their versions"]
#[doc = "Description for Get available application frameworks and their versions"]
pub fn get_available_stacks(&self) -> get_available_stacks::RequestBuilder {
get_available_stacks::RequestBuilder {
client: self.0.clone(),
os_type_selected: None,
}
}
#[doc = "Get available Function app frameworks and their versions"]
#[doc = "Description for Get available Function app frameworks and their versions"]
pub fn get_function_app_stacks(&self) -> get_function_app_stacks::RequestBuilder {
get_function_app_stacks::RequestBuilder {
client: self.0.clone(),
stack_os_type: None,
}
}
#[doc = "Get available Function app frameworks and their versions for location"]
#[doc = "Description for Get available Function app frameworks and their versions for location"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `location`: Function App stack location."]
pub fn get_function_app_stacks_for_location(
&self,
location: impl Into<String>,
) -> get_function_app_stacks_for_location::RequestBuilder {
get_function_app_stacks_for_location::RequestBuilder {
client: self.0.clone(),
location: location.into(),
stack_os_type: None,
}
}
#[doc = "Get available Web app frameworks and their versions for location"]
#[doc = "Description for Get available Web app frameworks and their versions for location"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `location`: Web App stack location."]
pub fn get_web_app_stacks_for_location(&self, location: impl Into<String>) -> get_web_app_stacks_for_location::RequestBuilder {
get_web_app_stacks_for_location::RequestBuilder {
client: self.0.clone(),
location: location.into(),
stack_os_type: None,
}
}
#[doc = "Gets all available operations for the Microsoft.Web resource provider. Also exposes resource metric definitions"]
#[doc = "Description for Gets all available operations for the Microsoft.Web resource provider. Also exposes resource metric definitions"]
pub fn list_operations(&self) -> list_operations::RequestBuilder {
list_operations::RequestBuilder { client: self.0.clone() }
}
#[doc = "Get available Web app frameworks and their versions"]
#[doc = "Description for Get available Web app frameworks and their versions"]
pub fn get_web_app_stacks(&self) -> get_web_app_stacks::RequestBuilder {
get_web_app_stacks::RequestBuilder {
client: self.0.clone(),
stack_os_type: None,
}
}
#[doc = "Get available application frameworks and their versions"]
#[doc = "Description for Get available application frameworks and their versions"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_available_stacks_on_prem(&self, subscription_id: impl Into<String>) -> get_available_stacks_on_prem::RequestBuilder {
get_available_stacks_on_prem::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
os_type_selected: None,
}
}
}
pub mod get_available_stacks {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApplicationStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApplicationStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) os_type_selected: Option<String>,
}
impl RequestBuilder {
pub fn os_type_selected(mut self, os_type_selected: impl Into<String>) -> Self {
self.os_type_selected = Some(os_type_selected.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::ApplicationStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/availableStacks", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(os_type_selected) = &this.os_type_selected {
req.url_mut().query_pairs_mut().append_pair("osTypeSelected", os_type_selected);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_function_app_stacks {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionAppStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionAppStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) stack_os_type: Option<String>,
}
impl RequestBuilder {
#[doc = "Stack OS Type"]
pub fn stack_os_type(mut self, stack_os_type: impl Into<String>) -> Self {
self.stack_os_type = Some(stack_os_type.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::FunctionAppStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url =
azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/functionAppStacks", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(stack_os_type) = &this.stack_os_type {
req.url_mut().query_pairs_mut().append_pair("stackOsType", stack_os_type);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_function_app_stacks_for_location {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionAppStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionAppStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) stack_os_type: Option<String>,
}
impl RequestBuilder {
#[doc = "Stack OS Type"]
pub fn stack_os_type(mut self, stack_os_type: impl Into<String>) -> Self {
self.stack_os_type = Some(stack_os_type.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::FunctionAppStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Web/locations/{}/functionAppStacks",
this.client.endpoint(),
&this.location
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(stack_os_type) = &this.stack_os_type {
req.url_mut().query_pairs_mut().append_pair("stackOsType", stack_os_type);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_web_app_stacks_for_location {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) stack_os_type: Option<String>,
}
impl RequestBuilder {
#[doc = "Stack OS Type"]
pub fn stack_os_type(mut self, stack_os_type: impl Into<String>) -> Self {
self.stack_os_type = Some(stack_os_type.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Web/locations/{}/webAppStacks",
this.client.endpoint(),
&this.location
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(stack_os_type) = &this.stack_os_type {
req.url_mut().query_pairs_mut().append_pair("stackOsType", stack_os_type);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_operations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmOperationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmOperationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CsmOperationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/operations", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_web_app_stacks {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) stack_os_type: Option<String>,
}
impl RequestBuilder {
#[doc = "Stack OS Type"]
pub fn stack_os_type(mut self, stack_os_type: impl Into<String>) -> Self {
self.stack_os_type = Some(stack_os_type.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/webAppStacks", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(stack_os_type) = &this.stack_os_type {
req.url_mut().query_pairs_mut().append_pair("stackOsType", stack_os_type);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_available_stacks_on_prem {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApplicationStackCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApplicationStackCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) os_type_selected: Option<String>,
}
impl RequestBuilder {
pub fn os_type_selected(mut self, os_type_selected: impl Into<String>) -> Self {
self.os_type_selected = Some(os_type_selected.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::ApplicationStackCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/availableStacks",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(os_type_selected) = &this.os_type_selected {
req.url_mut().query_pairs_mut().append_pair("osTypeSelected", os_type_selected);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod recommendations {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List all recommendations for a subscription."]
#[doc = "Description for List all recommendations for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
featured: None,
filter: None,
}
}
#[doc = "Reset all recommendation opt-out settings for a subscription."]
#[doc = "Description for Reset all recommendation opt-out settings for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_all_filters(&self, subscription_id: impl Into<String>) -> reset_all_filters::RequestBuilder {
reset_all_filters::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Disables the specified rule so it will not apply to a subscription in the future."]
#[doc = "Description for Disables the specified rule so it will not apply to a subscription in the future."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name`: Rule name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn disable_recommendation_for_subscription(
&self,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> disable_recommendation_for_subscription::RequestBuilder {
disable_recommendation_for_subscription::RequestBuilder {
client: self.0.clone(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get past recommendations for an app, optionally specified by the time range."]
#[doc = "Description for Get past recommendations for an app, optionally specified by the time range."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `hosting_environment_name`: Name of the hosting environment."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_history_for_hosting_environment(
&self,
resource_group_name: impl Into<String>,
hosting_environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_history_for_hosting_environment::RequestBuilder {
list_history_for_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
hosting_environment_name: hosting_environment_name.into(),
subscription_id: subscription_id.into(),
expired_only: None,
filter: None,
}
}
#[doc = "Get all recommendations for a hosting environment."]
#[doc = "Description for Get all recommendations for a hosting environment."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `hosting_environment_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_recommended_rules_for_hosting_environment(
&self,
resource_group_name: impl Into<String>,
hosting_environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_recommended_rules_for_hosting_environment::RequestBuilder {
list_recommended_rules_for_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
hosting_environment_name: hosting_environment_name.into(),
subscription_id: subscription_id.into(),
featured: None,
filter: None,
}
}
#[doc = "Disable all recommendations for an app."]
#[doc = "Description for Disable all recommendations for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `environment_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn disable_all_for_hosting_environment(
&self,
resource_group_name: impl Into<String>,
environment_name: impl Into<String>,
hosting_environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> disable_all_for_hosting_environment::RequestBuilder {
disable_all_for_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
environment_name: environment_name.into(),
hosting_environment_name: hosting_environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reset all recommendation opt-out settings for an app."]
#[doc = "Description for Reset all recommendation opt-out settings for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `environment_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_all_filters_for_hosting_environment(
&self,
resource_group_name: impl Into<String>,
environment_name: impl Into<String>,
hosting_environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> reset_all_filters_for_hosting_environment::RequestBuilder {
reset_all_filters_for_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
environment_name: environment_name.into(),
hosting_environment_name: hosting_environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a recommendation rule for an app."]
#[doc = "Description for Get a recommendation rule for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `hosting_environment_name`: Name of the hosting environment."]
#[doc = "* `name`: Name of the recommendation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_rule_details_by_hosting_environment(
&self,
resource_group_name: impl Into<String>,
hosting_environment_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_rule_details_by_hosting_environment::RequestBuilder {
get_rule_details_by_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
hosting_environment_name: hosting_environment_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
update_seen: None,
recommendation_id: None,
}
}
#[doc = "Disables the specific rule for a web site permanently."]
#[doc = "Description for Disables the specific rule for a web site permanently."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `environment_name`: Site name"]
#[doc = "* `name`: Rule name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn disable_recommendation_for_hosting_environment(
&self,
resource_group_name: impl Into<String>,
environment_name: impl Into<String>,
name: impl Into<String>,
hosting_environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> disable_recommendation_for_hosting_environment::RequestBuilder {
disable_recommendation_for_hosting_environment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
environment_name: environment_name.into(),
name: name.into(),
hosting_environment_name: hosting_environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get past recommendations for an app, optionally specified by the time range."]
#[doc = "Description for Get past recommendations for an app, optionally specified by the time range."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_history_for_web_app(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_history_for_web_app::RequestBuilder {
list_history_for_web_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
expired_only: None,
filter: None,
}
}
#[doc = "Get all recommendations for an app."]
#[doc = "Description for Get all recommendations for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_recommended_rules_for_web_app(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_recommended_rules_for_web_app::RequestBuilder {
list_recommended_rules_for_web_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
featured: None,
filter: None,
}
}
#[doc = "Disable all recommendations for an app."]
#[doc = "Description for Disable all recommendations for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn disable_all_for_web_app(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> disable_all_for_web_app::RequestBuilder {
disable_all_for_web_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reset all recommendation opt-out settings for an app."]
#[doc = "Description for Reset all recommendation opt-out settings for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_all_filters_for_web_app(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> reset_all_filters_for_web_app::RequestBuilder {
reset_all_filters_for_web_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a recommendation rule for an app."]
#[doc = "Description for Get a recommendation rule for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Name of the app."]
#[doc = "* `name`: Name of the recommendation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_rule_details_by_web_app(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_rule_details_by_web_app::RequestBuilder {
get_rule_details_by_web_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
update_seen: None,
recommendation_id: None,
}
}
#[doc = "Disables the specific rule for a web site permanently."]
#[doc = "Description for Disables the specific rule for a web site permanently."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `site_name`: Site name"]
#[doc = "* `name`: Rule name"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn disable_recommendation_for_site(
&self,
resource_group_name: impl Into<String>,
site_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> disable_recommendation_for_site::RequestBuilder {
disable_recommendation_for_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
site_name: site_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) featured: Option<bool>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to return only the most critical recommendations. The default is <code>false</code>, which returns all recommendations."]
pub fn featured(mut self, featured: bool) -> Self {
self.featured = Some(featured);
self
}
#[doc = "Filter is specified by using OData syntax. Example: $filter=channel eq 'Api' or channel eq 'Notification' and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[PT1H|PT1M|P1D]"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::RecommendationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/recommendations",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(featured) = &this.featured {
req.url_mut().query_pairs_mut().append_pair("featured", &featured.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod reset_all_filters {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/recommendations/reset",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod disable_recommendation_for_subscription {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/recommendations/{}/disable",
this.client.endpoint(),
&this.subscription_id,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_history_for_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) hosting_environment_name: String,
pub(crate) subscription_id: String,
pub(crate) expired_only: Option<bool>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>false</code> to return all recommendations. The default is <code>true</code>, which returns only expired recommendations."]
pub fn expired_only(mut self, expired_only: bool) -> Self {
self.expired_only = Some(expired_only);
self
}
#[doc = "Filter is specified by using OData syntax. Example: $filter=channel eq 'Api' or channel eq 'Notification' and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[PT1H|PT1M|P1D]"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::RecommendationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendationHistory",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.hosting_environment_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(expired_only) = &this.expired_only {
req.url_mut()
.query_pairs_mut()
.append_pair("expiredOnly", &expired_only.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_recommended_rules_for_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) hosting_environment_name: String,
pub(crate) subscription_id: String,
pub(crate) featured: Option<bool>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to return only the most critical recommendations. The default is <code>false</code>, which returns all recommendations."]
pub fn featured(mut self, featured: bool) -> Self {
self.featured = Some(featured);
self
}
#[doc = "Return only channels specified in the filter. Filter is specified by using OData syntax. Example: $filter=channel eq 'Api' or channel eq 'Notification'"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::RecommendationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendations",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.hosting_environment_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(featured) = &this.featured {
req.url_mut().query_pairs_mut().append_pair("featured", &featured.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod disable_all_for_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) environment_name: String,
pub(crate) hosting_environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendations/disable",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.hosting_environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let environment_name = &this.environment_name;
req.url_mut().query_pairs_mut().append_pair("environmentName", environment_name);
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod reset_all_filters_for_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) environment_name: String,
pub(crate) hosting_environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendations/reset",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.hosting_environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let environment_name = &this.environment_name;
req.url_mut().query_pairs_mut().append_pair("environmentName", environment_name);
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_rule_details_by_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationRule> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationRule = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) hosting_environment_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) update_seen: Option<bool>,
pub(crate) recommendation_id: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to update the last-seen timestamp of the recommendation object."]
pub fn update_seen(mut self, update_seen: bool) -> Self {
self.update_seen = Some(update_seen);
self
}
#[doc = "The GUID of the recommendation object if you query an expired one. You don't need to specify it to query an active entry."]
pub fn recommendation_id(mut self, recommendation_id: impl Into<String>) -> Self {
self.recommendation_id = Some(recommendation_id.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendations/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.hosting_environment_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(update_seen) = &this.update_seen {
req.url_mut().query_pairs_mut().append_pair("updateSeen", &update_seen.to_string());
}
if let Some(recommendation_id) = &this.recommendation_id {
req.url_mut().query_pairs_mut().append_pair("recommendationId", recommendation_id);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RecommendationRule>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod disable_recommendation_for_hosting_environment {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) environment_name: String,
pub(crate) name: String,
pub(crate) hosting_environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/hostingEnvironments/{}/recommendations/{}/disable" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . hosting_environment_name , & this . name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let environment_name = &this.environment_name;
req.url_mut().query_pairs_mut().append_pair("environmentName", environment_name);
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_history_for_web_app {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
pub(crate) expired_only: Option<bool>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>false</code> to return all recommendations. The default is <code>true</code>, which returns only expired recommendations."]
pub fn expired_only(mut self, expired_only: bool) -> Self {
self.expired_only = Some(expired_only);
self
}
#[doc = "Filter is specified by using OData syntax. Example: $filter=channel eq 'Api' or channel eq 'Notification' and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[PT1H|PT1M|P1D]"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::RecommendationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendationHistory",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(expired_only) = &this.expired_only {
req.url_mut()
.query_pairs_mut()
.append_pair("expiredOnly", &expired_only.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_recommended_rules_for_web_app {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
pub(crate) featured: Option<bool>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to return only the most critical recommendations. The default is <code>false</code>, which returns all recommendations."]
pub fn featured(mut self, featured: bool) -> Self {
self.featured = Some(featured);
self
}
#[doc = "Return only channels specified in the filter. Filter is specified by using OData syntax. Example: $filter=channel eq 'Api' or channel eq 'Notification'"]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::RecommendationCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendations",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(featured) = &this.featured {
req.url_mut().query_pairs_mut().append_pair("featured", &featured.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod disable_all_for_web_app {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendations/disable",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod reset_all_filters_for_web_app {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendations/reset",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_rule_details_by_web_app {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RecommendationRule> {
let bytes = self.0.into_body().collect().await?;
let body: models::RecommendationRule = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) update_seen: Option<bool>,
pub(crate) recommendation_id: Option<String>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to update the last-seen timestamp of the recommendation object."]
pub fn update_seen(mut self, update_seen: bool) -> Self {
self.update_seen = Some(update_seen);
self
}
#[doc = "The GUID of the recommendation object if you query an expired one. You don't need to specify it to query an active entry."]
pub fn recommendation_id(mut self, recommendation_id: impl Into<String>) -> Self {
self.recommendation_id = Some(recommendation_id.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendations/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(update_seen) = &this.update_seen {
req.url_mut().query_pairs_mut().append_pair("updateSeen", &update_seen.to_string());
}
if let Some(recommendation_id) = &this.recommendation_id {
req.url_mut().query_pairs_mut().append_pair("recommendationId", recommendation_id);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RecommendationRule>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod disable_recommendation_for_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) site_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/recommendations/{}/disable",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.site_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod resource_health_metadata {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List all ResourceHealthMetadata for all sites in the subscription."]
#[doc = "Description for List all ResourceHealthMetadata for all sites in the subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all ResourceHealthMetadata for all sites in the resource group in the subscription."]
#[doc = "Description for List all ResourceHealthMetadata for all sites in the resource group in the subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the category of ResourceHealthMetadata to use for the given site as a collection"]
#[doc = "Description for Gets the category of ResourceHealthMetadata to use for the given site as a collection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_site::RequestBuilder {
list_by_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the category of ResourceHealthMetadata to use for the given site"]
#[doc = "Description for Gets the category of ResourceHealthMetadata to use for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_by_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_by_site::RequestBuilder {
get_by_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the category of ResourceHealthMetadata to use for the given site as a collection"]
#[doc = "Description for Gets the category of ResourceHealthMetadata to use for the given site as a collection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_site_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_site_slot::RequestBuilder {
list_by_site_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the category of ResourceHealthMetadata to use for the given site"]
#[doc = "Description for Gets the category of ResourceHealthMetadata to use for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app"]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_by_site_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_by_site_slot::RequestBuilder {
get_by_site_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadataCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadataCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceHealthMetadataCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/resourceHealthMetadata",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadataCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadataCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceHealthMetadataCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/resourceHealthMetadata",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadataCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadataCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceHealthMetadataCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/resourceHealthMetadata",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_by_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadata> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadata = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/resourceHealthMetadata/default",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ResourceHealthMetadata>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_by_site_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadataCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadataCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ResourceHealthMetadataCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/resourceHealthMetadata",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_by_site_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceHealthMetadata> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceHealthMetadata = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/resourceHealthMetadata/default" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ResourceHealthMetadata>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
impl Client {
#[doc = "Gets publishing user"]
#[doc = "Description for Gets publishing user"]
pub fn get_publishing_user(&self) -> get_publishing_user::RequestBuilder {
get_publishing_user::RequestBuilder { client: self.clone() }
}
#[doc = "Updates publishing user"]
#[doc = "Description for Updates publishing user"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `user_details`: Details of publishing user"]
pub fn update_publishing_user(&self, user_details: impl Into<models::User>) -> update_publishing_user::RequestBuilder {
update_publishing_user::RequestBuilder {
client: self.clone(),
user_details: user_details.into(),
}
}
#[doc = "Gets the source controls available for Azure websites."]
#[doc = "Description for Gets the source controls available for Azure websites."]
pub fn list_source_controls(&self) -> list_source_controls::RequestBuilder {
list_source_controls::RequestBuilder { client: self.clone() }
}
#[doc = "Gets source control token"]
#[doc = "Description for Gets source control token"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `source_control_type`: Type of source control"]
pub fn get_source_control(&self, source_control_type: impl Into<String>) -> get_source_control::RequestBuilder {
get_source_control::RequestBuilder {
client: self.clone(),
source_control_type: source_control_type.into(),
}
}
#[doc = "Updates source control token"]
#[doc = "Description for Updates source control token"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `source_control_type`: Type of source control"]
#[doc = "* `request_message`: Source control token information"]
pub fn update_source_control(
&self,
source_control_type: impl Into<String>,
request_message: impl Into<models::SourceControl>,
) -> update_source_control::RequestBuilder {
update_source_control::RequestBuilder {
client: self.clone(),
source_control_type: source_control_type.into(),
request_message: request_message.into(),
}
}
#[doc = "Gets a list of meters for a given location."]
#[doc = "Description for Gets a list of meters for a given location."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_billing_meters(&self, subscription_id: impl Into<String>) -> list_billing_meters::RequestBuilder {
list_billing_meters::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
billing_location: None,
os_type: None,
}
}
#[doc = "Check if a resource name is available."]
#[doc = "Description for Check if a resource name is available."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `request`: Name availability request."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn check_name_availability(
&self,
request: impl Into<models::ResourceNameAvailabilityRequest>,
subscription_id: impl Into<String>,
) -> check_name_availability::RequestBuilder {
check_name_availability::RequestBuilder {
client: self.clone(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get custom hostnames under this subscription"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_custom_host_name_sites(&self, subscription_id: impl Into<String>) -> list_custom_host_name_sites::RequestBuilder {
list_custom_host_name_sites::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
hostname: None,
}
}
#[doc = "Gets list of available geo regions plus ministamps"]
#[doc = "Description for Gets list of available geo regions plus ministamps"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_subscription_deployment_locations(
&self,
subscription_id: impl Into<String>,
) -> get_subscription_deployment_locations::RequestBuilder {
get_subscription_deployment_locations::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a list of available geographical regions."]
#[doc = "Description for Get a list of available geographical regions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_geo_regions(&self, subscription_id: impl Into<String>) -> list_geo_regions::RequestBuilder {
list_geo_regions::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
sku: None,
linux_workers_enabled: None,
xenon_workers_enabled: None,
linux_dynamic_workers_enabled: None,
}
}
#[doc = "List all apps that are assigned to a hostname."]
#[doc = "Description for List all apps that are assigned to a hostname."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `name_identifier`: Hostname information."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_identifiers_assigned_to_host_name(
&self,
name_identifier: impl Into<models::NameIdentifier>,
subscription_id: impl Into<String>,
) -> list_site_identifiers_assigned_to_host_name::RequestBuilder {
list_site_identifiers_assigned_to_host_name::RequestBuilder {
client: self.clone(),
name_identifier: name_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all premier add-on offers."]
#[doc = "Description for List all premier add-on offers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_premier_add_on_offers(&self, subscription_id: impl Into<String>) -> list_premier_add_on_offers::RequestBuilder {
list_premier_add_on_offers::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List all SKUs."]
#[doc = "Description for List all SKUs."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_skus(&self, subscription_id: impl Into<String>) -> list_skus::RequestBuilder {
list_skus::RequestBuilder {
client: self.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Verifies if this VNET is compatible with an App Service Environment by analyzing the Network Security Group rules."]
#[doc = "Description for Verifies if this VNET is compatible with an App Service Environment by analyzing the Network Security Group rules."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `parameters`: VNET information"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn verify_hosting_environment_vnet(
&self,
parameters: impl Into<models::VnetParameters>,
subscription_id: impl Into<String>,
) -> verify_hosting_environment_vnet::RequestBuilder {
verify_hosting_environment_vnet::RequestBuilder {
client: self.clone(),
parameters: parameters.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Move resources between resource groups."]
#[doc = "Description for Move resources between resource groups."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `move_resource_envelope`: Object that represents the resource to move."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn move_(
&self,
resource_group_name: impl Into<String>,
move_resource_envelope: impl Into<models::CsmMoveResourceEnvelope>,
subscription_id: impl Into<String>,
) -> move_::RequestBuilder {
move_::RequestBuilder {
client: self.clone(),
resource_group_name: resource_group_name.into(),
move_resource_envelope: move_resource_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validate if a resource can be created."]
#[doc = "Description for Validate if a resource can be created."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `validate_request`: Request with the resources to validate."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate(
&self,
resource_group_name: impl Into<String>,
validate_request: impl Into<models::ValidateRequest>,
subscription_id: impl Into<String>,
) -> validate::RequestBuilder {
validate::RequestBuilder {
client: self.clone(),
resource_group_name: resource_group_name.into(),
validate_request: validate_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validate whether a resource can be moved."]
#[doc = "Description for Validate whether a resource can be moved."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `move_resource_envelope`: Object that represents the resource to move."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate_move(
&self,
resource_group_name: impl Into<String>,
move_resource_envelope: impl Into<models::CsmMoveResourceEnvelope>,
subscription_id: impl Into<String>,
) -> validate_move::RequestBuilder {
validate_move::RequestBuilder {
client: self.clone(),
resource_group_name: resource_group_name.into(),
move_resource_envelope: move_resource_envelope.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod get_publishing_user {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::User> {
let bytes = self.0.into_body().collect().await?;
let body: models::User = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/publishingUsers/web", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::User>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_publishing_user {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::User> {
let bytes = self.0.into_body().collect().await?;
let body: models::User = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) user_details: models::User,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/publishingUsers/web", this.client.endpoint(),))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.user_details)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::User>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_source_controls {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SourceControlCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SourceControlCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SourceControlCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!("{}/providers/Microsoft.Web/sourcecontrols", this.client.endpoint(),))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_source_control {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) source_control_type: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Web/sourcecontrols/{}",
this.client.endpoint(),
&this.source_control_type
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_source_control {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) source_control_type: String,
pub(crate) request_message: models::SourceControl,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/providers/Microsoft.Web/sourcecontrols/{}",
this.client.endpoint(),
&this.source_control_type
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request_message)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_billing_meters {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BillingMeterCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::BillingMeterCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
pub(crate) billing_location: Option<String>,
pub(crate) os_type: Option<String>,
}
impl RequestBuilder {
#[doc = "Azure Location of billable resource"]
pub fn billing_location(mut self, billing_location: impl Into<String>) -> Self {
self.billing_location = Some(billing_location.into());
self
}
#[doc = "App Service OS type meters used for"]
pub fn os_type(mut self, os_type: impl Into<String>) -> Self {
self.os_type = Some(os_type.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::BillingMeterCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/billingMeters",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(billing_location) = &this.billing_location {
req.url_mut().query_pairs_mut().append_pair("billingLocation", billing_location);
}
if let Some(os_type) = &this.os_type {
req.url_mut().query_pairs_mut().append_pair("osType", os_type);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod check_name_availability {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ResourceNameAvailability> {
let bytes = self.0.into_body().collect().await?;
let body: models::ResourceNameAvailability = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) request: models::ResourceNameAvailabilityRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/checknameavailability",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ResourceNameAvailability>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_custom_host_name_sites {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomHostnameSitesCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomHostnameSitesCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
pub(crate) hostname: Option<String>,
}
impl RequestBuilder {
#[doc = "Specific hostname"]
pub fn hostname(mut self, hostname: impl Into<String>) -> Self {
self.hostname = Some(hostname.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CustomHostnameSitesCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/customhostnameSites",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(hostname) = &this.hostname {
req.url_mut().query_pairs_mut().append_pair("hostname", hostname);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_subscription_deployment_locations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeploymentLocations> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeploymentLocations = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/deploymentLocations",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::DeploymentLocations>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_geo_regions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::GeoRegionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::GeoRegionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
pub(crate) sku: Option<String>,
pub(crate) linux_workers_enabled: Option<bool>,
pub(crate) xenon_workers_enabled: Option<bool>,
pub(crate) linux_dynamic_workers_enabled: Option<bool>,
}
impl RequestBuilder {
#[doc = "Name of SKU used to filter the regions."]
pub fn sku(mut self, sku: impl Into<String>) -> Self {
self.sku = Some(sku.into());
self
}
#[doc = "Specify <code>true</code> if you want to filter to only regions that support Linux workers."]
pub fn linux_workers_enabled(mut self, linux_workers_enabled: bool) -> Self {
self.linux_workers_enabled = Some(linux_workers_enabled);
self
}
#[doc = "Specify <code>true</code> if you want to filter to only regions that support Xenon workers."]
pub fn xenon_workers_enabled(mut self, xenon_workers_enabled: bool) -> Self {
self.xenon_workers_enabled = Some(xenon_workers_enabled);
self
}
#[doc = "Specify <code>true</code> if you want to filter to only regions that support Linux Consumption Workers."]
pub fn linux_dynamic_workers_enabled(mut self, linux_dynamic_workers_enabled: bool) -> Self {
self.linux_dynamic_workers_enabled = Some(linux_dynamic_workers_enabled);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::GeoRegionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/geoRegions",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(sku) = &this.sku {
req.url_mut().query_pairs_mut().append_pair("sku", sku);
}
if let Some(linux_workers_enabled) = &this.linux_workers_enabled {
req.url_mut()
.query_pairs_mut()
.append_pair("linuxWorkersEnabled", &linux_workers_enabled.to_string());
}
if let Some(xenon_workers_enabled) = &this.xenon_workers_enabled {
req.url_mut()
.query_pairs_mut()
.append_pair("xenonWorkersEnabled", &xenon_workers_enabled.to_string());
}
if let Some(linux_dynamic_workers_enabled) = &this.linux_dynamic_workers_enabled {
req.url_mut()
.query_pairs_mut()
.append_pair("linuxDynamicWorkersEnabled", &linux_dynamic_workers_enabled.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_site_identifiers_assigned_to_host_name {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::IdentifierCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::IdentifierCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) name_identifier: models::NameIdentifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::IdentifierCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/listSitesAssignedToHostName",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.name_identifier)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_premier_add_on_offers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOnOfferCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOnOfferCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PremierAddOnOfferCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/premieraddonoffers",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_skus {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SkuInfos> {
let bytes = self.0.into_body().collect().await?;
let body: models::SkuInfos = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/skus",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SkuInfos>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod verify_hosting_environment_vnet {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetValidationFailureDetails> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetValidationFailureDetails = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) parameters: models::VnetParameters,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/verifyHostingEnvironmentVnet",
this.client.endpoint(),
&this.subscription_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.parameters)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetValidationFailureDetails>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod move_ {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) resource_group_name: String,
pub(crate) move_resource_envelope: models::CsmMoveResourceEnvelope,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/moveResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.move_resource_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod validate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ValidateResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::ValidateResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) resource_group_name: String,
pub(crate) validate_request: models::ValidateRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/validate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.validate_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ValidateResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod validate_move {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::Client,
pub(crate) resource_group_name: String,
pub(crate) move_resource_envelope: models::CsmMoveResourceEnvelope,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/validateMoveResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.move_resource_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod static_sites {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Generates a preview workflow file for the static site"]
#[doc = "Description for Generates a preview workflow file for the static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `location`: Location where you plan to create the static site."]
#[doc = "* `static_sites_workflow_preview_request`: A JSON representation of the StaticSitesWorkflowPreviewRequest properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn preview_workflow(
&self,
location: impl Into<String>,
static_sites_workflow_preview_request: impl Into<models::StaticSitesWorkflowPreviewRequest>,
subscription_id: impl Into<String>,
) -> preview_workflow::RequestBuilder {
preview_workflow::RequestBuilder {
client: self.0.clone(),
location: location.into(),
static_sites_workflow_preview_request: static_sites_workflow_preview_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get all Static Sites for a subscription."]
#[doc = "Description for Get all Static Sites for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all static sites in the specified resource group."]
#[doc = "Description for Gets all static sites in the specified resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_static_sites_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_static_sites_by_resource_group::RequestBuilder {
get_static_sites_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of a static site."]
#[doc = "Description for Gets the details of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_static_site::RequestBuilder {
get_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new static site in an existing resource group, or updates an existing static site."]
#[doc = "Description for Creates a new static site in an existing resource group, or updates an existing static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site to create or update."]
#[doc = "* `static_site_envelope`: A JSON representation of the staticsite properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
static_site_envelope: impl Into<models::StaticSiteArmResource>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site::RequestBuilder {
create_or_update_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
static_site_envelope: static_site_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new static site in an existing resource group, or updates an existing static site."]
#[doc = "Description for Creates a new static site in an existing resource group, or updates an existing static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site to create or update."]
#[doc = "* `static_site_envelope`: A JSON representation of the staticsite properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
static_site_envelope: impl Into<models::StaticSitePatchResource>,
subscription_id: impl Into<String>,
) -> update_static_site::RequestBuilder {
update_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
static_site_envelope: static_site_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a static site."]
#[doc = "Description for Deletes a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site to delete."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_static_site::RequestBuilder {
delete_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the list of users of a static site."]
#[doc = "Description for Gets the list of users of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `authprovider`: The auth provider for the users."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_users(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
authprovider: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_users::RequestBuilder {
list_static_site_users::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
authprovider: authprovider.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates a user entry with the listed roles"]
#[doc = "Description for Updates a user entry with the listed roles"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `authprovider`: The auth provider for this user."]
#[doc = "* `userid`: The user id of the user."]
#[doc = "* `static_site_user_envelope`: A JSON representation of the StaticSiteUser properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_static_site_user(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
authprovider: impl Into<String>,
userid: impl Into<String>,
static_site_user_envelope: impl Into<models::StaticSiteUserArmResource>,
subscription_id: impl Into<String>,
) -> update_static_site_user::RequestBuilder {
update_static_site_user::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
authprovider: authprovider.into(),
userid: userid.into(),
static_site_user_envelope: static_site_user_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes the user entry from the static site."]
#[doc = "Description for Deletes the user entry from the static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the staticsite."]
#[doc = "* `authprovider`: The auth provider for this user."]
#[doc = "* `userid`: The user id of the user."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_static_site_user(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
authprovider: impl Into<String>,
userid: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_static_site_user::RequestBuilder {
delete_static_site_user::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
authprovider: authprovider.into(),
userid: userid.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all static site builds for a particular static site."]
#[doc = "Description for Gets all static site builds for a particular static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_static_site_builds(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_static_site_builds::RequestBuilder {
get_static_site_builds::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of a static site build."]
#[doc = "Description for Gets the details of a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_static_site_build::RequestBuilder {
get_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a static site build."]
#[doc = "Description for Deletes a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_static_site_build::RequestBuilder {
delete_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates the app settings of a static site build."]
#[doc = "Description for Creates or updates the app settings of a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `app_settings`: The dictionary containing the static site app settings to update."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site_build_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site_build_app_settings::RequestBuilder {
create_or_update_static_site_build_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
app_settings: app_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates the function app settings of a static site build."]
#[doc = "Description for Creates or updates the function app settings of a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `app_settings`: The dictionary containing the static site function app settings to update."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site_build_function_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site_build_function_app_settings::RequestBuilder {
create_or_update_static_site_build_function_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
app_settings: app_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the functions of a particular static site build."]
#[doc = "Description for Gets the functions of a particular static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_build_functions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_build_functions::RequestBuilder {
list_static_site_build_functions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of a static site build."]
#[doc = "Description for Gets the application settings of a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_build_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_build_app_settings::RequestBuilder {
list_static_site_build_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of a static site build."]
#[doc = "Description for Gets the application settings of a static site build."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_build_function_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_build_function_app_settings::RequestBuilder {
list_static_site_build_function_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of the user provided function apps registered with a static site build"]
#[doc = "Description for Gets the details of the user provided function apps registered with a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_user_provided_function_apps_for_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_user_provided_function_apps_for_static_site_build::RequestBuilder {
get_user_provided_function_apps_for_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of the user provided function app registered with a static site build"]
#[doc = "Description for Gets the details of the user provided function app registered with a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `function_app_name`: Name of the function app registered with the static site build."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_user_provided_function_app_for_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
function_app_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_user_provided_function_app_for_static_site_build::RequestBuilder {
get_user_provided_function_app_for_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
function_app_name: function_app_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Register a user provided function app with a static site build"]
#[doc = "Description for Register a user provided function app with a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `function_app_name`: Name of the function app to register with the static site build."]
#[doc = "* `static_site_user_provided_function_envelope`: A JSON representation of the user provided function app properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn register_user_provided_function_app_with_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
function_app_name: impl Into<String>,
static_site_user_provided_function_envelope: impl Into<models::StaticSiteUserProvidedFunctionAppArmResource>,
subscription_id: impl Into<String>,
) -> register_user_provided_function_app_with_static_site_build::RequestBuilder {
register_user_provided_function_app_with_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
function_app_name: function_app_name.into(),
static_site_user_provided_function_envelope: static_site_user_provided_function_envelope.into(),
subscription_id: subscription_id.into(),
is_forced: None,
}
}
#[doc = "Detach the user provided function app from the static site build"]
#[doc = "Description for Detach the user provided function app from the static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: The stage site identifier."]
#[doc = "* `function_app_name`: Name of the function app registered with the static site build."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn detach_user_provided_function_app_from_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
function_app_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> detach_user_provided_function_app_from_static_site_build::RequestBuilder {
detach_user_provided_function_app_from_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
function_app_name: function_app_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deploys zipped content to a specific environment of a static site."]
#[doc = "Description for Deploys zipped content to a specific environment of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `environment_name`: Name of the environment."]
#[doc = "* `static_site_zip_deployment_envelope`: A JSON representation of the StaticSiteZipDeployment properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_zip_deployment_for_static_site_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
static_site_zip_deployment_envelope: impl Into<models::StaticSiteZipDeploymentArmResource>,
subscription_id: impl Into<String>,
) -> create_zip_deployment_for_static_site_build::RequestBuilder {
create_zip_deployment_for_static_site_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
static_site_zip_deployment_envelope: static_site_zip_deployment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates the app settings of a static site."]
#[doc = "Description for Creates or updates the app settings of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `app_settings`: The dictionary containing the static site app settings to update."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site_app_settings::RequestBuilder {
create_or_update_static_site_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_settings: app_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates or updates the function app settings of a static site."]
#[doc = "Description for Creates or updates the function app settings of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `app_settings`: The dictionary containing the static site function app settings to update."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site_function_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site_function_app_settings::RequestBuilder {
create_or_update_static_site_function_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_settings: app_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates an invitation link for a user with the role"]
#[doc = "Description for Creates an invitation link for a user with the role"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_user_roles_invitation_link(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
static_site_user_roles_invitation_envelope: impl Into<models::StaticSiteUserInvitationRequestResource>,
subscription_id: impl Into<String>,
) -> create_user_roles_invitation_link::RequestBuilder {
create_user_roles_invitation_link::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
static_site_user_roles_invitation_envelope: static_site_user_roles_invitation_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all static site custom domains for a particular static site."]
#[doc = "Description for Gets all static site custom domains for a particular static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site resource to search in."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_custom_domains(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_custom_domains::RequestBuilder {
list_static_site_custom_domains::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets an existing custom domain for a particular static site."]
#[doc = "Description for Gets an existing custom domain for a particular static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site resource to search in."]
#[doc = "* `domain_name`: The custom domain name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_static_site_custom_domain(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_static_site_custom_domain::RequestBuilder {
get_static_site_custom_domain::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new static site custom domain in an existing resource group and static site."]
#[doc = "Description for Creates a new static site custom domain in an existing resource group and static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `domain_name`: The custom domain to create."]
#[doc = "* `static_site_custom_domain_request_properties_envelope`: A JSON representation of the static site custom domain request properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_static_site_custom_domain(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_name: impl Into<String>,
static_site_custom_domain_request_properties_envelope: impl Into<models::StaticSiteCustomDomainRequestPropertiesArmResource>,
subscription_id: impl Into<String>,
) -> create_or_update_static_site_custom_domain::RequestBuilder {
create_or_update_static_site_custom_domain::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_name: domain_name.into(),
static_site_custom_domain_request_properties_envelope: static_site_custom_domain_request_properties_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a custom domain."]
#[doc = "Description for Deletes a custom domain."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `domain_name`: The custom domain to delete."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_static_site_custom_domain(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_static_site_custom_domain::RequestBuilder {
delete_static_site_custom_domain::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_name: domain_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validates a particular custom domain can be added to a static site."]
#[doc = "Description for Validates a particular custom domain can be added to a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `domain_name`: The custom domain to validate."]
#[doc = "* `static_site_custom_domain_request_properties_envelope`: A JSON representation of the static site custom domain request properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate_custom_domain_can_be_added_to_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_name: impl Into<String>,
static_site_custom_domain_request_properties_envelope: impl Into<models::StaticSiteCustomDomainRequestPropertiesArmResource>,
subscription_id: impl Into<String>,
) -> validate_custom_domain_can_be_added_to_static_site::RequestBuilder {
validate_custom_domain_can_be_added_to_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_name: domain_name.into(),
static_site_custom_domain_request_properties_envelope: static_site_custom_domain_request_properties_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Detaches a static site."]
#[doc = "Description for Detaches a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site to detach."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn detach_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> detach_static_site::RequestBuilder {
detach_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the functions of a static site."]
#[doc = "Description for Gets the functions of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_functions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_functions::RequestBuilder {
list_static_site_functions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of a static site."]
#[doc = "Description for Gets the application settings of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_app_settings::RequestBuilder {
list_static_site_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Lists the roles configured for the static site."]
#[doc = "Description for Lists the roles configured for the static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_configured_roles(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_configured_roles::RequestBuilder {
list_static_site_configured_roles::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of a static site."]
#[doc = "Description for Gets the application settings of a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_function_app_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_function_app_settings::RequestBuilder {
list_static_site_function_app_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Lists the secrets for an existing static site."]
#[doc = "Description for Lists the secrets for an existing static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_static_site_secrets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_static_site_secrets::RequestBuilder {
list_static_site_secrets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the list of private endpoint connections associated with a static site"]
#[doc = "Description for Gets the list of private endpoint connections associated with a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection_list(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection_list::RequestBuilder {
get_private_endpoint_connection_list::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a private endpoint connection"]
#[doc = "Description for Gets a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection::RequestBuilder {
get_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Approves or rejects a private endpoint connection"]
#[doc = "Description for Approves or rejects a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `private_endpoint_wrapper`: Request body."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn approve_or_reject_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
private_endpoint_wrapper: impl Into<models::PrivateLinkConnectionApprovalRequestResource>,
subscription_id: impl Into<String>,
) -> approve_or_reject_private_endpoint_connection::RequestBuilder {
approve_or_reject_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
private_endpoint_wrapper: private_endpoint_wrapper.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a private endpoint connection"]
#[doc = "Description for Deletes a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_private_endpoint_connection::RequestBuilder {
delete_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the private link resources"]
#[doc = "Description for Gets the private link resources"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_link_resources(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_link_resources::RequestBuilder {
get_private_link_resources::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resets the api key for an existing static site."]
#[doc = "Description for Resets the api key for an existing static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_static_site_api_key(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
reset_properties_envelope: impl Into<models::StaticSiteResetPropertiesArmResource>,
subscription_id: impl Into<String>,
) -> reset_static_site_api_key::RequestBuilder {
reset_static_site_api_key::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
reset_properties_envelope: reset_properties_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of the user provided function apps registered with a static site"]
#[doc = "Description for Gets the details of the user provided function apps registered with a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_user_provided_function_apps_for_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_user_provided_function_apps_for_static_site::RequestBuilder {
get_user_provided_function_apps_for_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of the user provided function app registered with a static site"]
#[doc = "Description for Gets the details of the user provided function app registered with a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `function_app_name`: Name of the function app registered with the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_user_provided_function_app_for_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_app_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_user_provided_function_app_for_static_site::RequestBuilder {
get_user_provided_function_app_for_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_app_name: function_app_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Register a user provided function app with a static site"]
#[doc = "Description for Register a user provided function app with a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `function_app_name`: Name of the function app to register with the static site."]
#[doc = "* `static_site_user_provided_function_envelope`: A JSON representation of the user provided function app properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn register_user_provided_function_app_with_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_app_name: impl Into<String>,
static_site_user_provided_function_envelope: impl Into<models::StaticSiteUserProvidedFunctionAppArmResource>,
subscription_id: impl Into<String>,
) -> register_user_provided_function_app_with_static_site::RequestBuilder {
register_user_provided_function_app_with_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_app_name: function_app_name.into(),
static_site_user_provided_function_envelope: static_site_user_provided_function_envelope.into(),
subscription_id: subscription_id.into(),
is_forced: None,
}
}
#[doc = "Detach the user provided function app from the static site"]
#[doc = "Description for Detach the user provided function app from the static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `function_app_name`: Name of the function app registered with the static site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn detach_user_provided_function_app_from_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_app_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> detach_user_provided_function_app_from_static_site::RequestBuilder {
detach_user_provided_function_app_from_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_app_name: function_app_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deploys zipped content to a static site."]
#[doc = "Description for Deploys zipped content to a static site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site."]
#[doc = "* `static_site_zip_deployment_envelope`: A JSON representation of the StaticSiteZipDeployment properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_zip_deployment_for_static_site(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
static_site_zip_deployment_envelope: impl Into<models::StaticSiteZipDeploymentArmResource>,
subscription_id: impl Into<String>,
) -> create_zip_deployment_for_static_site::RequestBuilder {
create_zip_deployment_for_static_site::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
static_site_zip_deployment_envelope: static_site_zip_deployment_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validates that a backend can be linked to a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `linked_backend_name`: Name of the linked backend that should be retrieved"]
#[doc = "* `static_site_linked_backend_envelope`: A JSON representation of the linked backend request properties"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate_backend(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
linked_backend_name: impl Into<String>,
static_site_linked_backend_envelope: impl Into<models::StaticSiteLinkedBackendArmResource>,
subscription_id: impl Into<String>,
) -> validate_backend::RequestBuilder {
validate_backend::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
linked_backend_name: linked_backend_name.into(),
static_site_linked_backend_envelope: static_site_linked_backend_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Validates that a backend can be linked to a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `environment_name`: The stage site identifier"]
#[doc = "* `linked_backend_name`: Name of the linked backend that should be retrieved"]
#[doc = "* `static_site_linked_backend_envelope`: A JSON representation of the linked backend request properties"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn validate_backend_for_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
linked_backend_name: impl Into<String>,
static_site_linked_backend_envelope: impl Into<models::StaticSiteLinkedBackendArmResource>,
subscription_id: impl Into<String>,
) -> validate_backend_for_build::RequestBuilder {
validate_backend_for_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
linked_backend_name: linked_backend_name.into(),
static_site_linked_backend_envelope: static_site_linked_backend_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns details of all backends linked to a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_linked_backends(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_linked_backends::RequestBuilder {
get_linked_backends::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns details of all backends linked to a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `environment_name`: The stage site identifier"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_linked_backends_for_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_linked_backends_for_build::RequestBuilder {
get_linked_backends_for_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns the details of a linked backend linked to a static site by name"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `linked_backend_name`: Name of the linked backend that should be retrieved"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_linked_backend(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
linked_backend_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_linked_backend::RequestBuilder {
get_linked_backend::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
linked_backend_name: linked_backend_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Link backend to a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `linked_backend_name`: Name of the backend to link to the static site"]
#[doc = "* `static_site_linked_backend_envelope`: A JSON representation of the linked backend request properties"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn link_backend(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
linked_backend_name: impl Into<String>,
static_site_linked_backend_envelope: impl Into<models::StaticSiteLinkedBackendArmResource>,
subscription_id: impl Into<String>,
) -> link_backend::RequestBuilder {
link_backend::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
linked_backend_name: linked_backend_name.into(),
static_site_linked_backend_envelope: static_site_linked_backend_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Unlink a backend from a static site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `linked_backend_name`: Name of the backend linked to the static site"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn unlink_backend(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
linked_backend_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> unlink_backend::RequestBuilder {
unlink_backend::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
linked_backend_name: linked_backend_name.into(),
subscription_id: subscription_id.into(),
is_cleaning_auth_config: None,
}
}
#[doc = "Returns the details of a linked backend linked to a static site build by name"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `environment_name`: The stage site identifier"]
#[doc = "* `linked_backend_name`: Name of the linked backend that should be retrieved"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_linked_backend_for_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
linked_backend_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_linked_backend_for_build::RequestBuilder {
get_linked_backend_for_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
linked_backend_name: linked_backend_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Link backend to a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `environment_name`: The stage site identifier"]
#[doc = "* `linked_backend_name`: Name of the backend to link to the static site"]
#[doc = "* `static_site_linked_backend_envelope`: A JSON representation of the linked backend request properties"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn link_backend_to_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
linked_backend_name: impl Into<String>,
static_site_linked_backend_envelope: impl Into<models::StaticSiteLinkedBackendArmResource>,
subscription_id: impl Into<String>,
) -> link_backend_to_build::RequestBuilder {
link_backend_to_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
linked_backend_name: linked_backend_name.into(),
static_site_linked_backend_envelope: static_site_linked_backend_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Unlink a backend from a static site build"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the static site"]
#[doc = "* `environment_name`: The stage site identifier"]
#[doc = "* `linked_backend_name`: Name of the backend linked to the static site"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn unlink_backend_from_build(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
environment_name: impl Into<String>,
linked_backend_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> unlink_backend_from_build::RequestBuilder {
unlink_backend_from_build::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
environment_name: environment_name.into(),
linked_backend_name: linked_backend_name.into(),
subscription_id: subscription_id.into(),
is_cleaning_auth_config: None,
}
}
}
pub mod preview_workflow {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSitesWorkflowPreview> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSitesWorkflowPreview = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) location: String,
pub(crate) static_sites_workflow_preview_request: models::StaticSitesWorkflowPreviewRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/locations/{}/previewStaticSiteWorkflowFile",
this.client.endpoint(),
&this.subscription_id,
&this.location
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_sites_workflow_preview_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSitesWorkflowPreview>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/staticSites",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_static_sites_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) static_site_envelope: models::StaticSiteArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) static_site_envelope: models::StaticSitePatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_static_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_static_site_users {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) authprovider: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteUserCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/authproviders/{}/listUsers",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.authprovider
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod update_static_site_user {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) authprovider: String,
pub(crate) userid: String,
pub(crate) static_site_user_envelope: models::StaticSiteUserArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/authproviders/{}/users/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.authprovider,
&this.userid
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_user_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_static_site_user {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) authprovider: String,
pub(crate) userid: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/authproviders/{}/users/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.authprovider,
&this.userid
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_static_site_builds {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteBuildCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteBuildCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteBuildCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteBuildArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteBuildArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteBuildArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_static_site_build_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/config/appsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_static_site_build_function_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/config/functionappsettings" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_build_functions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteFunctionOverviewCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteFunctionOverviewCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteFunctionOverviewCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/functions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_static_site_build_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/listAppSettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_build_function_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/listFunctionAppSettings" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_user_provided_function_apps_for_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppsCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppsCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(
self,
) -> azure_core::Pageable<models::StaticSiteUserProvidedFunctionAppsCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/userProvidedFunctionApps" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_user_provided_function_app_for_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) function_app_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/userProvidedFunctionApps/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name , & this . function_app_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod register_user_provided_function_app_with_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) function_app_name: String,
pub(crate) static_site_user_provided_function_envelope: models::StaticSiteUserProvidedFunctionAppArmResource,
pub(crate) subscription_id: String,
pub(crate) is_forced: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to force the update of the auth configuration on the function app even if an AzureStaticWebApps provider is already configured on the function app. The default is <code>false</code>."]
pub fn is_forced(mut self, is_forced: bool) -> Self {
self.is_forced = Some(is_forced);
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/userProvidedFunctionApps/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name , & this . function_app_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_user_provided_function_envelope)?;
if let Some(is_forced) = &this.is_forced {
req.url_mut().query_pairs_mut().append_pair("isForced", &is_forced.to_string());
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod detach_user_provided_function_app_from_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) function_app_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/userProvidedFunctionApps/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name , & this . function_app_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_zip_deployment_for_static_site_build {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) static_site_zip_deployment_envelope: models::StaticSiteZipDeploymentArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/zipdeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_zip_deployment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_static_site_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/config/appsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_static_site_function_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/config/functionappsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_user_roles_invitation_link {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserInvitationResponseResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserInvitationResponseResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) static_site_user_roles_invitation_envelope: models::StaticSiteUserInvitationRequestResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/createUserInvitation",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_user_roles_invitation_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserInvitationResponseResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_custom_domains {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteCustomDomainOverviewCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteCustomDomainOverviewCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteCustomDomainOverviewCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/customDomains",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_static_site_custom_domain {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteCustomDomainOverviewArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteCustomDomainOverviewArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/customDomains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteCustomDomainOverviewArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_static_site_custom_domain {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteCustomDomainOverviewArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteCustomDomainOverviewArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_name: String,
pub(crate) static_site_custom_domain_request_properties_envelope: models::StaticSiteCustomDomainRequestPropertiesArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/customDomains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_custom_domain_request_properties_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteCustomDomainOverviewArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_static_site_custom_domain {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/customDomains/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod validate_custom_domain_can_be_added_to_static_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_name: String,
pub(crate) static_site_custom_domain_request_properties_envelope: models::StaticSiteCustomDomainRequestPropertiesArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/customDomains/{}/validate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_custom_domain_request_properties_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod detach_static_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/detach",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_static_site_functions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteFunctionOverviewCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteFunctionOverviewCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteFunctionOverviewCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/functions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_static_site_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/listAppSettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_configured_roles {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringList> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringList = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/listConfiguredRoles",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringList>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_function_app_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/listFunctionAppSettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_static_site_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/listSecrets",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_endpoint_connection_list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnectionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateEndpointConnectionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PrivateEndpointConnectionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/privateEndpointConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod approve_or_reject_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) private_endpoint_wrapper: models::PrivateLinkConnectionApprovalRequestResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.private_endpoint_wrapper)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_link_resources {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResourcesWrapper> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateLinkResourcesWrapper = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/privateLinkResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateLinkResourcesWrapper>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod reset_static_site_api_key {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) reset_properties_envelope: models::StaticSiteResetPropertiesArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/resetapikey",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.reset_properties_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_user_provided_function_apps_for_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppsCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppsCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(
self,
) -> azure_core::Pageable<models::StaticSiteUserProvidedFunctionAppsCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/userProvidedFunctionApps",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_user_provided_function_app_for_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_app_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/userProvidedFunctionApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_app_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod register_user_provided_function_app_with_static_site {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteUserProvidedFunctionAppArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_app_name: String,
pub(crate) static_site_user_provided_function_envelope: models::StaticSiteUserProvidedFunctionAppArmResource,
pub(crate) subscription_id: String,
pub(crate) is_forced: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <code>true</code> to force the update of the auth configuration on the function app even if an AzureStaticWebApps provider is already configured on the function app. The default is <code>false</code>."]
pub fn is_forced(mut self, is_forced: bool) -> Self {
self.is_forced = Some(is_forced);
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/userProvidedFunctionApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_app_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_user_provided_function_envelope)?;
if let Some(is_forced) = &this.is_forced {
req.url_mut().query_pairs_mut().append_pair("isForced", &is_forced.to_string());
}
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteUserProvidedFunctionAppArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod detach_user_provided_function_app_from_static_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_app_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/userProvidedFunctionApps/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_app_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_zip_deployment_for_static_site {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) static_site_zip_deployment_envelope: models::StaticSiteZipDeploymentArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/zipdeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_zip_deployment_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod validate_backend {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) linked_backend_name: String,
pub(crate) static_site_linked_backend_envelope: models::StaticSiteLinkedBackendArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/linkedBackends/{}/validate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_linked_backend_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod validate_backend_for_build {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) linked_backend_name: String,
pub(crate) static_site_linked_backend_envelope: models::StaticSiteLinkedBackendArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/linkedBackends/{}/validate" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . environment_name , & this . linked_backend_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_linked_backend_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_linked_backends {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendsCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendsCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteLinkedBackendsCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/linkedBackends",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_linked_backends_for_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendsCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendsCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::StaticSiteLinkedBackendsCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/linkedBackends",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_linked_backend {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) linked_backend_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteLinkedBackendArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod link_backend {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) linked_backend_name: String,
pub(crate) static_site_linked_backend_envelope: models::StaticSiteLinkedBackendArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_linked_backend_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteLinkedBackendArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod unlink_backend {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) linked_backend_name: String,
pub(crate) subscription_id: String,
pub(crate) is_cleaning_auth_config: Option<bool>,
}
impl RequestBuilder {
#[doc = "Decides if Easy Auth configuration will be removed from backend configuration"]
pub fn is_cleaning_auth_config(mut self, is_cleaning_auth_config: bool) -> Self {
self.is_cleaning_auth_config = Some(is_cleaning_auth_config);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(is_cleaning_auth_config) = &this.is_cleaning_auth_config {
req.url_mut()
.query_pairs_mut()
.append_pair("isCleaningAuthConfig", &is_cleaning_auth_config.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_linked_backend_for_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) linked_backend_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteLinkedBackendArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod link_backend_to_build {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StaticSiteLinkedBackendArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::StaticSiteLinkedBackendArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) linked_backend_name: String,
pub(crate) static_site_linked_backend_envelope: models::StaticSiteLinkedBackendArmResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.static_site_linked_backend_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::StaticSiteLinkedBackendArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod unlink_backend_from_build {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) environment_name: String,
pub(crate) linked_backend_name: String,
pub(crate) subscription_id: String,
pub(crate) is_cleaning_auth_config: Option<bool>,
}
impl RequestBuilder {
#[doc = "Decides if auth will be removed from backend configuration"]
pub fn is_cleaning_auth_config(mut self, is_cleaning_auth_config: bool) -> Self {
self.is_cleaning_auth_config = Some(is_cleaning_auth_config);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/staticSites/{}/builds/{}/linkedBackends/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.environment_name,
&this.linked_backend_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(is_cleaning_auth_config) = &this.is_cleaning_auth_config {
req.url_mut()
.query_pairs_mut()
.append_pair("isCleaningAuthConfig", &is_cleaning_auth_config.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod web_apps {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all apps for a subscription."]
#[doc = "Description for Get all apps for a subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list(&self, subscription_id: impl Into<String>) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all web, mobile, and API apps in the specified resource group."]
#[doc = "Description for Gets all web, mobile, and API apps in the specified resource group."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_by_resource_group(
&self,
resource_group_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_by_resource_group::RequestBuilder {
list_by_resource_group::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
subscription_id: subscription_id.into(),
include_slots: None,
}
}
#[doc = "Gets the details of a web, mobile, or API app."]
#[doc = "Description for Gets the details of a web, mobile, or API app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = "Description for Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Unique name of the app to create or update. To create or update a deployment slot, use the {slot} parameter."]
#[doc = "* `site_envelope`: A JSON representation of the app properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_envelope: impl Into<models::Site>,
subscription_id: impl Into<String>,
) -> create_or_update::RequestBuilder {
create_or_update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_envelope: site_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = "Description for Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Unique name of the app to create or update. To create or update a deployment slot, use the {slot} parameter."]
#[doc = "* `site_envelope`: A JSON representation of the app properties. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_envelope: impl Into<models::SitePatchResource>,
subscription_id: impl Into<String>,
) -> update::RequestBuilder {
update::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_envelope: site_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a web, mobile, or API app, or one of the deployment slots."]
#[doc = "Description for Deletes a web, mobile, or API app, or one of the deployment slots."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app to delete."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete::RequestBuilder {
delete::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
delete_metrics: None,
delete_empty_server_farm: None,
}
}
#[doc = "Analyze a custom hostname."]
#[doc = "Description for Analyze a custom hostname."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn analyze_custom_hostname(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> analyze_custom_hostname::RequestBuilder {
analyze_custom_hostname::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
host_name: None,
}
}
#[doc = "Applies the configuration settings from the target slot onto the current slot."]
#[doc = "Description for Applies the configuration settings from the target slot onto the current slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn apply_slot_config_to_production(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
subscription_id: impl Into<String>,
) -> apply_slot_config_to_production::RequestBuilder {
apply_slot_config_to_production::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a backup of an app."]
#[doc = "Description for Creates a backup of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Backup configuration. You can use the JSON response from the POST action as input here."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn backup(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::BackupRequest>,
subscription_id: impl Into<String>,
) -> backup::RequestBuilder {
backup::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets existing backups of an app."]
#[doc = "Description for Gets existing backups of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_backups(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_backups::RequestBuilder {
list_backups::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a backup of an app by its ID."]
#[doc = "Description for Gets a backup of an app by its ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_backup_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_backup_status::RequestBuilder {
get_backup_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a backup of an app by its ID."]
#[doc = "Description for Deletes a backup of an app by its ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_backup(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_backup::RequestBuilder {
delete_backup::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets status of a web app backup that may be in progress, including secrets associated with the backup, such as the Azure Storage SAS URL. Also can be used to update the SAS URL for the backup if a new URL is passed in the request body."]
#[doc = "Description for Gets status of a web app backup that may be in progress, including secrets associated with the backup, such as the Azure Storage SAS URL. Also can be used to update the SAS URL for the backup if a new URL is passed in the request body."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `backup_id`: ID of backup."]
#[doc = "* `request`: Information on backup request."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_backup_status_secrets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
request: impl Into<models::BackupRequest>,
subscription_id: impl Into<String>,
) -> list_backup_status_secrets::RequestBuilder {
list_backup_status_secrets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a specific backup to another app (or deployment slot, if specified)."]
#[doc = "Description for Restores a specific backup to another app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `request`: Information on restore request ."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
request: impl Into<models::RestoreRequest>,
subscription_id: impl Into<String>,
) -> restore::RequestBuilder {
restore::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether Scm basic auth is allowed and whether Ftp is allowed for a given site."]
#[doc = "Description for Returns whether Scm basic auth is allowed and whether Ftp is allowed for a given site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_basic_publishing_credentials_policies(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_basic_publishing_credentials_policies::RequestBuilder {
list_basic_publishing_credentials_policies::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether FTP is allowed on the site or not."]
#[doc = "Description for Returns whether FTP is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ftp_allowed(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ftp_allowed::RequestBuilder {
get_ftp_allowed::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates whether FTP is allowed on the site or not."]
#[doc = "Description for Updates whether FTP is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_ftp_allowed(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
csm_publishing_access_policies_entity: impl Into<models::CsmPublishingCredentialsPoliciesEntity>,
subscription_id: impl Into<String>,
) -> update_ftp_allowed::RequestBuilder {
update_ftp_allowed::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
csm_publishing_access_policies_entity: csm_publishing_access_policies_entity.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether Scm basic auth is allowed on the site or not."]
#[doc = "Description for Returns whether Scm basic auth is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_scm_allowed(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_scm_allowed::RequestBuilder {
get_scm_allowed::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates whether user publishing credentials are allowed on the site or not."]
#[doc = "Description for Updates whether user publishing credentials are allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_scm_allowed(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
csm_publishing_access_policies_entity: impl Into<models::CsmPublishingCredentialsPoliciesEntity>,
subscription_id: impl Into<String>,
) -> update_scm_allowed::RequestBuilder {
update_scm_allowed::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
csm_publishing_access_policies_entity: csm_publishing_access_policies_entity.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the configurations of an app"]
#[doc = "Description for List the configurations of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_configurations(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_configurations::RequestBuilder {
list_configurations::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the application settings of an app."]
#[doc = "Description for Replaces the application settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `app_settings`: Application settings of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_application_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> update_application_settings::RequestBuilder {
update_application_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_settings: app_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of an app."]
#[doc = "Description for Gets the application settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_application_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_application_settings::RequestBuilder {
list_application_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Authentication / Authorization settings associated with web app."]
#[doc = "Description for Updates the Authentication / Authorization settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `site_auth_settings`: Auth settings associated with web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_auth_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_auth_settings: impl Into<models::SiteAuthSettings>,
subscription_id: impl Into<String>,
) -> update_auth_settings::RequestBuilder {
update_auth_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_auth_settings: site_auth_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Authentication/Authorization settings of an app."]
#[doc = "Description for Gets the Authentication/Authorization settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings::RequestBuilder {
get_auth_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = "Description for Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings_v2_without_secrets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings_v2_without_secrets::RequestBuilder {
get_auth_settings_v2_without_secrets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = "Description for Updates site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `site_auth_settings_v2`: Auth settings associated with web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_auth_settings_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_auth_settings_v2: impl Into<models::SiteAuthSettingsV2>,
subscription_id: impl Into<String>,
) -> update_auth_settings_v2::RequestBuilder {
update_auth_settings_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_auth_settings_v2: site_auth_settings_v2.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = "Description for Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings_v2::RequestBuilder {
get_auth_settings_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Azure storage account configurations of an app."]
#[doc = "Description for Updates the Azure storage account configurations of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `azure_storage_accounts`: Azure storage accounts of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_azure_storage_accounts(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
azure_storage_accounts: impl Into<models::AzureStoragePropertyDictionaryResource>,
subscription_id: impl Into<String>,
) -> update_azure_storage_accounts::RequestBuilder {
update_azure_storage_accounts::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
azure_storage_accounts: azure_storage_accounts.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Azure storage account configurations of an app."]
#[doc = "Description for Gets the Azure storage account configurations of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_azure_storage_accounts(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_azure_storage_accounts::RequestBuilder {
list_azure_storage_accounts::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the backup configuration of an app."]
#[doc = "Description for Updates the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Edited backup configuration."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_backup_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::BackupRequest>,
subscription_id: impl Into<String>,
) -> update_backup_configuration::RequestBuilder {
update_backup_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes the backup configuration of an app."]
#[doc = "Description for Deletes the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_backup_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_backup_configuration::RequestBuilder {
delete_backup_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the backup configuration of an app."]
#[doc = "Description for Gets the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_backup_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_backup_configuration::RequestBuilder {
get_backup_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference app settings and status of an app"]
#[doc = "Description for Gets the config reference app settings and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_app_settings_key_vault_references(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_app_settings_key_vault_references::RequestBuilder {
get_app_settings_key_vault_references::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference and status of an app"]
#[doc = "Description for Gets the config reference and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `app_setting_key`: App Setting key name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_app_setting_key_vault_reference(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_setting_key: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_app_setting_key_vault_reference::RequestBuilder {
get_app_setting_key_vault_reference::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_setting_key: app_setting_key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference app settings and status of an app"]
#[doc = "Description for Gets the config reference app settings and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_connection_string_key_vault_references(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_connection_string_key_vault_references::RequestBuilder {
get_site_connection_string_key_vault_references::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference and status of an app"]
#[doc = "Description for Gets the config reference and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_connection_string_key_vault_reference(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_string_key: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_connection_string_key_vault_reference::RequestBuilder {
get_site_connection_string_key_vault_reference::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_string_key: connection_string_key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the connection strings of an app."]
#[doc = "Description for Replaces the connection strings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_strings`: Connection strings of the app or deployment slot. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_connection_strings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_strings: impl Into<models::ConnectionStringDictionary>,
subscription_id: impl Into<String>,
) -> update_connection_strings::RequestBuilder {
update_connection_strings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_strings: connection_strings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the connection strings of an app."]
#[doc = "Description for Gets the connection strings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_connection_strings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_connection_strings::RequestBuilder {
list_connection_strings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the logging configuration of an app."]
#[doc = "Description for Gets the logging configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_diagnostic_logs_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_diagnostic_logs_configuration::RequestBuilder {
get_diagnostic_logs_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the logging configuration of an app."]
#[doc = "Description for Updates the logging configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_logs_config`: A SiteLogsConfig JSON object that contains the logging configuration to change in the \"properties\" property."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_diagnostic_logs_config(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_logs_config: impl Into<models::SiteLogsConfig>,
subscription_id: impl Into<String>,
) -> update_diagnostic_logs_config::RequestBuilder {
update_diagnostic_logs_config::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_logs_config: site_logs_config.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the metadata of an app."]
#[doc = "Description for Replaces the metadata of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `metadata`: Edited metadata of the app or deployment slot. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_metadata(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
metadata: impl Into<models::StringDictionary>,
subscription_id: impl Into<String>,
) -> update_metadata::RequestBuilder {
update_metadata::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
metadata: metadata.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the metadata of an app."]
#[doc = "Description for Gets the metadata of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_metadata(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_metadata::RequestBuilder {
list_metadata::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Git/FTP publishing credentials of an app."]
#[doc = "Description for Gets the Git/FTP publishing credentials of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_publishing_credentials(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_publishing_credentials::RequestBuilder {
list_publishing_credentials::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Push settings associated with web app."]
#[doc = "Description for Updates the Push settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `push_settings`: Push settings associated with web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_site_push_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
push_settings: impl Into<models::PushSettings>,
subscription_id: impl Into<String>,
) -> update_site_push_settings::RequestBuilder {
update_site_push_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
push_settings: push_settings.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Push settings associated with web app."]
#[doc = "Description for Gets the Push settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_push_settings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_push_settings::RequestBuilder {
list_site_push_settings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the names of app settings and connection strings that stick to the slot (not swapped)."]
#[doc = "Description for Gets the names of app settings and connection strings that stick to the slot (not swapped)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_slot_configuration_names(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_slot_configuration_names::RequestBuilder {
list_slot_configuration_names::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the names of application settings and connection string that remain with the slot during swap operation."]
#[doc = "Description for Updates the names of application settings and connection string that remain with the slot during swap operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_config_names`: Names of application settings and connection strings. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_slot_configuration_names(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_config_names: impl Into<models::SlotConfigNamesResource>,
subscription_id: impl Into<String>,
) -> update_slot_configuration_names::RequestBuilder {
update_slot_configuration_names::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_config_names: slot_config_names.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the configuration of an app, such as platform version and bitness, default documents, virtual applications, Always On, etc."]
#[doc = "Description for Gets the configuration of an app, such as platform version and bitness, default documents, virtual applications, Always On, etc."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_configuration::RequestBuilder {
get_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the configuration of an app."]
#[doc = "Description for Updates the configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_config`: JSON representation of a SiteConfig object. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_config: impl Into<models::SiteConfigResource>,
subscription_id: impl Into<String>,
) -> create_or_update_configuration::RequestBuilder {
create_or_update_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_config: site_config.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the configuration of an app."]
#[doc = "Description for Updates the configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_config`: JSON representation of a SiteConfig object. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_configuration(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_config: impl Into<models::SiteConfigResource>,
subscription_id: impl Into<String>,
) -> update_configuration::RequestBuilder {
update_configuration::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_config: site_config.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a list of web app configuration snapshots identifiers. Each element of the list contains a timestamp and the ID of the snapshot."]
#[doc = "Description for Gets a list of web app configuration snapshots identifiers. Each element of the list contains a timestamp and the ID of the snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_configuration_snapshot_info(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_configuration_snapshot_info::RequestBuilder {
list_configuration_snapshot_info::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a snapshot of the configuration of an app at a previous point in time."]
#[doc = "Description for Gets a snapshot of the configuration of an app at a previous point in time."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `snapshot_id`: The ID of the snapshot to read."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_configuration_snapshot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
snapshot_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_configuration_snapshot::RequestBuilder {
get_configuration_snapshot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
snapshot_id: snapshot_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reverts the configuration of an app to a previous snapshot."]
#[doc = "Description for Reverts the configuration of an app to a previous snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `snapshot_id`: The ID of the snapshot to read."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn recover_site_configuration_snapshot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
snapshot_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> recover_site_configuration_snapshot::RequestBuilder {
recover_site_configuration_snapshot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
snapshot_id: snapshot_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the last lines of docker logs for the given site"]
#[doc = "Description for Gets the last lines of docker logs for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_web_site_container_logs(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_web_site_container_logs::RequestBuilder {
get_web_site_container_logs::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the ZIP archived docker log files for the given site"]
#[doc = "Description for Gets the ZIP archived docker log files for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_container_logs_zip(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_container_logs_zip::RequestBuilder {
get_container_logs_zip::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List continuous web jobs for an app, or a deployment slot."]
#[doc = "Description for List continuous web jobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_continuous_web_jobs(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_continuous_web_jobs::RequestBuilder {
list_continuous_web_jobs::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a continuous web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Gets a continuous web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_continuous_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_continuous_web_job::RequestBuilder {
get_continuous_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a continuous web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a continuous web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_continuous_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_continuous_web_job::RequestBuilder {
delete_continuous_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start a continuous web job for an app, or a deployment slot."]
#[doc = "Description for Start a continuous web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_continuous_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_continuous_web_job::RequestBuilder {
start_continuous_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Stop a continuous web job for an app, or a deployment slot."]
#[doc = "Description for Stop a continuous web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_continuous_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_continuous_web_job::RequestBuilder {
stop_continuous_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List deployment statuses for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_production_site_deployment_statuses(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_production_site_deployment_statuses::RequestBuilder {
list_production_site_deployment_statuses::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the deployment status for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `deployment_status_id`: GUID of the deployment operation."]
pub fn get_production_site_deployment_status(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
deployment_status_id: impl Into<String>,
) -> get_production_site_deployment_status::RequestBuilder {
get_production_site_deployment_status::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
deployment_status_id: deployment_status_id.into(),
}
}
#[doc = "List deployments for an app, or a deployment slot."]
#[doc = "Description for List deployments for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_deployments(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_deployments::RequestBuilder {
list_deployments::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a deployment by its ID for an app, or a deployment slot."]
#[doc = "Description for Get a deployment by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: Deployment ID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_deployment(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_deployment::RequestBuilder {
get_deployment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create a deployment for an app, or a deployment slot."]
#[doc = "Description for Create a deployment for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: ID of an existing deployment."]
#[doc = "* `deployment`: Deployment details."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_deployment(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
deployment: impl Into<models::Deployment>,
subscription_id: impl Into<String>,
) -> create_deployment::RequestBuilder {
create_deployment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
deployment: deployment.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a deployment by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a deployment by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: Deployment ID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_deployment(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_deployment::RequestBuilder {
delete_deployment::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List deployment log for specific deployment for an app, or a deployment slot."]
#[doc = "Description for List deployment log for specific deployment for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: The ID of a specific deployment. This is the value of the name property in the JSON response from \"GET /api/sites/{siteName}/deployments\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_deployment_log(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_deployment_log::RequestBuilder {
list_deployment_log::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Discovers an existing app backup that can be restored from a blob in Azure storage. Use this to get information about the databases stored in a backup."]
#[doc = "Description for Discovers an existing app backup that can be restored from a blob in Azure storage. Use this to get information about the databases stored in a backup."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: A RestoreRequest object that includes Azure storage URL and blog name for discovery of backup."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn discover_backup(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::RestoreRequest>,
subscription_id: impl Into<String>,
) -> discover_backup::RequestBuilder {
discover_backup::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Lists ownership identifiers for domain associated with web app."]
#[doc = "Description for Lists ownership identifiers for domain associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_domain_ownership_identifiers(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_domain_ownership_identifiers::RequestBuilder {
list_domain_ownership_identifiers::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get domain ownership identifier for web app."]
#[doc = "Description for Get domain ownership identifier for web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_domain_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_domain_ownership_identifier::RequestBuilder {
get_domain_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = "Description for Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_domain_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
domain_ownership_identifier: impl Into<models::Identifier>,
subscription_id: impl Into<String>,
) -> create_or_update_domain_ownership_identifier::RequestBuilder {
create_or_update_domain_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = "Description for Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_domain_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
domain_ownership_identifier: impl Into<models::Identifier>,
subscription_id: impl Into<String>,
) -> update_domain_ownership_identifier::RequestBuilder {
update_domain_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a domain ownership identifier for a web app."]
#[doc = "Description for Deletes a domain ownership identifier for a web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_domain_ownership_identifier(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_domain_ownership_identifier::RequestBuilder {
delete_domain_ownership_identifier::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the status of the last MSDeploy operation."]
#[doc = "Description for Get the status of the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ms_deploy_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ms_deploy_status::RequestBuilder {
get_ms_deploy_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke the MSDeploy web app extension."]
#[doc = "Description for Invoke the MSDeploy web app extension."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `ms_deploy`: Details of MSDeploy operation"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_ms_deploy_operation(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
ms_deploy: impl Into<models::MsDeploy>,
subscription_id: impl Into<String>,
) -> create_ms_deploy_operation::RequestBuilder {
create_ms_deploy_operation::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
ms_deploy: ms_deploy.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = "Description for Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ms_deploy_log(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ms_deploy_log::RequestBuilder {
get_ms_deploy_log::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke onedeploy status API /api/deployments and gets the deployment status for the site"]
#[doc = "Description for Invoke onedeploy status API /api/deployments and gets the deployment status for the site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_one_deploy_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_one_deploy_status::RequestBuilder {
get_one_deploy_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke the OneDeploy publish web app extension."]
#[doc = "Description for Invoke the OneDeploy publish web app extension."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_one_deploy_operation(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_one_deploy_operation::RequestBuilder {
create_one_deploy_operation::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the functions for a web site, or a deployment slot."]
#[doc = "Description for List the functions for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_functions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_functions::RequestBuilder {
list_functions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Fetch a short lived token that can be exchanged for a master key."]
#[doc = "Description for Fetch a short lived token that can be exchanged for a master key."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_functions_admin_token(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_functions_admin_token::RequestBuilder {
get_functions_admin_token::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function information by its ID for web site, or a deployment slot."]
#[doc = "Description for Get function information by its ID for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_function(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_function::RequestBuilder {
get_function::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create function for web site, or a deployment slot."]
#[doc = "Description for Create function for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `function_envelope`: Function details."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_function(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
function_envelope: impl Into<models::FunctionEnvelope>,
subscription_id: impl Into<String>,
) -> create_function::RequestBuilder {
create_function::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
function_envelope: function_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a function for web site, or a deployment slot."]
#[doc = "Description for Delete a function for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_function(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_function::RequestBuilder {
delete_function::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Add or update a function secret."]
#[doc = "Description for Add or update a function secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: The name of the function."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `key`: The key to create or update"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_function_secret(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
key_name: impl Into<String>,
key: impl Into<models::KeyInfo>,
subscription_id: impl Into<String>,
) -> create_or_update_function_secret::RequestBuilder {
create_or_update_function_secret::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
key_name: key_name.into(),
key: key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a function secret."]
#[doc = "Description for Delete a function secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: The name of the function."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_function_secret(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
key_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_function_secret::RequestBuilder {
delete_function_secret::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
key_name: key_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function keys for a function in a web site, or a deployment slot."]
#[doc = "Description for Get function keys for a function in a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_function_keys(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_function_keys::RequestBuilder {
list_function_keys::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function secrets for a function in a web site, or a deployment slot."]
#[doc = "Description for Get function secrets for a function in a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_function_secrets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_function_secrets::RequestBuilder {
list_function_secrets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get host secrets for a function app."]
#[doc = "Description for Get host secrets for a function app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_host_keys(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_host_keys::RequestBuilder {
list_host_keys::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "This is to allow calling via powershell and ARM template."]
#[doc = "Description for This is to allow calling via powershell and ARM template."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_sync_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_sync_status::RequestBuilder {
list_sync_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Syncs function trigger metadata to the management database"]
#[doc = "Description for Syncs function trigger metadata to the management database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_functions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_functions::RequestBuilder {
sync_functions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Add or update a host level secret."]
#[doc = "Description for Add or update a host level secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `key_type`: The type of host key."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `key`: The key to create or update"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_host_secret(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
key_type: impl Into<String>,
key_name: impl Into<String>,
key: impl Into<models::KeyInfo>,
subscription_id: impl Into<String>,
) -> create_or_update_host_secret::RequestBuilder {
create_or_update_host_secret::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
key_type: key_type.into(),
key_name: key_name.into(),
key: key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a host level secret."]
#[doc = "Description for Delete a host level secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `key_type`: The type of host key."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_host_secret(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
key_type: impl Into<String>,
key_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_host_secret::RequestBuilder {
delete_host_secret::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
key_type: key_type.into(),
key_name: key_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get hostname bindings for an app or a deployment slot."]
#[doc = "Description for Get hostname bindings for an app or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_host_name_bindings(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_host_name_bindings::RequestBuilder {
list_host_name_bindings::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the named hostname binding for an app (or deployment slot, if specified)."]
#[doc = "Description for Get the named hostname binding for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_host_name_binding(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
host_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_host_name_binding::RequestBuilder {
get_host_name_binding::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
host_name: host_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a hostname binding for an app."]
#[doc = "Description for Creates a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `host_name_binding`: Binding details. This is the JSON representation of a HostNameBinding object."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_host_name_binding(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
host_name: impl Into<String>,
host_name_binding: impl Into<models::HostNameBinding>,
subscription_id: impl Into<String>,
) -> create_or_update_host_name_binding::RequestBuilder {
create_or_update_host_name_binding::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
host_name: host_name.into(),
host_name_binding: host_name_binding.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a hostname binding for an app."]
#[doc = "Description for Deletes a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_host_name_binding(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
host_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_host_name_binding::RequestBuilder {
delete_host_name_binding::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
host_name: host_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieves a specific Service Bus Hybrid Connection used by this Web App."]
#[doc = "Description for Retrieves a specific Service Bus Hybrid Connection used by this Web App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_hybrid_connection::RequestBuilder {
get_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = "Description for Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `connection_envelope`: The details of the hybrid connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
connection_envelope: impl Into<models::HybridConnection>,
subscription_id: impl Into<String>,
) -> create_or_update_hybrid_connection::RequestBuilder {
create_or_update_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = "Description for Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `connection_envelope`: The details of the hybrid connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
connection_envelope: impl Into<models::HybridConnection>,
subscription_id: impl Into<String>,
) -> update_hybrid_connection::RequestBuilder {
update_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Removes a Hybrid Connection from this site."]
#[doc = "Description for Removes a Hybrid Connection from this site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_hybrid_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_hybrid_connection::RequestBuilder {
delete_hybrid_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieves all Service Bus Hybrid Connections used by this Web App."]
#[doc = "Description for Retrieves all Service Bus Hybrid Connections used by this Web App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_hybrid_connections(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_hybrid_connections::RequestBuilder {
list_hybrid_connections::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets hybrid connections configured for an app (or deployment slot, if specified)."]
#[doc = "Description for Gets hybrid connections configured for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_relay_service_connections(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_relay_service_connections::RequestBuilder {
list_relay_service_connections::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a hybrid connection configuration by its name."]
#[doc = "Description for Gets a hybrid connection configuration by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_relay_service_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_relay_service_connection::RequestBuilder {
get_relay_service_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = "Description for Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `connection_envelope`: Details of the hybrid connection configuration."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_relay_service_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
connection_envelope: impl Into<models::RelayServiceConnectionEntity>,
subscription_id: impl Into<String>,
) -> create_or_update_relay_service_connection::RequestBuilder {
create_or_update_relay_service_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = "Description for Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `connection_envelope`: Details of the hybrid connection configuration."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_relay_service_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
connection_envelope: impl Into<models::RelayServiceConnectionEntity>,
subscription_id: impl Into<String>,
) -> update_relay_service_connection::RequestBuilder {
update_relay_service_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a relay service connection by its name."]
#[doc = "Description for Deletes a relay service connection by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_relay_service_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_relay_service_connection::RequestBuilder {
delete_relay_service_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all scale-out instances of an app."]
#[doc = "Description for Gets all scale-out instances of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_identifiers(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_identifiers::RequestBuilder {
list_instance_identifiers::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all scale-out instances of an app."]
#[doc = "Description for Gets all scale-out instances of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_info(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_info::RequestBuilder {
get_instance_info::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the status of the last MSDeploy operation."]
#[doc = "Description for Get the status of the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_ms_deploy_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_ms_deploy_status::RequestBuilder {
get_instance_ms_deploy_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke the MSDeploy web app extension."]
#[doc = "Description for Invoke the MSDeploy web app extension."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `ms_deploy`: Details of MSDeploy operation"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_instance_ms_deploy_operation(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
ms_deploy: impl Into<models::MsDeploy>,
subscription_id: impl Into<String>,
) -> create_instance_ms_deploy_operation::RequestBuilder {
create_instance_ms_deploy_operation::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
ms_deploy: ms_deploy.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = "Description for Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_ms_deploy_log(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_ms_deploy_log::RequestBuilder {
get_instance_ms_deploy_log::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = "Description for Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_processes(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_processes::RequestBuilder {
list_instance_processes::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process::RequestBuilder {
get_instance_process::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = "Description for Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_instance_process(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_instance_process::RequestBuilder {
delete_instance_process::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process_dump(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process_dump::RequestBuilder {
get_instance_process_dump::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_process_modules(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_process_modules::RequestBuilder {
list_instance_process_modules::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `base_address`: Module base address."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process_module(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
base_address: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process_module::RequestBuilder {
get_instance_process_module::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
base_address: base_address.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_process_threads(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_process_threads::RequestBuilder {
list_instance_process_threads::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Shows whether an app can be cloned to another resource group or subscription."]
#[doc = "Description for Shows whether an app can be cloned to another resource group or subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn is_cloneable(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> is_cloneable::RequestBuilder {
is_cloneable::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets existing backups of an app."]
#[doc = "Description for Gets existing backups of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_backups(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_backups::RequestBuilder {
list_site_backups::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "This is to allow calling via powershell and ARM template."]
#[doc = "Description for This is to allow calling via powershell and ARM template."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_sync_function_triggers(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_sync_function_triggers::RequestBuilder {
list_sync_function_triggers::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a web app."]
#[doc = "Description for Restores a web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_name`: Azure subscription."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `migration_options`: Migration migrationOptions."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn migrate_storage(
&self,
subscription_name: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
migration_options: impl Into<models::StorageMigrationOptions>,
subscription_id: impl Into<String>,
) -> migrate_storage::RequestBuilder {
migrate_storage::RequestBuilder {
client: self.0.clone(),
subscription_name: subscription_name.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
migration_options: migration_options.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Migrates a local (in-app) MySql database to a remote MySql database."]
#[doc = "Description for Migrates a local (in-app) MySql database to a remote MySql database."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `migration_request_envelope`: MySql migration options."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn migrate_my_sql(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
migration_request_envelope: impl Into<models::MigrateMySqlRequest>,
subscription_id: impl Into<String>,
) -> migrate_my_sql::RequestBuilder {
migrate_my_sql::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
migration_request_envelope: migration_request_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns the status of MySql in app migration, if one is active, and whether or not MySql in app is enabled"]
#[doc = "Description for Returns the status of MySql in app migration, if one is active, and whether or not MySql in app is enabled"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_migrate_my_sql_status(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_migrate_my_sql_status::RequestBuilder {
get_migrate_my_sql_status::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a Swift Virtual Network connection."]
#[doc = "Description for Gets a Swift Virtual Network connection."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_swift_virtual_network_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_swift_virtual_network_connection::RequestBuilder {
get_swift_virtual_network_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\r\nin use by another App Service Plan other than the one this App is in."]
#[doc = "Description for Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\nin use by another App Service Plan other than the one this App is in."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_swift_virtual_network_connection_with_check(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_envelope: impl Into<models::SwiftVirtualNetwork>,
subscription_id: impl Into<String>,
) -> create_or_update_swift_virtual_network_connection_with_check::RequestBuilder {
create_or_update_swift_virtual_network_connection_with_check::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\r\nin use by another App Service Plan other than the one this App is in."]
#[doc = "Description for Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\nin use by another App Service Plan other than the one this App is in."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_swift_virtual_network_connection_with_check(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_envelope: impl Into<models::SwiftVirtualNetwork>,
subscription_id: impl Into<String>,
) -> update_swift_virtual_network_connection_with_check::RequestBuilder {
update_swift_virtual_network_connection_with_check::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a Swift Virtual Network connection from an app (or deployment slot)."]
#[doc = "Description for Deletes a Swift Virtual Network connection from an app (or deployment slot)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_swift_virtual_network(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_swift_virtual_network::RequestBuilder {
delete_swift_virtual_network::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all network features used by the app (or deployment slot, if specified)."]
#[doc = "Description for Gets all network features used by the app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `view`: The type of view. Only \"summary\" is supported at this time."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_network_features(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
view: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_network_features::RequestBuilder {
list_network_features::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
view: view.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_trace_operation(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_trace_operation::RequestBuilder {
get_network_trace_operation::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start capturing network packets for the site (To be deprecated)."]
#[doc = "Description for Start capturing network packets for the site (To be deprecated)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_web_site_network_trace(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_web_site_network_trace::RequestBuilder {
start_web_site_network_trace::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Start capturing network packets for the site."]
#[doc = "Description for Start capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_web_site_network_trace_operation(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_web_site_network_trace_operation::RequestBuilder {
start_web_site_network_trace_operation::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Stop ongoing capturing network packets for the site."]
#[doc = "Description for Stop ongoing capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_web_site_network_trace(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_web_site_network_trace::RequestBuilder {
stop_web_site_network_trace::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_traces(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_traces::RequestBuilder {
get_network_traces::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_trace_operation_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_trace_operation_v2::RequestBuilder {
get_network_trace_operation_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_traces_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_traces_v2::RequestBuilder {
get_network_traces_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Generates a new publishing password for an app (or deployment slot, if specified)."]
#[doc = "Description for Generates a new publishing password for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn generate_new_site_publishing_password(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> generate_new_site_publishing_password::RequestBuilder {
generate_new_site_publishing_password::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets perfmon counters for web app."]
#[doc = "Description for Gets perfmon counters for web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_perf_mon_counters(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_perf_mon_counters::RequestBuilder {
list_perf_mon_counters::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Gets web app's event logs."]
#[doc = "Description for Gets web app's event logs."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_php_error_log_flag(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_php_error_log_flag::RequestBuilder {
get_site_php_error_log_flag::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the premier add-ons of an app."]
#[doc = "Description for Gets the premier add-ons of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_premier_add_ons(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_premier_add_ons::RequestBuilder {
list_premier_add_ons::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named add-on of an app."]
#[doc = "Description for Gets a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_premier_add_on(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_premier_add_on::RequestBuilder {
get_premier_add_on::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates a named add-on of an app."]
#[doc = "Description for Updates a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `premier_add_on`: A JSON representation of the edited premier add-on."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn add_premier_add_on(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
premier_add_on: impl Into<models::PremierAddOn>,
subscription_id: impl Into<String>,
) -> add_premier_add_on::RequestBuilder {
add_premier_add_on::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
premier_add_on: premier_add_on.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates a named add-on of an app."]
#[doc = "Description for Updates a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `premier_add_on`: A JSON representation of the edited premier add-on."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_premier_add_on(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
premier_add_on: impl Into<models::PremierAddOnPatchResource>,
subscription_id: impl Into<String>,
) -> update_premier_add_on::RequestBuilder {
update_premier_add_on::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
premier_add_on: premier_add_on.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a premier add-on from an app."]
#[doc = "Description for Delete a premier add-on from an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_premier_add_on(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_premier_add_on::RequestBuilder {
delete_premier_add_on::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = "Description for Gets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_access(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_access::RequestBuilder {
get_private_access::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Sets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = "Description for Sets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `access`: The information for the private access"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn put_private_access_vnet(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
access: impl Into<models::PrivateAccess>,
subscription_id: impl Into<String>,
) -> put_private_access_vnet::RequestBuilder {
put_private_access_vnet::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
access: access.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the list of private endpoint connections associated with a site"]
#[doc = "Description for Gets the list of private endpoint connections associated with a site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection_list(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection_list::RequestBuilder {
get_private_endpoint_connection_list::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a private endpoint connection"]
#[doc = "Description for Gets a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection::RequestBuilder {
get_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Approves or rejects a private endpoint connection"]
#[doc = "Description for Approves or rejects a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn approve_or_reject_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
private_endpoint_wrapper: impl Into<models::PrivateLinkConnectionApprovalRequestResource>,
subscription_id: impl Into<String>,
) -> approve_or_reject_private_endpoint_connection::RequestBuilder {
approve_or_reject_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
private_endpoint_wrapper: private_endpoint_wrapper.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a private endpoint connection"]
#[doc = "Description for Deletes a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_private_endpoint_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_private_endpoint_connection::RequestBuilder {
delete_private_endpoint_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the private link resources"]
#[doc = "Description for Gets the private link resources"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_link_resources(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_link_resources::RequestBuilder {
get_private_link_resources::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = "Description for Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_processes(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_processes::RequestBuilder {
list_processes::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process::RequestBuilder {
get_process::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = "Description for Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_process(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_process::RequestBuilder {
delete_process::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process_dump(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process_dump::RequestBuilder {
get_process_dump::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_process_modules(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_process_modules::RequestBuilder {
list_process_modules::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `base_address`: Module base address."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process_module(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
base_address: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process_module::RequestBuilder {
get_process_module::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
base_address: base_address.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_process_threads(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_process_threads::RequestBuilder {
list_process_threads::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get public certificates for an app or a deployment slot."]
#[doc = "Description for Get public certificates for an app or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_public_certificates(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_public_certificates::RequestBuilder {
list_public_certificates::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the named public certificate for an app (or deployment slot, if specified)."]
#[doc = "Description for Get the named public certificate for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_public_certificate(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
public_certificate_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_public_certificate::RequestBuilder {
get_public_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
public_certificate_name: public_certificate_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a hostname binding for an app."]
#[doc = "Description for Creates a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `public_certificate`: Public certificate details. This is the JSON representation of a PublicCertificate object."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_public_certificate(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
public_certificate_name: impl Into<String>,
public_certificate: impl Into<models::PublicCertificate>,
subscription_id: impl Into<String>,
) -> create_or_update_public_certificate::RequestBuilder {
create_or_update_public_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
public_certificate_name: public_certificate_name.into(),
public_certificate: public_certificate.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a hostname binding for an app."]
#[doc = "Description for Deletes a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_public_certificate(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
public_certificate_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_public_certificate::RequestBuilder {
delete_public_certificate::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
public_certificate_name: public_certificate_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the publishing profile for an app (or deployment slot, if specified)."]
#[doc = "Description for Gets the publishing profile for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `publishing_profile_options`: Specifies publishingProfileOptions for publishing profile. For example, use {\"format\": \"FileZilla3\"} to get a FileZilla publishing profile."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_publishing_profile_xml_with_secrets(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
publishing_profile_options: impl Into<models::CsmPublishingProfileOptions>,
subscription_id: impl Into<String>,
) -> list_publishing_profile_xml_with_secrets::RequestBuilder {
list_publishing_profile_xml_with_secrets::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
publishing_profile_options: publishing_profile_options.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resets the configuration settings of the current slot if they were previously modified by calling the API with POST."]
#[doc = "Description for Resets the configuration settings of the current slot if they were previously modified by calling the API with POST."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_production_slot_config(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> reset_production_slot_config::RequestBuilder {
reset_production_slot_config::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restarts an app (or deployment slot, if specified)."]
#[doc = "Description for Restarts an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restart(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> restart::RequestBuilder {
restart::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
soft_restart: None,
synchronous: None,
}
}
#[doc = "Restores an app from a backup blob in Azure Storage."]
#[doc = "Description for Restores an app from a backup blob in Azure Storage."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Information on restore request ."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_from_backup_blob(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::RestoreRequest>,
subscription_id: impl Into<String>,
) -> restore_from_backup_blob::RequestBuilder {
restore_from_backup_blob::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a deleted web app to this web app."]
#[doc = "Description for Restores a deleted web app to this web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `restore_request`: Deleted web app restore information."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_from_deleted_app(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
restore_request: impl Into<models::DeletedAppRestoreRequest>,
subscription_id: impl Into<String>,
) -> restore_from_deleted_app::RequestBuilder {
restore_from_deleted_app::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
restore_request: restore_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a web app from a snapshot."]
#[doc = "Description for Restores a web app from a snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `restore_request`: Snapshot restore settings. Snapshot information can be obtained by calling GetDeletedSites or GetSiteSnapshots API."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_snapshot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
restore_request: impl Into<models::SnapshotRestoreRequest>,
subscription_id: impl Into<String>,
) -> restore_snapshot::RequestBuilder {
restore_snapshot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
restore_request: restore_request.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of siteextensions for a web site, or a deployment slot."]
#[doc = "Description for Get list of siteextensions for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_extensions(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_extensions::RequestBuilder {
list_site_extensions::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get site extension information by its ID for a web site, or a deployment slot."]
#[doc = "Description for Get site extension information by its ID for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_extension(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_extension::RequestBuilder {
get_site_extension::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Install site extension on a web site, or a deployment slot."]
#[doc = "Description for Install site extension on a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn install_site_extension(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> install_site_extension::RequestBuilder {
install_site_extension::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Remove a site extension from a web site, or a deployment slot."]
#[doc = "Description for Remove a site extension from a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_site_extension(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_site_extension::RequestBuilder {
delete_site_extension::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets an app's deployment slots."]
#[doc = "Description for Gets an app's deployment slots."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_slots(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_slots::RequestBuilder {
list_slots::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the details of a web, mobile, or API app."]
#[doc = "Description for Gets the details of a web, mobile, or API app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. By default, this API returns the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_slot::RequestBuilder {
get_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = "Description for Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Unique name of the app to create or update. To create or update a deployment slot, use the {slot} parameter."]
#[doc = "* `site_envelope`: A JSON representation of the app properties. See example."]
#[doc = "* `slot`: Name of the deployment slot to create or update. By default, this API attempts to create or modify the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_envelope: impl Into<models::Site>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_slot::RequestBuilder {
create_or_update_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_envelope: site_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = "Description for Creates a new web, mobile, or API app in an existing resource group, or updates an existing app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Unique name of the app to create or update. To create or update a deployment slot, use the {slot} parameter."]
#[doc = "* `site_envelope`: A JSON representation of the app properties. See example."]
#[doc = "* `slot`: Name of the deployment slot to create or update. By default, this API attempts to create or modify the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_envelope: impl Into<models::SitePatchResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_slot::RequestBuilder {
update_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_envelope: site_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a web, mobile, or API app, or one of the deployment slots."]
#[doc = "Description for Deletes a web, mobile, or API app, or one of the deployment slots."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app to delete."]
#[doc = "* `slot`: Name of the deployment slot to delete. By default, the API deletes the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_slot::RequestBuilder {
delete_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
delete_metrics: None,
delete_empty_server_farm: None,
}
}
#[doc = "Analyze a custom hostname."]
#[doc = "Description for Analyze a custom hostname."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn analyze_custom_hostname_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> analyze_custom_hostname_slot::RequestBuilder {
analyze_custom_hostname_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
host_name: None,
}
}
#[doc = "Applies the configuration settings from the target slot onto the current slot."]
#[doc = "Description for Applies the configuration settings from the target slot onto the current slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `slot`: Name of the source slot. If a slot is not specified, the production slot is used as the source slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn apply_slot_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> apply_slot_configuration_slot::RequestBuilder {
apply_slot_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a backup of an app."]
#[doc = "Description for Creates a backup of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Backup configuration. You can use the JSON response from the POST action as input here."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will create a backup for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn backup_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::BackupRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> backup_slot::RequestBuilder {
backup_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets existing backups of an app."]
#[doc = "Description for Gets existing backups of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get backups of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_backups_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_backups_slot::RequestBuilder {
list_backups_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a backup of an app by its ID."]
#[doc = "Description for Gets a backup of an app by its ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get a backup of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_backup_status_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_backup_status_slot::RequestBuilder {
get_backup_status_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a backup of an app by its ID."]
#[doc = "Description for Deletes a backup of an app by its ID."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete a backup of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_backup_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_backup_slot::RequestBuilder {
delete_backup_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets status of a web app backup that may be in progress, including secrets associated with the backup, such as the Azure Storage SAS URL. Also can be used to update the SAS URL for the backup if a new URL is passed in the request body."]
#[doc = "Description for Gets status of a web app backup that may be in progress, including secrets associated with the backup, such as the Azure Storage SAS URL. Also can be used to update the SAS URL for the backup if a new URL is passed in the request body."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `backup_id`: ID of backup."]
#[doc = "* `request`: Information on backup request."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_backup_status_secrets_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
request: impl Into<models::BackupRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_backup_status_secrets_slot::RequestBuilder {
list_backup_status_secrets_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a specific backup to another app (or deployment slot, if specified)."]
#[doc = "Description for Restores a specific backup to another app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `backup_id`: ID of the backup."]
#[doc = "* `request`: Information on restore request ."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will restore a backup of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
backup_id: impl Into<String>,
request: impl Into<models::RestoreRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> restore_slot::RequestBuilder {
restore_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
backup_id: backup_id.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether Scm basic auth is allowed and whether Ftp is allowed for a given site."]
#[doc = "Description for Returns whether Scm basic auth is allowed and whether Ftp is allowed for a given site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_basic_publishing_credentials_policies_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_basic_publishing_credentials_policies_slot::RequestBuilder {
list_basic_publishing_credentials_policies_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether FTP is allowed on the site or not."]
#[doc = "Description for Returns whether FTP is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ftp_allowed_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ftp_allowed_slot::RequestBuilder {
get_ftp_allowed_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates whether FTP is allowed on the site or not."]
#[doc = "Description for Updates whether FTP is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_ftp_allowed_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
csm_publishing_access_policies_entity: impl Into<models::CsmPublishingCredentialsPoliciesEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_ftp_allowed_slot::RequestBuilder {
update_ftp_allowed_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
csm_publishing_access_policies_entity: csm_publishing_access_policies_entity.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns whether Scm basic auth is allowed on the site or not."]
#[doc = "Description for Returns whether Scm basic auth is allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_scm_allowed_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_scm_allowed_slot::RequestBuilder {
get_scm_allowed_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates whether user publishing credentials are allowed on the site or not."]
#[doc = "Description for Updates whether user publishing credentials are allowed on the site or not."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_scm_allowed_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
csm_publishing_access_policies_entity: impl Into<models::CsmPublishingCredentialsPoliciesEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_scm_allowed_slot::RequestBuilder {
update_scm_allowed_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
csm_publishing_access_policies_entity: csm_publishing_access_policies_entity.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the configurations of an app"]
#[doc = "Description for List the configurations of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will return configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_configurations_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_configurations_slot::RequestBuilder {
list_configurations_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the application settings of an app."]
#[doc = "Description for Replaces the application settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `app_settings`: Application settings of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the application settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_application_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_settings: impl Into<models::StringDictionary>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_application_settings_slot::RequestBuilder {
update_application_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_settings: app_settings.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the application settings of an app."]
#[doc = "Description for Gets the application settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the application settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_application_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_application_settings_slot::RequestBuilder {
list_application_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Authentication / Authorization settings associated with web app."]
#[doc = "Description for Updates the Authentication / Authorization settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `site_auth_settings`: Auth settings associated with web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_auth_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_auth_settings: impl Into<models::SiteAuthSettings>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_auth_settings_slot::RequestBuilder {
update_auth_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_auth_settings: site_auth_settings.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Authentication/Authorization settings of an app."]
#[doc = "Description for Gets the Authentication/Authorization settings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings_slot::RequestBuilder {
get_auth_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings_v2_without_secrets_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings_v2_without_secrets_slot::RequestBuilder {
get_auth_settings_v2_without_secrets_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = "Description for Updates site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `site_auth_settings_v2`: Auth settings associated with web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_auth_settings_v2_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_auth_settings_v2: impl Into<models::SiteAuthSettingsV2>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_auth_settings_v2_slot::RequestBuilder {
update_auth_settings_v2_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_auth_settings_v2: site_auth_settings_v2.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = "Description for Gets site's Authentication / Authorization settings for apps via the V2 format"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_auth_settings_v2_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_auth_settings_v2_slot::RequestBuilder {
get_auth_settings_v2_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Azure storage account configurations of an app."]
#[doc = "Description for Updates the Azure storage account configurations of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `azure_storage_accounts`: Azure storage accounts of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the Azure storage account configurations for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_azure_storage_accounts_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
azure_storage_accounts: impl Into<models::AzureStoragePropertyDictionaryResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_azure_storage_accounts_slot::RequestBuilder {
update_azure_storage_accounts_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
azure_storage_accounts: azure_storage_accounts.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Azure storage account configurations of an app."]
#[doc = "Description for Gets the Azure storage account configurations of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the Azure storage account configurations for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_azure_storage_accounts_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_azure_storage_accounts_slot::RequestBuilder {
list_azure_storage_accounts_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the backup configuration of an app."]
#[doc = "Description for Updates the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Edited backup configuration."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the backup configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_backup_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::BackupRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_backup_configuration_slot::RequestBuilder {
update_backup_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes the backup configuration of an app."]
#[doc = "Description for Deletes the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the backup configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_backup_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_backup_configuration_slot::RequestBuilder {
delete_backup_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the backup configuration of an app."]
#[doc = "Description for Gets the backup configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the backup configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_backup_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_backup_configuration_slot::RequestBuilder {
get_backup_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference app settings and status of an app"]
#[doc = "Description for Gets the config reference app settings and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_app_settings_key_vault_references_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_app_settings_key_vault_references_slot::RequestBuilder {
get_app_settings_key_vault_references_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference and status of an app"]
#[doc = "Description for Gets the config reference and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `app_setting_key`: App Setting key name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_app_setting_key_vault_reference_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
app_setting_key: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_app_setting_key_vault_reference_slot::RequestBuilder {
get_app_setting_key_vault_reference_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
app_setting_key: app_setting_key.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference app settings and status of an app"]
#[doc = "Description for Gets the config reference app settings and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_connection_string_key_vault_references_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_connection_string_key_vault_references_slot::RequestBuilder {
get_site_connection_string_key_vault_references_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the config reference and status of an app"]
#[doc = "Description for Gets the config reference and status of an app"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_connection_string_key_vault_reference_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_string_key: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_connection_string_key_vault_reference_slot::RequestBuilder {
get_site_connection_string_key_vault_reference_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_string_key: connection_string_key.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the connection strings of an app."]
#[doc = "Description for Replaces the connection strings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_strings`: Connection strings of the app or deployment slot. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the connection settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_connection_strings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_strings: impl Into<models::ConnectionStringDictionary>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_connection_strings_slot::RequestBuilder {
update_connection_strings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_strings: connection_strings.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the connection strings of an app."]
#[doc = "Description for Gets the connection strings of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the connection settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_connection_strings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_connection_strings_slot::RequestBuilder {
list_connection_strings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the logging configuration of an app."]
#[doc = "Description for Gets the logging configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the logging configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_diagnostic_logs_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_diagnostic_logs_configuration_slot::RequestBuilder {
get_diagnostic_logs_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the logging configuration of an app."]
#[doc = "Description for Updates the logging configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_logs_config`: A SiteLogsConfig JSON object that contains the logging configuration to change in the \"properties\" property."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the logging configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_diagnostic_logs_config_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_logs_config: impl Into<models::SiteLogsConfig>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_diagnostic_logs_config_slot::RequestBuilder {
update_diagnostic_logs_config_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_logs_config: site_logs_config.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Replaces the metadata of an app."]
#[doc = "Description for Replaces the metadata of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `metadata`: Edited metadata of the app or deployment slot. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the metadata for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_metadata_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
metadata: impl Into<models::StringDictionary>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_metadata_slot::RequestBuilder {
update_metadata_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
metadata: metadata.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the metadata of an app."]
#[doc = "Description for Gets the metadata of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the metadata for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_metadata_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_metadata_slot::RequestBuilder {
list_metadata_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Git/FTP publishing credentials of an app."]
#[doc = "Description for Gets the Git/FTP publishing credentials of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the publishing credentials for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_publishing_credentials_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_publishing_credentials_slot::RequestBuilder {
list_publishing_credentials_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the Push settings associated with web app."]
#[doc = "Description for Updates the Push settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `push_settings`: Push settings associated with web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_site_push_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
push_settings: impl Into<models::PushSettings>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_site_push_settings_slot::RequestBuilder {
update_site_push_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
push_settings: push_settings.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the Push settings associated with web app."]
#[doc = "Description for Gets the Push settings associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_push_settings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_push_settings_slot::RequestBuilder {
list_site_push_settings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the configuration of an app, such as platform version and bitness, default documents, virtual applications, Always On, etc."]
#[doc = "Description for Gets the configuration of an app, such as platform version and bitness, default documents, virtual applications, Always On, etc."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will return configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_configuration_slot::RequestBuilder {
get_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the configuration of an app."]
#[doc = "Description for Updates the configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_config`: JSON representation of a SiteConfig object. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_config: impl Into<models::SiteConfigResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_configuration_slot::RequestBuilder {
create_or_update_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_config: site_config.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the configuration of an app."]
#[doc = "Description for Updates the configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_config`: JSON representation of a SiteConfig object. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_config: impl Into<models::SiteConfigResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_configuration_slot::RequestBuilder {
update_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_config: site_config.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a list of web app configuration snapshots identifiers. Each element of the list contains a timestamp and the ID of the snapshot."]
#[doc = "Description for Gets a list of web app configuration snapshots identifiers. Each element of the list contains a timestamp and the ID of the snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will return configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_configuration_snapshot_info_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_configuration_snapshot_info_slot::RequestBuilder {
list_configuration_snapshot_info_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a snapshot of the configuration of an app at a previous point in time."]
#[doc = "Description for Gets a snapshot of the configuration of an app at a previous point in time."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `snapshot_id`: The ID of the snapshot to read."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will return configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_configuration_snapshot_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
snapshot_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_configuration_snapshot_slot::RequestBuilder {
get_configuration_snapshot_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
snapshot_id: snapshot_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Reverts the configuration of an app to a previous snapshot."]
#[doc = "Description for Reverts the configuration of an app to a previous snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `snapshot_id`: The ID of the snapshot to read."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will return configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn recover_site_configuration_snapshot_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
snapshot_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> recover_site_configuration_snapshot_slot::RequestBuilder {
recover_site_configuration_snapshot_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
snapshot_id: snapshot_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the last lines of docker logs for the given site"]
#[doc = "Description for Gets the last lines of docker logs for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_web_site_container_logs_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_web_site_container_logs_slot::RequestBuilder {
get_web_site_container_logs_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the ZIP archived docker log files for the given site"]
#[doc = "Description for Gets the ZIP archived docker log files for the given site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_container_logs_zip_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_container_logs_zip_slot::RequestBuilder {
get_container_logs_zip_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List continuous web jobs for an app, or a deployment slot."]
#[doc = "Description for List continuous web jobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_continuous_web_jobs_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_continuous_web_jobs_slot::RequestBuilder {
list_continuous_web_jobs_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a continuous web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Gets a continuous web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_continuous_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_continuous_web_job_slot::RequestBuilder {
get_continuous_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a continuous web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a continuous web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_continuous_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_continuous_web_job_slot::RequestBuilder {
delete_continuous_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start a continuous web job for an app, or a deployment slot."]
#[doc = "Description for Start a continuous web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_continuous_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_continuous_web_job_slot::RequestBuilder {
start_continuous_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Stop a continuous web job for an app, or a deployment slot."]
#[doc = "Description for Stop a continuous web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_continuous_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_continuous_web_job_slot::RequestBuilder {
stop_continuous_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List deployment statuses for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the deployment status for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_slot_site_deployment_statuses_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_slot_site_deployment_statuses_slot::RequestBuilder {
list_slot_site_deployment_statuses_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the deployment status for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the deployment status for the production slot."]
#[doc = "* `deployment_status_id`: GUID of the deployment operation."]
pub fn get_slot_site_deployment_status_slot(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
deployment_status_id: impl Into<String>,
) -> get_slot_site_deployment_status_slot::RequestBuilder {
get_slot_site_deployment_status_slot::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
deployment_status_id: deployment_status_id.into(),
}
}
#[doc = "List deployments for an app, or a deployment slot."]
#[doc = "Description for List deployments for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_deployments_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_deployments_slot::RequestBuilder {
list_deployments_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a deployment by its ID for an app, or a deployment slot."]
#[doc = "Description for Get a deployment by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: Deployment ID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API gets a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_deployment_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_deployment_slot::RequestBuilder {
get_deployment_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create a deployment for an app, or a deployment slot."]
#[doc = "Description for Create a deployment for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: ID of an existing deployment."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API creates a deployment for the production slot."]
#[doc = "* `deployment`: Deployment details."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_deployment_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
slot: impl Into<String>,
deployment: impl Into<models::Deployment>,
subscription_id: impl Into<String>,
) -> create_deployment_slot::RequestBuilder {
create_deployment_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
slot: slot.into(),
deployment: deployment.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a deployment by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a deployment by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: Deployment ID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_deployment_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_deployment_slot::RequestBuilder {
delete_deployment_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List deployment log for specific deployment for an app, or a deployment slot."]
#[doc = "Description for List deployment log for specific deployment for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `id`: The ID of a specific deployment. This is the value of the name property in the JSON response from \"GET /api/sites/{siteName}/deployments\"."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_deployment_log_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_deployment_log_slot::RequestBuilder {
list_deployment_log_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
id: id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Discovers an existing app backup that can be restored from a blob in Azure storage. Use this to get information about the databases stored in a backup."]
#[doc = "Description for Discovers an existing app backup that can be restored from a blob in Azure storage. Use this to get information about the databases stored in a backup."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: A RestoreRequest object that includes Azure storage URL and blog name for discovery of backup."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will perform discovery for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn discover_backup_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::RestoreRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> discover_backup_slot::RequestBuilder {
discover_backup_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Lists ownership identifiers for domain associated with web app."]
#[doc = "Description for Lists ownership identifiers for domain associated with web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_domain_ownership_identifiers_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_domain_ownership_identifiers_slot::RequestBuilder {
list_domain_ownership_identifiers_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get domain ownership identifier for web app."]
#[doc = "Description for Get domain ownership identifier for web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_domain_ownership_identifier_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_domain_ownership_identifier_slot::RequestBuilder {
get_domain_ownership_identifier_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = "Description for Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_domain_ownership_identifier_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
domain_ownership_identifier: impl Into<models::Identifier>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_domain_ownership_identifier_slot::RequestBuilder {
create_or_update_domain_ownership_identifier_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = "Description for Creates a domain ownership identifier for web app, or updates an existing ownership identifier."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `domain_ownership_identifier`: A JSON representation of the domain ownership properties."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_domain_ownership_identifier_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
domain_ownership_identifier: impl Into<models::Identifier>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_domain_ownership_identifier_slot::RequestBuilder {
update_domain_ownership_identifier_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
domain_ownership_identifier: domain_ownership_identifier.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a domain ownership identifier for a web app."]
#[doc = "Description for Deletes a domain ownership identifier for a web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `domain_ownership_identifier_name`: Name of domain ownership identifier."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_domain_ownership_identifier_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
domain_ownership_identifier_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_domain_ownership_identifier_slot::RequestBuilder {
delete_domain_ownership_identifier_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
domain_ownership_identifier_name: domain_ownership_identifier_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the status of the last MSDeploy operation."]
#[doc = "Description for Get the status of the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ms_deploy_status_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ms_deploy_status_slot::RequestBuilder {
get_ms_deploy_status_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke the MSDeploy web app extension."]
#[doc = "Description for Invoke the MSDeploy web app extension."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `ms_deploy`: Details of MSDeploy operation"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_ms_deploy_operation_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
ms_deploy: impl Into<models::MsDeploy>,
subscription_id: impl Into<String>,
) -> create_ms_deploy_operation_slot::RequestBuilder {
create_ms_deploy_operation_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
ms_deploy: ms_deploy.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = "Description for Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_ms_deploy_log_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_ms_deploy_log_slot::RequestBuilder {
get_ms_deploy_log_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the functions for a web site, or a deployment slot."]
#[doc = "Description for List the functions for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_functions_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_functions_slot::RequestBuilder {
list_instance_functions_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Fetch a short lived token that can be exchanged for a master key."]
#[doc = "Description for Fetch a short lived token that can be exchanged for a master key."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_functions_admin_token_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_functions_admin_token_slot::RequestBuilder {
get_functions_admin_token_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function information by its ID for web site, or a deployment slot."]
#[doc = "Description for Get function information by its ID for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_function_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_function_slot::RequestBuilder {
get_instance_function_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Create function for web site, or a deployment slot."]
#[doc = "Description for Create function for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `function_envelope`: Function details."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_instance_function_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
slot: impl Into<String>,
function_envelope: impl Into<models::FunctionEnvelope>,
subscription_id: impl Into<String>,
) -> create_instance_function_slot::RequestBuilder {
create_instance_function_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
slot: slot.into(),
function_envelope: function_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a function for web site, or a deployment slot."]
#[doc = "Description for Delete a function for web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_instance_function_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_instance_function_slot::RequestBuilder {
delete_instance_function_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Add or update a function secret."]
#[doc = "Description for Add or update a function secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: The name of the function."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `key`: The key to create or update"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_function_secret_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
key_name: impl Into<String>,
slot: impl Into<String>,
key: impl Into<models::KeyInfo>,
subscription_id: impl Into<String>,
) -> create_or_update_function_secret_slot::RequestBuilder {
create_or_update_function_secret_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
key_name: key_name.into(),
slot: slot.into(),
key: key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a function secret."]
#[doc = "Description for Delete a function secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: The name of the function."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_function_secret_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
key_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_function_secret_slot::RequestBuilder {
delete_function_secret_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
key_name: key_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function keys for a function in a web site, or a deployment slot."]
#[doc = "Description for Get function keys for a function in a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_function_keys_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_function_keys_slot::RequestBuilder {
list_function_keys_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get function secrets for a function in a web site, or a deployment slot."]
#[doc = "Description for Get function secrets for a function in a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `function_name`: Function name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_function_secrets_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
function_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_function_secrets_slot::RequestBuilder {
list_function_secrets_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
function_name: function_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get host secrets for a function app."]
#[doc = "Description for Get host secrets for a function app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_host_keys_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_host_keys_slot::RequestBuilder {
list_host_keys_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "This is to allow calling via powershell and ARM template."]
#[doc = "Description for This is to allow calling via powershell and ARM template."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_sync_status_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_sync_status_slot::RequestBuilder {
list_sync_status_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Syncs function trigger metadata to the management database"]
#[doc = "Description for Syncs function trigger metadata to the management database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_functions_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_functions_slot::RequestBuilder {
sync_functions_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Add or update a host level secret."]
#[doc = "Description for Add or update a host level secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `key_type`: The type of host key."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `key`: The key to create or update"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_host_secret_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
key_type: impl Into<String>,
key_name: impl Into<String>,
slot: impl Into<String>,
key: impl Into<models::KeyInfo>,
subscription_id: impl Into<String>,
) -> create_or_update_host_secret_slot::RequestBuilder {
create_or_update_host_secret_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
key_type: key_type.into(),
key_name: key_name.into(),
slot: slot.into(),
key: key.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a host level secret."]
#[doc = "Description for Delete a host level secret."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `key_type`: The type of host key."]
#[doc = "* `key_name`: The name of the key."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_host_secret_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
key_type: impl Into<String>,
key_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_host_secret_slot::RequestBuilder {
delete_host_secret_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
key_type: key_type.into(),
key_name: key_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get hostname bindings for an app or a deployment slot."]
#[doc = "Description for Get hostname bindings for an app or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API gets hostname bindings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_host_name_bindings_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_host_name_bindings_slot::RequestBuilder {
list_host_name_bindings_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the named hostname binding for an app (or deployment slot, if specified)."]
#[doc = "Description for Get the named hostname binding for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API the named binding for the production slot."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_host_name_binding_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
host_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_host_name_binding_slot::RequestBuilder {
get_host_name_binding_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
host_name: host_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a hostname binding for an app."]
#[doc = "Description for Creates a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `host_name_binding`: Binding details. This is the JSON representation of a HostNameBinding object."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will create a binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_host_name_binding_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
host_name: impl Into<String>,
host_name_binding: impl Into<models::HostNameBinding>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_host_name_binding_slot::RequestBuilder {
create_or_update_host_name_binding_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
host_name: host_name.into(),
host_name_binding: host_name_binding.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a hostname binding for an app."]
#[doc = "Description for Deletes a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `host_name`: Hostname in the hostname binding."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_host_name_binding_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
host_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_host_name_binding_slot::RequestBuilder {
delete_host_name_binding_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
host_name: host_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieves a specific Service Bus Hybrid Connection used by this Web App."]
#[doc = "Description for Retrieves a specific Service Bus Hybrid Connection used by this Web App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_hybrid_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_hybrid_connection_slot::RequestBuilder {
get_hybrid_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = "Description for Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `connection_envelope`: The details of the hybrid connection."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_hybrid_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
connection_envelope: impl Into<models::HybridConnection>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_hybrid_connection_slot::RequestBuilder {
create_or_update_hybrid_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = "Description for Creates a new Hybrid Connection using a Service Bus relay."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `connection_envelope`: The details of the hybrid connection."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_hybrid_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
connection_envelope: impl Into<models::HybridConnection>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_hybrid_connection_slot::RequestBuilder {
update_hybrid_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Removes a Hybrid Connection from this site."]
#[doc = "Description for Removes a Hybrid Connection from this site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `namespace_name`: The namespace for this hybrid connection."]
#[doc = "* `relay_name`: The relay name for this hybrid connection."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_hybrid_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
namespace_name: impl Into<String>,
relay_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_hybrid_connection_slot::RequestBuilder {
delete_hybrid_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
namespace_name: namespace_name.into(),
relay_name: relay_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Retrieves all Service Bus Hybrid Connections used by this Web App."]
#[doc = "Description for Retrieves all Service Bus Hybrid Connections used by this Web App."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_hybrid_connections_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_hybrid_connections_slot::RequestBuilder {
list_hybrid_connections_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets hybrid connections configured for an app (or deployment slot, if specified)."]
#[doc = "Description for Gets hybrid connections configured for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get hybrid connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_relay_service_connections_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_relay_service_connections_slot::RequestBuilder {
list_relay_service_connections_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a hybrid connection configuration by its name."]
#[doc = "Description for Gets a hybrid connection configuration by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get a hybrid connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_relay_service_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_relay_service_connection_slot::RequestBuilder {
get_relay_service_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = "Description for Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `connection_envelope`: Details of the hybrid connection configuration."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will create or update a hybrid connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_relay_service_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
connection_envelope: impl Into<models::RelayServiceConnectionEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_relay_service_connection_slot::RequestBuilder {
create_or_update_relay_service_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = "Description for Creates a new hybrid connection configuration (PUT), or updates an existing one (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `connection_envelope`: Details of the hybrid connection configuration."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will create or update a hybrid connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_relay_service_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
connection_envelope: impl Into<models::RelayServiceConnectionEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_relay_service_connection_slot::RequestBuilder {
update_relay_service_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a relay service connection by its name."]
#[doc = "Description for Deletes a relay service connection by its name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `entity_name`: Name of the hybrid connection configuration."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete a hybrid connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_relay_service_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
entity_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_relay_service_connection_slot::RequestBuilder {
delete_relay_service_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
entity_name: entity_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all scale-out instances of an app."]
#[doc = "Description for Gets all scale-out instances of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API gets the production slot instances."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_identifiers_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_identifiers_slot::RequestBuilder {
list_instance_identifiers_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all scale-out instances of an app."]
#[doc = "Description for Gets all scale-out instances of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API gets the production slot instances."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_info_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
instance_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_info_slot::RequestBuilder {
get_instance_info_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
instance_id: instance_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the status of the last MSDeploy operation."]
#[doc = "Description for Get the status of the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_ms_deploy_status_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_ms_deploy_status_slot::RequestBuilder {
get_instance_ms_deploy_status_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Invoke the MSDeploy web app extension."]
#[doc = "Description for Invoke the MSDeploy web app extension."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `ms_deploy`: Details of MSDeploy operation"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_instance_ms_deploy_operation_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
ms_deploy: impl Into<models::MsDeploy>,
subscription_id: impl Into<String>,
) -> create_instance_ms_deploy_operation_slot::RequestBuilder {
create_instance_ms_deploy_operation_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
instance_id: instance_id.into(),
ms_deploy: ms_deploy.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = "Description for Get the MSDeploy Log for the last MSDeploy operation."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `instance_id`: ID of web app instance."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_ms_deploy_log_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_ms_deploy_log_slot::RequestBuilder {
get_instance_ms_deploy_log_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = "Description for Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_processes_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_processes_slot::RequestBuilder {
list_instance_processes_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process_slot::RequestBuilder {
get_instance_process_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = "Description for Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_instance_process_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_instance_process_slot::RequestBuilder {
delete_instance_process_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process_dump_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process_dump_slot::RequestBuilder {
get_instance_process_dump_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_process_modules_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_process_modules_slot::RequestBuilder {
list_instance_process_modules_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `base_address`: Module base address."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_instance_process_module_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
base_address: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_instance_process_module_slot::RequestBuilder {
get_instance_process_module_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
base_address: base_address.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `instance_id`: ID of a specific scaled-out instance. This is the value of the name property in the JSON response from \"GET api/sites/{siteName}/instances\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_instance_process_threads_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
instance_id: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_instance_process_threads_slot::RequestBuilder {
list_instance_process_threads_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
instance_id: instance_id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Shows whether an app can be cloned to another resource group or subscription."]
#[doc = "Description for Shows whether an app can be cloned to another resource group or subscription."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. By default, this API returns information on the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn is_cloneable_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> is_cloneable_slot::RequestBuilder {
is_cloneable_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets existing backups of an app."]
#[doc = "Description for Gets existing backups of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get backups of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_backups_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_backups_slot::RequestBuilder {
list_site_backups_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "This is to allow calling via powershell and ARM template."]
#[doc = "Description for This is to allow calling via powershell and ARM template."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_sync_function_triggers_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_sync_function_triggers_slot::RequestBuilder {
list_sync_function_triggers_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns the status of MySql in app migration, if one is active, and whether or not MySql in app is enabled"]
#[doc = "Description for Returns the status of MySql in app migration, if one is active, and whether or not MySql in app is enabled"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_migrate_my_sql_status_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_migrate_my_sql_status_slot::RequestBuilder {
get_migrate_my_sql_status_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a Swift Virtual Network connection."]
#[doc = "Description for Gets a Swift Virtual Network connection."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get a gateway for the production slot's Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_swift_virtual_network_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_swift_virtual_network_connection_slot::RequestBuilder {
get_swift_virtual_network_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\r\nin use by another App Service Plan other than the one this App is in."]
#[doc = "Description for Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\nin use by another App Service Plan other than the one this App is in."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_swift_virtual_network_connection_with_check_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_envelope: impl Into<models::SwiftVirtualNetwork>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_swift_virtual_network_connection_with_check_slot::RequestBuilder {
create_or_update_swift_virtual_network_connection_with_check_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\r\nin use by another App Service Plan other than the one this App is in."]
#[doc = "Description for Integrates this Web App with a Virtual Network. This requires that 1) \"swiftSupported\" is true when doing a GET against this resource, and 2) that the target Subnet has already been delegated, and is not\nin use by another App Service Plan other than the one this App is in."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_swift_virtual_network_connection_with_check_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
connection_envelope: impl Into<models::SwiftVirtualNetwork>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_swift_virtual_network_connection_with_check_slot::RequestBuilder {
update_swift_virtual_network_connection_with_check_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a Swift Virtual Network connection from an app (or deployment slot)."]
#[doc = "Description for Deletes a Swift Virtual Network connection from an app (or deployment slot)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_swift_virtual_network_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_swift_virtual_network_slot::RequestBuilder {
delete_swift_virtual_network_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets all network features used by the app (or deployment slot, if specified)."]
#[doc = "Description for Gets all network features used by the app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `view`: The type of view. Only \"summary\" is supported at this time."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get network features for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_network_features_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
view: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_network_features_slot::RequestBuilder {
list_network_features_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
view: view.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get an operation for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_trace_operation_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_trace_operation_slot::RequestBuilder {
get_network_trace_operation_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start capturing network packets for the site (To be deprecated)."]
#[doc = "Description for Start capturing network packets for the site (To be deprecated)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for this web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_web_site_network_trace_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_web_site_network_trace_slot::RequestBuilder {
start_web_site_network_trace_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Start capturing network packets for the site."]
#[doc = "Description for Start capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for this web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_web_site_network_trace_operation_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_web_site_network_trace_operation_slot::RequestBuilder {
start_web_site_network_trace_operation_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Stop ongoing capturing network packets for the site."]
#[doc = "Description for Stop ongoing capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for this web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_web_site_network_trace_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_web_site_network_trace_slot::RequestBuilder {
stop_web_site_network_trace_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get an operation for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_traces_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_traces_slot::RequestBuilder {
get_network_traces_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get an operation for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_trace_operation_slot_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_trace_operation_slot_v2::RequestBuilder {
get_network_trace_operation_slot_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = "Description for Gets a named operation for a network trace capturing (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `operation_id`: GUID of the operation."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get an operation for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_network_traces_slot_v2(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
operation_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_network_traces_slot_v2::RequestBuilder {
get_network_traces_slot_v2::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
operation_id: operation_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Generates a new publishing password for an app (or deployment slot, if specified)."]
#[doc = "Description for Generates a new publishing password for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API generate a new publishing password for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn generate_new_site_publishing_password_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> generate_new_site_publishing_password_slot::RequestBuilder {
generate_new_site_publishing_password_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets perfmon counters for web app."]
#[doc = "Description for Gets perfmon counters for web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_perf_mon_counters_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_perf_mon_counters_slot::RequestBuilder {
list_perf_mon_counters_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Gets web app's event logs."]
#[doc = "Description for Gets web app's event logs."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_php_error_log_flag_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_php_error_log_flag_slot::RequestBuilder {
get_site_php_error_log_flag_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the premier add-ons of an app."]
#[doc = "Description for Gets the premier add-ons of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the premier add-ons for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_premier_add_ons_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_premier_add_ons_slot::RequestBuilder {
list_premier_add_ons_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a named add-on of an app."]
#[doc = "Description for Gets a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the named add-on for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_premier_add_on_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_premier_add_on_slot::RequestBuilder {
get_premier_add_on_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates a named add-on of an app."]
#[doc = "Description for Updates a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `premier_add_on`: A JSON representation of the edited premier add-on."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the named add-on for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn add_premier_add_on_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
premier_add_on: impl Into<models::PremierAddOn>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> add_premier_add_on_slot::RequestBuilder {
add_premier_add_on_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
premier_add_on: premier_add_on.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates a named add-on of an app."]
#[doc = "Description for Updates a named add-on of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `premier_add_on`: A JSON representation of the edited premier add-on."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the named add-on for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_premier_add_on_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
premier_add_on: impl Into<models::PremierAddOnPatchResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_premier_add_on_slot::RequestBuilder {
update_premier_add_on_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
premier_add_on: premier_add_on.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a premier add-on from an app."]
#[doc = "Description for Delete a premier add-on from an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `premier_add_on_name`: Add-on name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the named add-on for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_premier_add_on_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
premier_add_on_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_premier_add_on_slot::RequestBuilder {
delete_premier_add_on_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
premier_add_on_name: premier_add_on_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = "Description for Gets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_access_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_access_slot::RequestBuilder {
get_private_access_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Sets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = "Description for Sets data around private site access enablement and authorized Virtual Networks that can access the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `access`: The information for the private access"]
#[doc = "* `slot`: The name of the slot for the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn put_private_access_vnet_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
access: impl Into<models::PrivateAccess>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> put_private_access_vnet_slot::RequestBuilder {
put_private_access_vnet_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
access: access.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the list of private endpoint connections associated with a site"]
#[doc = "Description for Gets the list of private endpoint connections associated with a site"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `slot`: Name of the site deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection_list_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection_list_slot::RequestBuilder {
get_private_endpoint_connection_list_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a private endpoint connection"]
#[doc = "Description for Gets a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `private_endpoint_connection_name`: Name of the private endpoint connection."]
#[doc = "* `slot`: Name of the site deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_endpoint_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_endpoint_connection_slot::RequestBuilder {
get_private_endpoint_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Approves or rejects a private endpoint connection"]
#[doc = "Description for Approves or rejects a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn approve_or_reject_private_endpoint_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
private_endpoint_wrapper: impl Into<models::PrivateLinkConnectionApprovalRequestResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> approve_or_reject_private_endpoint_connection_slot::RequestBuilder {
approve_or_reject_private_endpoint_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
private_endpoint_wrapper: private_endpoint_wrapper.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a private endpoint connection"]
#[doc = "Description for Deletes a private endpoint connection"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_private_endpoint_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
private_endpoint_connection_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_private_endpoint_connection_slot::RequestBuilder {
delete_private_endpoint_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
private_endpoint_connection_name: private_endpoint_connection_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the private link resources"]
#[doc = "Description for Gets the private link resources"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the site."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_private_link_resources_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_private_link_resources_slot::RequestBuilder {
get_private_link_resources_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = "Description for Get list of processes for a web site, or a deployment slot, or for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_processes_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_processes_slot::RequestBuilder {
list_processes_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process_slot::RequestBuilder {
get_process_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = "Description for Terminate a process by its ID for a web site, or a deployment slot, or specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_process_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_process_slot::RequestBuilder {
delete_process_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get a memory dump of a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process_dump_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process_dump_slot::RequestBuilder {
get_process_dump_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List module information for a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_process_modules_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_process_modules_slot::RequestBuilder {
list_process_modules_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for Get process information by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `base_address`: Module base address."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_process_module_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
base_address: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_process_module_slot::RequestBuilder {
get_process_module_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
base_address: base_address.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = "Description for List the threads in a process by its ID for a specific scaled-out instance in a web site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `process_id`: PID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_process_threads_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
process_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_process_threads_slot::RequestBuilder {
list_process_threads_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
process_id: process_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get public certificates for an app or a deployment slot."]
#[doc = "Description for Get public certificates for an app or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API gets hostname bindings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_public_certificates_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_public_certificates_slot::RequestBuilder {
list_public_certificates_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the named public certificate for an app (or deployment slot, if specified)."]
#[doc = "Description for Get the named public certificate for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API the named binding for the production slot."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_public_certificate_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
public_certificate_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_public_certificate_slot::RequestBuilder {
get_public_certificate_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
public_certificate_name: public_certificate_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Creates a hostname binding for an app."]
#[doc = "Description for Creates a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `public_certificate`: Public certificate details. This is the JSON representation of a PublicCertificate object."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will create a binding for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_public_certificate_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
public_certificate_name: impl Into<String>,
public_certificate: impl Into<models::PublicCertificate>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_public_certificate_slot::RequestBuilder {
create_or_update_public_certificate_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
public_certificate_name: public_certificate_name.into(),
public_certificate: public_certificate.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a hostname binding for an app."]
#[doc = "Description for Deletes a hostname binding for an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the binding for the production slot."]
#[doc = "* `public_certificate_name`: Public certificate name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_public_certificate_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
public_certificate_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_public_certificate_slot::RequestBuilder {
delete_public_certificate_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
public_certificate_name: public_certificate_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the publishing profile for an app (or deployment slot, if specified)."]
#[doc = "Description for Gets the publishing profile for an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `publishing_profile_options`: Specifies publishingProfileOptions for publishing profile. For example, use {\"format\": \"FileZilla3\"} to get a FileZilla publishing profile."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the publishing profile for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_publishing_profile_xml_with_secrets_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
publishing_profile_options: impl Into<models::CsmPublishingProfileOptions>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_publishing_profile_xml_with_secrets_slot::RequestBuilder {
list_publishing_profile_xml_with_secrets_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
publishing_profile_options: publishing_profile_options.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Resets the configuration settings of the current slot if they were previously modified by calling the API with POST."]
#[doc = "Description for Resets the configuration settings of the current slot if they were previously modified by calling the API with POST."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API resets configuration settings for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn reset_slot_configuration_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> reset_slot_configuration_slot::RequestBuilder {
reset_slot_configuration_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restarts an app (or deployment slot, if specified)."]
#[doc = "Description for Restarts an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will restart the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restart_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> restart_slot::RequestBuilder {
restart_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
soft_restart: None,
synchronous: None,
}
}
#[doc = "Restores an app from a backup blob in Azure Storage."]
#[doc = "Description for Restores an app from a backup blob in Azure Storage."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `request`: Information on restore request ."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will restore a backup of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_from_backup_blob_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
request: impl Into<models::RestoreRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> restore_from_backup_blob_slot::RequestBuilder {
restore_from_backup_blob_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
request: request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a deleted web app to this web app."]
#[doc = "Description for Restores a deleted web app to this web app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `restore_request`: Deleted web app restore information."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_from_deleted_app_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
restore_request: impl Into<models::DeletedAppRestoreRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> restore_from_deleted_app_slot::RequestBuilder {
restore_from_deleted_app_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
restore_request: restore_request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Restores a web app from a snapshot."]
#[doc = "Description for Restores a web app from a snapshot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `restore_request`: Snapshot restore settings. Snapshot information can be obtained by calling GetDeletedSites or GetSiteSnapshots API."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn restore_snapshot_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
restore_request: impl Into<models::SnapshotRestoreRequest>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> restore_snapshot_slot::RequestBuilder {
restore_snapshot_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
restore_request: restore_request.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get list of siteextensions for a web site, or a deployment slot."]
#[doc = "Description for Get list of siteextensions for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_site_extensions_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_site_extensions_slot::RequestBuilder {
list_site_extensions_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get site extension information by its ID for a web site, or a deployment slot."]
#[doc = "Description for Get site extension information by its ID for a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_site_extension_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_site_extension_slot::RequestBuilder {
get_site_extension_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Install site extension on a web site, or a deployment slot."]
#[doc = "Description for Install site extension on a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn install_site_extension_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> install_site_extension_slot::RequestBuilder {
install_site_extension_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Remove a site extension from a web site, or a deployment slot."]
#[doc = "Description for Remove a site extension from a web site, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `site_extension_id`: Site extension name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_site_extension_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_extension_id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_site_extension_slot::RequestBuilder {
delete_site_extension_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_extension_id: site_extension_id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the difference in configuration settings between two web app slots."]
#[doc = "Description for Get the difference in configuration settings between two web app slots."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `slot`: Name of the source slot. If a slot is not specified, the production slot is used as the source slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_slot_differences_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_slot_differences_slot::RequestBuilder {
list_slot_differences_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Swaps two deployment slots of an app."]
#[doc = "Description for Swaps two deployment slots of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `slot`: Name of the source slot. If a slot is not specified, the production slot is used as the source slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn swap_slot_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> swap_slot_slot::RequestBuilder {
swap_slot_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns all Snapshots to the user."]
#[doc = "Description for Returns all Snapshots to the user."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Website Name."]
#[doc = "* `slot`: Website Slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_snapshots_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_snapshots_slot::RequestBuilder {
list_snapshots_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns all Snapshots to the user from DRSecondary endpoint."]
#[doc = "Description for Returns all Snapshots to the user from DRSecondary endpoint."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Website Name."]
#[doc = "* `slot`: Website Slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_snapshots_from_dr_secondary_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_snapshots_from_dr_secondary_slot::RequestBuilder {
list_snapshots_from_dr_secondary_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the source control configuration of an app."]
#[doc = "Description for Gets the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the source control configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_source_control_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_source_control_slot::RequestBuilder {
get_source_control_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the source control configuration of an app."]
#[doc = "Description for Updates the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_source_control`: JSON representation of a SiteSourceControl object. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the source control configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_source_control_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_source_control: impl Into<models::SiteSourceControl>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_source_control_slot::RequestBuilder {
create_or_update_source_control_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_source_control: site_source_control.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the source control configuration of an app."]
#[doc = "Description for Updates the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_source_control`: JSON representation of a SiteSourceControl object. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will update the source control configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_source_control_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_source_control: impl Into<models::SiteSourceControl>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_source_control_slot::RequestBuilder {
update_source_control_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_source_control: site_source_control.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes the source control configuration of an app."]
#[doc = "Description for Deletes the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the source control configuration for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_source_control_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_source_control_slot::RequestBuilder {
delete_source_control_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
additional_flags: None,
}
}
#[doc = "Starts an app (or deployment slot, if specified)."]
#[doc = "Description for Starts an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will start the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_slot::RequestBuilder {
start_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start capturing network packets for the site."]
#[doc = "Description for Start capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for this web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_network_trace_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_network_trace_slot::RequestBuilder {
start_network_trace_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Stops an app (or deployment slot, if specified)."]
#[doc = "Description for Stops an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will stop the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_slot::RequestBuilder {
stop_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Stop ongoing capturing network packets for the site."]
#[doc = "Description for Stop ongoing capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `slot`: The name of the slot for this web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_network_trace_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_network_trace_slot::RequestBuilder {
stop_network_trace_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Sync web app repository."]
#[doc = "Description for Sync web app repository."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `slot`: Name of web app slot. If not specified then will default to production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_repository_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_repository_slot::RequestBuilder {
sync_repository_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Syncs function trigger metadata to the management database"]
#[doc = "Description for Syncs function trigger metadata to the management database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_function_triggers_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_function_triggers_slot::RequestBuilder {
sync_function_triggers_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List triggered web jobs for an app, or a deployment slot."]
#[doc = "Description for List triggered web jobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes a deployment for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_triggered_web_jobs_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_triggered_web_jobs_slot::RequestBuilder {
list_triggered_web_jobs_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a triggered web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Gets a triggered web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_triggered_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_triggered_web_job_slot::RequestBuilder {
get_triggered_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a triggered web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a triggered web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API deletes web job for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_triggered_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_triggered_web_job_slot::RequestBuilder {
delete_triggered_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List a triggered web job's history for an app, or a deployment slot."]
#[doc = "Description for List a triggered web job's history for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_triggered_web_job_history_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_triggered_web_job_history_slot::RequestBuilder {
list_triggered_web_job_history_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a triggered web job's history by its ID for an app, , or a deployment slot."]
#[doc = "Description for Gets a triggered web job's history by its ID for an app, , or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `id`: History ID."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_triggered_web_job_history_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
id: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_triggered_web_job_history_slot::RequestBuilder {
get_triggered_web_job_history_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
id: id.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Run a triggered web job for an app, or a deployment slot."]
#[doc = "Description for Run a triggered web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API uses the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn run_triggered_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> run_triggered_web_job_slot::RequestBuilder {
run_triggered_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the quota usage information of an app (or deployment slot, if specified)."]
#[doc = "Description for Gets the quota usage information of an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get quota information of the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_usages_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_usages_slot::RequestBuilder {
list_usages_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Gets the virtual networks the app (or deployment slot) is connected to."]
#[doc = "Description for Gets the virtual networks the app (or deployment slot) is connected to."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get virtual network connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_vnet_connections_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_vnet_connections_slot::RequestBuilder {
list_vnet_connections_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a virtual network the app (or deployment slot) is connected to by name."]
#[doc = "Description for Gets a virtual network the app (or deployment slot) is connected to by name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the virtual network."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get the named virtual network for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_connection_slot::RequestBuilder {
get_vnet_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = "Description for Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of an existing Virtual Network."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_vnet_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
connection_envelope: impl Into<models::VnetInfoResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_vnet_connection_slot::RequestBuilder {
create_or_update_vnet_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = "Description for Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of an existing Virtual Network."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update connections for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
connection_envelope: impl Into<models::VnetInfoResource>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_vnet_connection_slot::RequestBuilder {
update_vnet_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a connection from an app (or deployment slot to a named virtual network."]
#[doc = "Description for Deletes a connection from an app (or deployment slot to a named virtual network."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the virtual network."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will delete the connection for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_vnet_connection_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_vnet_connection_slot::RequestBuilder {
delete_vnet_connection_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets an app's Virtual Network gateway."]
#[doc = "Description for Gets an app's Virtual Network gateway."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will get a gateway for the production slot's Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_connection_gateway_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_connection_gateway_slot::RequestBuilder {
get_vnet_connection_gateway_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = "Description for Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `connection_envelope`: The properties to update this gateway with."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update a gateway for the production slot's Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_vnet_connection_gateway_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
connection_envelope: impl Into<models::VnetGateway>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> create_or_update_vnet_connection_gateway_slot::RequestBuilder {
create_or_update_vnet_connection_gateway_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = "Description for Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `connection_envelope`: The properties to update this gateway with."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API will add or update a gateway for the production slot's Virtual Network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_connection_gateway_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
connection_envelope: impl Into<models::VnetGateway>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> update_vnet_connection_gateway_slot::RequestBuilder {
update_vnet_connection_gateway_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
connection_envelope: connection_envelope.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List webjobs for an app, or a deployment slot."]
#[doc = "Description for List webjobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_jobs_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_jobs_slot::RequestBuilder {
list_web_jobs_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get webjob information for an app, or a deployment slot."]
#[doc = "Description for Get webjob information for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of the web job."]
#[doc = "* `slot`: Name of the deployment slot. If a slot is not specified, the API returns deployments for the production slot."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_web_job_slot(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
slot: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_web_job_slot::RequestBuilder {
get_web_job_slot::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
slot: slot.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get the difference in configuration settings between two web app slots."]
#[doc = "Description for Get the difference in configuration settings between two web app slots."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_slot_differences_from_production(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
subscription_id: impl Into<String>,
) -> list_slot_differences_from_production::RequestBuilder {
list_slot_differences_from_production::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Swaps two deployment slots of an app."]
#[doc = "Description for Swaps two deployment slots of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `slot_swap_entity`: JSON object that contains the target slot name. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn swap_slot_with_production(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
slot_swap_entity: impl Into<models::CsmSlotEntity>,
subscription_id: impl Into<String>,
) -> swap_slot_with_production::RequestBuilder {
swap_slot_with_production::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
slot_swap_entity: slot_swap_entity.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns all Snapshots to the user."]
#[doc = "Description for Returns all Snapshots to the user."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Website Name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_snapshots(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_snapshots::RequestBuilder {
list_snapshots::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Returns all Snapshots to the user from DRSecondary endpoint."]
#[doc = "Description for Returns all Snapshots to the user from DRSecondary endpoint."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Website Name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_snapshots_from_dr_secondary(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_snapshots_from_dr_secondary::RequestBuilder {
list_snapshots_from_dr_secondary::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the source control configuration of an app."]
#[doc = "Description for Gets the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_source_control(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_source_control::RequestBuilder {
get_source_control::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the source control configuration of an app."]
#[doc = "Description for Updates the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_source_control`: JSON representation of a SiteSourceControl object. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_source_control(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_source_control: impl Into<models::SiteSourceControl>,
subscription_id: impl Into<String>,
) -> create_or_update_source_control::RequestBuilder {
create_or_update_source_control::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_source_control: site_source_control.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Updates the source control configuration of an app."]
#[doc = "Description for Updates the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `site_source_control`: JSON representation of a SiteSourceControl object. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_source_control(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
site_source_control: impl Into<models::SiteSourceControl>,
subscription_id: impl Into<String>,
) -> update_source_control::RequestBuilder {
update_source_control::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
site_source_control: site_source_control.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes the source control configuration of an app."]
#[doc = "Description for Deletes the source control configuration of an app."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_source_control(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_source_control::RequestBuilder {
delete_source_control::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
additional_flags: None,
}
}
#[doc = "Starts an app (or deployment slot, if specified)."]
#[doc = "Description for Starts an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> start::RequestBuilder {
start::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Start capturing network packets for the site."]
#[doc = "Description for Start capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn start_network_trace(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> start_network_trace::RequestBuilder {
start_network_trace::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
duration_in_seconds: None,
max_frame_length: None,
sas_url: None,
}
}
#[doc = "Stops an app (or deployment slot, if specified)."]
#[doc = "Description for Stops an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop::RequestBuilder {
stop::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Stop ongoing capturing network packets for the site."]
#[doc = "Description for Stop ongoing capturing network packets for the site."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: The name of the web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn stop_network_trace(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> stop_network_trace::RequestBuilder {
stop_network_trace::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Sync web app repository."]
#[doc = "Description for Sync web app repository."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of web app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_repository(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_repository::RequestBuilder {
sync_repository::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Syncs function trigger metadata to the management database"]
#[doc = "Description for Syncs function trigger metadata to the management database"]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn sync_function_triggers(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> sync_function_triggers::RequestBuilder {
sync_function_triggers::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List triggered web jobs for an app, or a deployment slot."]
#[doc = "Description for List triggered web jobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_triggered_web_jobs(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_triggered_web_jobs::RequestBuilder {
list_triggered_web_jobs::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a triggered web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Gets a triggered web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_triggered_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_triggered_web_job::RequestBuilder {
get_triggered_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Delete a triggered web job by its ID for an app, or a deployment slot."]
#[doc = "Description for Delete a triggered web job by its ID for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_triggered_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_triggered_web_job::RequestBuilder {
delete_triggered_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List a triggered web job's history for an app, or a deployment slot."]
#[doc = "Description for List a triggered web job's history for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_triggered_web_job_history(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_triggered_web_job_history::RequestBuilder {
list_triggered_web_job_history::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a triggered web job's history by its ID for an app, , or a deployment slot."]
#[doc = "Description for Gets a triggered web job's history by its ID for an app, , or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `id`: History ID."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_triggered_web_job_history(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
id: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_triggered_web_job_history::RequestBuilder {
get_triggered_web_job_history::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
id: id.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Run a triggered web job for an app, or a deployment slot."]
#[doc = "Description for Run a triggered web job for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of Web Job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn run_triggered_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> run_triggered_web_job::RequestBuilder {
run_triggered_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets the quota usage information of an app (or deployment slot, if specified)."]
#[doc = "Description for Gets the quota usage information of an app (or deployment slot, if specified)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_usages(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_usages::RequestBuilder {
list_usages::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
filter: None,
}
}
#[doc = "Gets the virtual networks the app (or deployment slot) is connected to."]
#[doc = "Description for Gets the virtual networks the app (or deployment slot) is connected to."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_vnet_connections(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_vnet_connections::RequestBuilder {
list_vnet_connections::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets a virtual network the app (or deployment slot) is connected to by name."]
#[doc = "Description for Gets a virtual network the app (or deployment slot) is connected to by name."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the virtual network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_connection::RequestBuilder {
get_vnet_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = "Description for Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of an existing Virtual Network."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_vnet_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
connection_envelope: impl Into<models::VnetInfoResource>,
subscription_id: impl Into<String>,
) -> create_or_update_vnet_connection::RequestBuilder {
create_or_update_vnet_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = "Description for Adds a Virtual Network connection to an app or slot (PUT) or updates the connection properties (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of an existing Virtual Network."]
#[doc = "* `connection_envelope`: Properties of the Virtual Network connection. See example."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
connection_envelope: impl Into<models::VnetInfoResource>,
subscription_id: impl Into<String>,
) -> update_vnet_connection::RequestBuilder {
update_vnet_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Deletes a connection from an app (or deployment slot to a named virtual network."]
#[doc = "Description for Deletes a connection from an app (or deployment slot to a named virtual network."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the virtual network."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn delete_vnet_connection(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> delete_vnet_connection::RequestBuilder {
delete_vnet_connection::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Gets an app's Virtual Network gateway."]
#[doc = "Description for Gets an app's Virtual Network gateway."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_vnet_connection_gateway(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_vnet_connection_gateway::RequestBuilder {
get_vnet_connection_gateway::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = "Description for Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `connection_envelope`: The properties to update this gateway with."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn create_or_update_vnet_connection_gateway(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
connection_envelope: impl Into<models::VnetGateway>,
subscription_id: impl Into<String>,
) -> create_or_update_vnet_connection_gateway::RequestBuilder {
create_or_update_vnet_connection_gateway::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = "Description for Adds a gateway to a connected Virtual Network (PUT) or updates it (PATCH)."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Name of the app."]
#[doc = "* `vnet_name`: Name of the Virtual Network."]
#[doc = "* `gateway_name`: Name of the gateway. Currently, the only supported string is \"primary\"."]
#[doc = "* `connection_envelope`: The properties to update this gateway with."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn update_vnet_connection_gateway(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
vnet_name: impl Into<String>,
gateway_name: impl Into<String>,
connection_envelope: impl Into<models::VnetGateway>,
subscription_id: impl Into<String>,
) -> update_vnet_connection_gateway::RequestBuilder {
update_vnet_connection_gateway::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
vnet_name: vnet_name.into(),
gateway_name: gateway_name.into(),
connection_envelope: connection_envelope.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "List webjobs for an app, or a deployment slot."]
#[doc = "Description for List webjobs for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn list_web_jobs(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
subscription_id: impl Into<String>,
) -> list_web_jobs::RequestBuilder {
list_web_jobs::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
subscription_id: subscription_id.into(),
}
}
#[doc = "Get webjob information for an app, or a deployment slot."]
#[doc = "Description for Get webjob information for an app, or a deployment slot."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `web_job_name`: Name of the web job."]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
pub fn get_web_job(
&self,
resource_group_name: impl Into<String>,
name: impl Into<String>,
web_job_name: impl Into<String>,
subscription_id: impl Into<String>,
) -> get_web_job::RequestBuilder {
get_web_job::RequestBuilder {
client: self.0.clone(),
resource_group_name: resource_group_name.into(),
name: name.into(),
web_job_name: web_job_name.into(),
subscription_id: subscription_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/providers/Microsoft.Web/sites",
this.client.endpoint(),
&this.subscription_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_by_resource_group {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) subscription_id: String,
pub(crate) include_slots: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify <strong>true</strong> to include deployment slots in results. The default is false, which only gives you the production slot of all apps."]
pub fn include_slots(mut self, include_slots: bool) -> Self {
self.include_slots = Some(include_slots);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(include_slots) = &this.include_slots {
req.url_mut()
.query_pairs_mut()
.append_pair("includeSlots", &include_slots.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_envelope: models::Site,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_envelope: models::SitePatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) delete_metrics: Option<bool>,
pub(crate) delete_empty_server_farm: Option<bool>,
}
impl RequestBuilder {
#[doc = "If true, web app metrics are also deleted."]
pub fn delete_metrics(mut self, delete_metrics: bool) -> Self {
self.delete_metrics = Some(delete_metrics);
self
}
#[doc = "Specify false if you want to keep empty App Service plan. By default, empty App Service plan is deleted."]
pub fn delete_empty_server_farm(mut self, delete_empty_server_farm: bool) -> Self {
self.delete_empty_server_farm = Some(delete_empty_server_farm);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(delete_metrics) = &this.delete_metrics {
req.url_mut()
.query_pairs_mut()
.append_pair("deleteMetrics", &delete_metrics.to_string());
}
if let Some(delete_empty_server_farm) = &this.delete_empty_server_farm {
req.url_mut()
.query_pairs_mut()
.append_pair("deleteEmptyServerFarm", &delete_empty_server_farm.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod analyze_custom_hostname {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomHostnameAnalysisResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomHostnameAnalysisResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) host_name: Option<String>,
}
impl RequestBuilder {
#[doc = "Custom hostname."]
pub fn host_name(mut self, host_name: impl Into<String>) -> Self {
self.host_name = Some(host_name.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/analyzeCustomHostname",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(host_name) = &this.host_name {
req.url_mut().query_pairs_mut().append_pair("hostName", host_name);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomHostnameAnalysisResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod apply_slot_config_to_production {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/applySlotConfig",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod backup {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::BackupRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_backups {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItemCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItemCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BackupItemCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_backup_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_backup {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_backup_status_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) request: models::BackupRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod restore {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) request: models::RestoreRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/backups/{}/restore",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_basic_publishing_credentials_policies {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublishingCredentialsPoliciesCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublishingCredentialsPoliciesCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PublishingCredentialsPoliciesCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/basicPublishingCredentialsPolicies",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_ftp_allowed {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/basicPublishingCredentialsPolicies/ftp",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_ftp_allowed {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) csm_publishing_access_policies_entity: models::CsmPublishingCredentialsPoliciesEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/basicPublishingCredentialsPolicies/ftp",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.csm_publishing_access_policies_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_scm_allowed {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/basicPublishingCredentialsPolicies/scm",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_scm_allowed {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) csm_publishing_access_policies_entity: models::CsmPublishingCredentialsPoliciesEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/basicPublishingCredentialsPolicies/scm",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.csm_publishing_access_policies_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_configurations {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResourceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResourceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteConfigResourceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod update_application_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/appsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_application_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/appsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_auth_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_auth_settings: models::SiteAuthSettings,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_auth_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings_v2_without_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettingsV2",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_auth_settings_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_auth_settings_v2: models::SiteAuthSettingsV2,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettingsV2",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_auth_settings_v2)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/authsettingsV2/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_azure_storage_accounts {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AzureStoragePropertyDictionaryResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AzureStoragePropertyDictionaryResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) azure_storage_accounts: models::AzureStoragePropertyDictionaryResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/azurestorageaccounts",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.azure_storage_accounts)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::AzureStoragePropertyDictionaryResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_azure_storage_accounts {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AzureStoragePropertyDictionaryResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AzureStoragePropertyDictionaryResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/azurestorageaccounts/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::AzureStoragePropertyDictionaryResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_backup_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::BackupRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_backup_configuration {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_backup_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/backup/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_app_settings_key_vault_references {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ApiKvReferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/configreferences/appsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_app_setting_key_vault_reference {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReference> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReference = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_setting_key: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/configreferences/appsettings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.app_setting_key
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ApiKvReference>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_site_connection_string_key_vault_references {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ApiKvReferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/configreferences/connectionstrings" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_connection_string_key_vault_reference {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReference> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReference = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_string_key: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/configreferences/connectionstrings/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . connection_string_key)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ApiKvReference>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_connection_strings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ConnectionStringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::ConnectionStringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_strings: models::ConnectionStringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/connectionstrings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_strings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ConnectionStringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_connection_strings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ConnectionStringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::ConnectionStringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/connectionstrings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ConnectionStringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_diagnostic_logs_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteLogsConfig> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteLogsConfig = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/logs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteLogsConfig>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_diagnostic_logs_config {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteLogsConfig> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteLogsConfig = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_logs_config: models::SiteLogsConfig,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/logs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_logs_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteLogsConfig>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_metadata {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) metadata: models::StringDictionary,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/metadata",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.metadata)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_metadata {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/metadata/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_publishing_credentials {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::User> {
let bytes = self.0.into_body().collect().await?;
let body: models::User = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/publishingcredentials/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::User>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_site_push_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PushSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::PushSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) push_settings: models::PushSettings,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/pushsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.push_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PushSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_push_settings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PushSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::PushSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/pushsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PushSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_slot_configuration_names {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SlotConfigNamesResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SlotConfigNamesResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/slotConfigNames",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SlotConfigNamesResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_slot_configuration_names {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SlotConfigNamesResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SlotConfigNamesResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_config_names: models::SlotConfigNamesResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/slotConfigNames",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_config_names)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SlotConfigNamesResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_config: models::SiteConfigResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_configuration {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_config: models::SiteConfigResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_configuration_snapshot_info {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigurationSnapshotInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigurationSnapshotInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteConfigurationSnapshotInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_configuration_snapshot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) snapshot_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.snapshot_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod recover_site_configuration_snapshot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) snapshot_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/config/web/snapshots/{}/recover",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.snapshot_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_web_site_container_logs {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/containerlogs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_container_logs_zip {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/containerlogs/zip/download",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_continuous_web_jobs {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContinuousWebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContinuousWebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ContinuousWebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_continuous_web_job {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContinuousWebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContinuousWebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ContinuousWebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_continuous_web_job {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start_continuous_web_job {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod stop_continuous_web_job {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/continuouswebjobs/{}/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_production_site_deployment_statuses {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmDeploymentStatusCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmDeploymentStatusCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CsmDeploymentStatusCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deploymentStatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_production_site_deployment_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmDeploymentStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmDeploymentStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) deployment_status_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deploymentStatus/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.deployment_status_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmDeploymentStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_deployments {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeploymentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeploymentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DeploymentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_deployment {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_deployment {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) deployment: models::Deployment,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.deployment)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_deployment {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_deployment_log {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/deployments/{}/log",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod discover_backup {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RestoreRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::RestoreRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::RestoreRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/discoverbackup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RestoreRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_domain_ownership_identifiers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::IdentifierCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::IdentifierCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::IdentifierCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_domain_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_domain_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) domain_ownership_identifier: models::Identifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_domain_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) domain_ownership_identifier: models::Identifier,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_domain_ownership_identifier {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_ms_deploy_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_ms_deploy_operation {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) ms_deploy: models::MsDeploy,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.ms_deploy)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_ms_deploy_log {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployLog> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployLog = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/MSDeploy/log",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployLog>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_one_deploy_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/onedeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_one_deploy_operation {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/extensions/onedeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_functions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelopeCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelopeCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::FunctionEnvelopeCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_functions_admin_token {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<String> {
let bytes = self.0.into_body().collect().await?;
let body: String = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/admin/token",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<String>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_function {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelope> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelope = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionEnvelope>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_function {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelope> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelope = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) function_envelope: models::FunctionEnvelope,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.function_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionEnvelope>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_function {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_function_secret {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KeyInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::KeyInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) key_name: String,
pub(crate) key: models::KeyInfo,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}/keys/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KeyInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_function_secret {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) key_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}/keys/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_function_keys {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}/listkeys",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_function_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionSecrets> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionSecrets = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/functions/{}/listsecrets",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionSecrets>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_host_keys {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostKeys> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostKeys = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/host/default/listkeys",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostKeys>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_sync_status {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/host/default/listsyncstatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_functions {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/host/default/sync",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_host_secret {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KeyInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::KeyInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) key_type: String,
pub(crate) key_name: String,
pub(crate) key: models::KeyInfo,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/host/default/{}/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.key_type,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KeyInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_host_secret {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) key_type: String,
pub(crate) key_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/host/default/{}/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.key_type,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_host_name_bindings {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBindingCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBindingCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::HostNameBindingCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_host_name_binding {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBinding> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBinding = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) host_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostNameBinding>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_host_name_binding {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBinding> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBinding = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) host_name: String,
pub(crate) host_name_binding: models::HostNameBinding,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.host_name_binding)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostNameBinding>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_host_name_binding {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) host_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) connection_envelope: models::HybridConnection,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) connection_envelope: models::HybridConnection,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_hybrid_connection {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_hybrid_connections {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridConnectionRelays",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_relay_service_connections {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_relay_service_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_relay_service_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) connection_envelope: models::RelayServiceConnectionEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_relay_service_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) connection_envelope: models::RelayServiceConnectionEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_relay_service_connection {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_instance_identifiers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppInstanceStatusCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppInstanceStatusCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppInstanceStatusCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_info {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebSiteInstanceStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebSiteInstanceStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WebSiteInstanceStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_instance_ms_deploy_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_instance_ms_deploy_operation {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) ms_deploy: models::MsDeploy,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.ms_deploy)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_instance_ms_deploy_log {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployLog> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployLog = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/extensions/MSDeploy/log",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployLog>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_processes {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_process {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_instance_process {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_instance_process_dump {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/dump",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_process_modules {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessModuleInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/modules",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_process_module {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) base_address: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/modules/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id,
&this.base_address
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessModuleInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_process_threads {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessThreadInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessThreadInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessThreadInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/instances/{}/processes/{}/threads",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.instance_id,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod is_cloneable {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteCloneability> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteCloneability = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/iscloneable",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteCloneability>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_backups {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItemCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItemCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BackupItemCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/listbackups",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_sync_function_triggers {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionSecrets> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionSecrets = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/listsyncfunctiontriggerstatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionSecrets>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod migrate_storage {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StorageMigrationResponse> {
let bytes = self.0.into_body().collect().await?;
let body: models::StorageMigrationResponse = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_name: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) migration_options: models::StorageMigrationOptions,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migrate",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let subscription_name = &this.subscription_name;
req.url_mut().query_pairs_mut().append_pair("subscriptionName", subscription_name);
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.migration_options)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StorageMigrationResponse>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod migrate_my_sql {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Operation> {
let bytes = self.0.into_body().collect().await?;
let body: models::Operation = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) migration_request_envelope: models::MigrateMySqlRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migratemysql",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.migration_request_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Operation>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_migrate_my_sql_status {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MigrateMySqlStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MigrateMySqlStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/migratemysql/status",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MigrateMySqlStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_swift_virtual_network_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_swift_virtual_network_connection_with_check {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_envelope: models::SwiftVirtualNetwork,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_swift_virtual_network_connection_with_check {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_envelope: models::SwiftVirtualNetwork,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_swift_virtual_network {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_network_features {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::NetworkFeatures> {
let bytes = self.0.into_body().collect().await?;
let body: models::NetworkFeatures = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) view: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkFeatures/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.view
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::NetworkFeatures>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_trace_operation {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/operationresults/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod start_web_site_network_trace {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<String> {
let bytes = self.0.into_body().collect().await?;
let body: String = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<String>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod start_web_site_network_trace_operation {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/startOperation",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod stop_web_site_network_trace {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_network_traces {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTrace/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_trace_operation_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTraces/current/operationresults/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . operation_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_traces_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/networkTraces/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod generate_new_site_publishing_password {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/newpassword",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_perf_mon_counters {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PerfMonCounterCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PerfMonCounterCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only usages/metrics specified in the filter. Filter conforms to odata syntax. Example: $filter=(startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[Hour|Minute|Day]'."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::PerfMonCounterCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/perfcounters",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_php_error_log_flag {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SitePhpErrorLogFlag> {
let bytes = self.0.into_body().collect().await?;
let body: models::SitePhpErrorLogFlag = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/phplogging",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SitePhpErrorLogFlag>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_premier_add_ons {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_premier_add_on {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_premier_add_on {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) premier_add_on: models::PremierAddOn,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.premier_add_on)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_premier_add_on {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) premier_add_on: models::PremierAddOnPatchResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.premier_add_on)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_premier_add_on {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_private_access {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateAccess> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateAccess = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateAccess/virtualNetworks",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateAccess>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod put_private_access_vnet {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateAccess> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateAccess = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) access: models::PrivateAccess,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateAccess/virtualNetworks",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.access)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateAccess>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_endpoint_connection_list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnectionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateEndpointConnectionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PrivateEndpointConnectionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateEndpointConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod approve_or_reject_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) private_endpoint_wrapper: models::PrivateLinkConnectionApprovalRequestResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.private_endpoint_wrapper)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_private_endpoint_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_link_resources {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResourcesWrapper> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateLinkResourcesWrapper = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/privateLinkResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateLinkResourcesWrapper>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_processes {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_process {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_process {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_process_dump {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/dump",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_process_modules {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessModuleInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/modules",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_process_module {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) base_address: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/modules/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id,
&this.base_address
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessModuleInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_process_threads {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessThreadInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessThreadInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessThreadInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/processes/{}/threads",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_public_certificates {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificateCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificateCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PublicCertificateCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_public_certificate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) public_certificate_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PublicCertificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_public_certificate {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) public_certificate_name: String,
pub(crate) public_certificate: models::PublicCertificate,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.public_certificate)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PublicCertificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_public_certificate {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) public_certificate_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_publishing_profile_xml_with_secrets {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) publishing_profile_options: models::CsmPublishingProfileOptions,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/publishxml",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.publishing_profile_options)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod reset_production_slot_config {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/resetSlotConfig",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restart {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) soft_restart: Option<bool>,
pub(crate) synchronous: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify true to apply the configuration settings and restarts the app only if necessary. By default, the API always restarts and reprovisions the app."]
pub fn soft_restart(mut self, soft_restart: bool) -> Self {
self.soft_restart = Some(soft_restart);
self
}
#[doc = "Specify true to block until the app is restarted. By default, it is set to false, and the API responds immediately (asynchronous)."]
pub fn synchronous(mut self, synchronous: bool) -> Self {
self.synchronous = Some(synchronous);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/restart",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(soft_restart) = &this.soft_restart {
req.url_mut()
.query_pairs_mut()
.append_pair("softRestart", &soft_restart.to_string());
}
if let Some(synchronous) = &this.synchronous {
req.url_mut().query_pairs_mut().append_pair("synchronous", &synchronous.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_from_backup_blob {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::RestoreRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/restoreFromBackupBlob",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_from_deleted_app {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) restore_request: models::DeletedAppRestoreRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/restoreFromDeletedApp",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.restore_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_snapshot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) restore_request: models::SnapshotRestoreRequest,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/restoreSnapshot",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.restore_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_site_extensions {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteExtensionInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_extension {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteExtensionInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod install_site_extension {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteExtensionInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_site_extension {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_slots {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_envelope: models::Site,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Site> {
let bytes = self.0.into_body().collect().await?;
let body: models::Site = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_envelope: models::SitePatchResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Site>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) delete_metrics: Option<bool>,
pub(crate) delete_empty_server_farm: Option<bool>,
}
impl RequestBuilder {
#[doc = "If true, web app metrics are also deleted."]
pub fn delete_metrics(mut self, delete_metrics: bool) -> Self {
self.delete_metrics = Some(delete_metrics);
self
}
#[doc = "Specify false if you want to keep empty App Service plan. By default, empty App Service plan is deleted."]
pub fn delete_empty_server_farm(mut self, delete_empty_server_farm: bool) -> Self {
self.delete_empty_server_farm = Some(delete_empty_server_farm);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(delete_metrics) = &this.delete_metrics {
req.url_mut()
.query_pairs_mut()
.append_pair("deleteMetrics", &delete_metrics.to_string());
}
if let Some(delete_empty_server_farm) = &this.delete_empty_server_farm {
req.url_mut()
.query_pairs_mut()
.append_pair("deleteEmptyServerFarm", &delete_empty_server_farm.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod analyze_custom_hostname_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CustomHostnameAnalysisResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::CustomHostnameAnalysisResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) host_name: Option<String>,
}
impl RequestBuilder {
#[doc = "Custom hostname."]
pub fn host_name(mut self, host_name: impl Into<String>) -> Self {
self.host_name = Some(host_name.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/analyzeCustomHostname",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(host_name) = &this.host_name {
req.url_mut().query_pairs_mut().append_pair("hostName", host_name);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CustomHostnameAnalysisResult>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod apply_slot_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/applySlotConfig",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod backup_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::BackupRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_backups_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItemCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItemCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BackupItemCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_backup_status_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_backup_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_backup_status_secrets_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItem> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItem = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) request: models::BackupRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupItem>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod restore_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) backup_id: String,
pub(crate) request: models::RestoreRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/backups/{}/restore",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.backup_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_basic_publishing_credentials_policies_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublishingCredentialsPoliciesCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublishingCredentialsPoliciesCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PublishingCredentialsPoliciesCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/basicPublishingCredentialsPolicies" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_ftp_allowed_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/basicPublishingCredentialsPolicies/ftp" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_ftp_allowed_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) csm_publishing_access_policies_entity: models::CsmPublishingCredentialsPoliciesEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/basicPublishingCredentialsPolicies/ftp" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.csm_publishing_access_policies_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_scm_allowed_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/basicPublishingCredentialsPolicies/scm" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_scm_allowed_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmPublishingCredentialsPoliciesEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) csm_publishing_access_policies_entity: models::CsmPublishingCredentialsPoliciesEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/basicPublishingCredentialsPolicies/scm" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.csm_publishing_access_policies_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmPublishingCredentialsPoliciesEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_configurations_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResourceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResourceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteConfigResourceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod update_application_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_settings: models::StringDictionary,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/appsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.app_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_application_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/appsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_auth_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_auth_settings: models::SiteAuthSettings,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_auth_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings_v2_without_secrets_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettingsV2",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_auth_settings_v2_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_auth_settings_v2: models::SiteAuthSettingsV2,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettingsV2",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_auth_settings_v2)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_auth_settings_v2_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteAuthSettingsV2> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteAuthSettingsV2 = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/authsettingsV2/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteAuthSettingsV2>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_azure_storage_accounts_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AzureStoragePropertyDictionaryResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AzureStoragePropertyDictionaryResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) azure_storage_accounts: models::AzureStoragePropertyDictionaryResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/azurestorageaccounts",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.azure_storage_accounts)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::AzureStoragePropertyDictionaryResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_azure_storage_accounts_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::AzureStoragePropertyDictionaryResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::AzureStoragePropertyDictionaryResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/azurestorageaccounts/list" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::AzureStoragePropertyDictionaryResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_backup_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::BackupRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_backup_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_backup_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/backup/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::BackupRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_app_settings_key_vault_references_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ApiKvReferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/configreferences/appsettings" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_app_setting_key_vault_reference_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReference> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReference = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) app_setting_key: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/configreferences/appsettings/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . app_setting_key)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ApiKvReference>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_site_connection_string_key_vault_references_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ApiKvReferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/configreferences/connectionstrings" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_connection_string_key_vault_reference_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ApiKvReference> {
let bytes = self.0.into_body().collect().await?;
let body: models::ApiKvReference = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_string_key: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/configreferences/connectionstrings/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . connection_string_key)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ApiKvReference>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_connection_strings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ConnectionStringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::ConnectionStringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_strings: models::ConnectionStringDictionary,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/connectionstrings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_strings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ConnectionStringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_connection_strings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ConnectionStringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::ConnectionStringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/connectionstrings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ConnectionStringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_diagnostic_logs_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteLogsConfig> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteLogsConfig = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/logs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteLogsConfig>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_diagnostic_logs_config_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteLogsConfig> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteLogsConfig = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_logs_config: models::SiteLogsConfig,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/logs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_logs_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteLogsConfig>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_metadata_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) metadata: models::StringDictionary,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/metadata",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.metadata)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_metadata_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/metadata/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_publishing_credentials_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::User> {
let bytes = self.0.into_body().collect().await?;
let body: models::User = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/publishingcredentials/list" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::User>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_site_push_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PushSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::PushSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) push_settings: models::PushSettings,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/pushsettings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.push_settings)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PushSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_push_settings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PushSettings> {
let bytes = self.0.into_body().collect().await?;
let body: models::PushSettings = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/pushsettings/list",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PushSettings>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_config: models::SiteConfigResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_config: models::SiteConfigResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_config)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_configuration_snapshot_info_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigurationSnapshotInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigurationSnapshotInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteConfigurationSnapshotInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_configuration_snapshot_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteConfigResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteConfigResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) snapshot_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.snapshot_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteConfigResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod recover_site_configuration_snapshot_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) snapshot_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/config/web/snapshots/{}/recover" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . snapshot_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_web_site_container_logs_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/containerlogs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_container_logs_zip_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/containerlogs/zip/download",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_continuous_web_jobs_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContinuousWebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContinuousWebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ContinuousWebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_continuous_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ContinuousWebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::ContinuousWebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ContinuousWebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_continuous_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start_continuous_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod stop_continuous_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/continuouswebjobs/{}/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_slot_site_deployment_statuses_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmDeploymentStatusCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmDeploymentStatusCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::CsmDeploymentStatusCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deploymentStatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_slot_site_deployment_status_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmDeploymentStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmDeploymentStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) deployment_status_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deploymentStatus/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.deployment_status_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::CsmDeploymentStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_deployments_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::DeploymentCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::DeploymentCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::DeploymentCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_deployment_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_deployment_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) slot: String,
pub(crate) deployment: models::Deployment,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.deployment)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_deployment_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_deployment_log_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Deployment> {
let bytes = self.0.into_body().collect().await?;
let body: models::Deployment = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/deployments/{}/log",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Deployment>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod discover_backup_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RestoreRequest> {
let bytes = self.0.into_body().collect().await?;
let body: models::RestoreRequest = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::RestoreRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/discoverbackup",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RestoreRequest>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_domain_ownership_identifiers_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::IdentifierCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::IdentifierCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::IdentifierCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_domain_ownership_identifier_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_domain_ownership_identifier_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) domain_ownership_identifier: models::Identifier,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_domain_ownership_identifier_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::Identifier> {
let bytes = self.0.into_body().collect().await?;
let body: models::Identifier = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) domain_ownership_identifier: models::Identifier,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.domain_ownership_identifier)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::Identifier>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_domain_ownership_identifier_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) domain_ownership_identifier_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/domainOwnershipIdentifiers/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.domain_ownership_identifier_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_ms_deploy_status_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_ms_deploy_operation_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) ms_deploy: models::MsDeploy,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.ms_deploy)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_ms_deploy_log_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployLog> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployLog = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/extensions/MSDeploy/log",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployLog>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_functions_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelopeCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelopeCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::FunctionEnvelopeCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_functions_admin_token_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<String> {
let bytes = self.0.into_body().collect().await?;
let body: String = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/admin/token",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<String>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_instance_function_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelope> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelope = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionEnvelope>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_instance_function_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionEnvelope> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionEnvelope = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) slot: String,
pub(crate) function_envelope: models::FunctionEnvelope,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.function_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionEnvelope>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_instance_function_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_function_secret_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KeyInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::KeyInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) key_name: String,
pub(crate) slot: String,
pub(crate) key: models::KeyInfo,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}/keys/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KeyInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_function_secret_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) key_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}/keys/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_function_keys_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::StringDictionary> {
let bytes = self.0.into_body().collect().await?;
let body: models::StringDictionary = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}/listkeys",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::StringDictionary>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_function_secrets_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionSecrets> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionSecrets = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) function_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/functions/{}/listsecrets",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.function_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionSecrets>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_host_keys_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostKeys> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostKeys = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/host/default/listkeys",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostKeys>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_sync_status_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/host/default/listsyncstatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_functions_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/host/default/sync",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod create_or_update_host_secret_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::KeyInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::KeyInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) key_type: String,
pub(crate) key_name: String,
pub(crate) slot: String,
pub(crate) key: models::KeyInfo,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/host/default/{}/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.key_type,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::KeyInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_host_secret_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) key_type: String,
pub(crate) key_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/host/default/{}/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.key_type,
&this.key_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_host_name_bindings_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBindingCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBindingCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::HostNameBindingCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_host_name_binding_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBinding> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBinding = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) host_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostNameBinding>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_host_name_binding_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HostNameBinding> {
let bytes = self.0.into_body().collect().await?;
let body: models::HostNameBinding = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) host_name: String,
pub(crate) host_name_binding: models::HostNameBinding,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.host_name_binding)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HostNameBinding>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_host_name_binding_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) host_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hostNameBindings/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.host_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_hybrid_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_hybrid_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) connection_envelope: models::HybridConnection,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_hybrid_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) connection_envelope: models::HybridConnection,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_hybrid_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) namespace_name: String,
pub(crate) relay_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionNamespaces/{}/relays/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . namespace_name , & this . relay_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_hybrid_connections_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::HybridConnection> {
let bytes = self.0.into_body().collect().await?;
let body: models::HybridConnection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridConnectionRelays",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::HybridConnection>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_relay_service_connections_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_relay_service_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_relay_service_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) connection_envelope: models::RelayServiceConnectionEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_relay_service_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RelayServiceConnectionEntity> {
let bytes = self.0.into_body().collect().await?;
let body: models::RelayServiceConnectionEntity = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) connection_envelope: models::RelayServiceConnectionEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RelayServiceConnectionEntity>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_relay_service_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) entity_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/hybridconnection/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.entity_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_instance_identifiers_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebAppInstanceStatusCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebAppInstanceStatusCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebAppInstanceStatusCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_info_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebSiteInstanceStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebSiteInstanceStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) instance_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.instance_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WebSiteInstanceStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_instance_ms_deploy_status_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_instance_ms_deploy_operation_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) ms_deploy: models::MsDeploy,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.ms_deploy)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_instance_ms_deploy_log_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MsDeployLog> {
let bytes = self.0.into_body().collect().await?;
let body: models::MsDeployLog = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/extensions/MSDeploy/log" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MsDeployLog>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_processes_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.instance_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_process_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.instance_id,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_instance_process_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.instance_id,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_instance_process_dump_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/dump" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id , & this . process_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_process_modules_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessModuleInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/modules" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id , & this . process_id)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_instance_process_module_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) base_address: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/modules/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id , & this . process_id , & this . base_address)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessModuleInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_instance_process_threads_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessThreadInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessThreadInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) instance_id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessThreadInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/instances/{}/processes/{}/threads" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . instance_id , & this . process_id)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod is_cloneable_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteCloneability> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteCloneability = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/iscloneable",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteCloneability>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_site_backups_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::BackupItemCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::BackupItemCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::BackupItemCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/listbackups",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_sync_function_triggers_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::FunctionSecrets> {
let bytes = self.0.into_body().collect().await?;
let body: models::FunctionSecrets = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/listsyncfunctiontriggerstatus",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::FunctionSecrets>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_migrate_my_sql_status_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::MigrateMySqlStatus> {
let bytes = self.0.into_body().collect().await?;
let body: models::MigrateMySqlStatus = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/migratemysql/status",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::MigrateMySqlStatus>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_swift_virtual_network_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_swift_virtual_network_connection_with_check_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_envelope: models::SwiftVirtualNetwork,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_swift_virtual_network_connection_with_check_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SwiftVirtualNetwork> {
let bytes = self.0.into_body().collect().await?;
let body: models::SwiftVirtualNetwork = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) connection_envelope: models::SwiftVirtualNetwork,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SwiftVirtualNetwork>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_swift_virtual_network_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkConfig/virtualNetwork",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_network_features_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::NetworkFeatures> {
let bytes = self.0.into_body().collect().await?;
let body: models::NetworkFeatures = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) view: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkFeatures/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.view
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::NetworkFeatures>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_trace_operation_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/operationresults/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . operation_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod start_web_site_network_trace_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<String> {
let bytes = self.0.into_body().collect().await?;
let body: String = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<String>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod start_web_site_network_trace_operation_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/startOperation",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod stop_web_site_network_trace_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_network_traces_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTrace/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_trace_operation_slot_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTraces/current/operationresults/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . operation_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_network_traces_slot_v2 {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) operation_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/networkTraces/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.operation_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod generate_new_site_publishing_password_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/newpassword",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_perf_mon_counters_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PerfMonCounterCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PerfMonCounterCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only usages/metrics specified in the filter. Filter conforms to odata syntax. Example: $filter=(startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[Hour|Minute|Day]'."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::PerfMonCounterCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/perfcounters",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_php_error_log_flag_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SitePhpErrorLogFlag> {
let bytes = self.0.into_body().collect().await?;
let body: models::SitePhpErrorLogFlag = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/phplogging",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SitePhpErrorLogFlag>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_premier_add_ons_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_premier_add_on_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod add_premier_add_on_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) premier_add_on: models::PremierAddOn,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.premier_add_on)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_premier_add_on_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PremierAddOn> {
let bytes = self.0.into_body().collect().await?;
let body: models::PremierAddOn = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) premier_add_on: models::PremierAddOnPatchResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.premier_add_on)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PremierAddOn>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_premier_add_on_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) premier_add_on_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/premieraddons/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.premier_add_on_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_private_access_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateAccess> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateAccess = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateAccess/virtualNetworks",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateAccess>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod put_private_access_vnet_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateAccess> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateAccess = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) access: models::PrivateAccess,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateAccess/virtualNetworks",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.access)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateAccess>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_endpoint_connection_list_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateEndpointConnectionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateEndpointConnectionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PrivateEndpointConnectionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateEndpointConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_private_endpoint_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod approve_or_reject_private_endpoint_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RemotePrivateEndpointConnectionArmResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::RemotePrivateEndpointConnectionArmResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) private_endpoint_wrapper: models::PrivateLinkConnectionApprovalRequestResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.private_endpoint_wrapper)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::RemotePrivateEndpointConnectionArmResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_private_endpoint_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<serde_json::Value> {
let bytes = self.0.into_body().collect().await?;
let body: serde_json::Value = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) private_endpoint_connection_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateEndpointConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.private_endpoint_connection_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<serde_json::Value>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_private_link_resources_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PrivateLinkResourcesWrapper> {
let bytes = self.0.into_body().collect().await?;
let body: models::PrivateLinkResourcesWrapper = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/privateLinkResources",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PrivateLinkResourcesWrapper>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_processes_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_process_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_process_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_process_dump_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/dump",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_process_modules_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessModuleInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/modules",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_process_module_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessModuleInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessModuleInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) base_address: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/modules/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id,
&this.base_address
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::ProcessModuleInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_process_threads_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ProcessThreadInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::ProcessThreadInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) process_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ProcessThreadInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/processes/{}/threads",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.process_id
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_public_certificates_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificateCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificateCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::PublicCertificateCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_public_certificate_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) public_certificate_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PublicCertificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_public_certificate_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::PublicCertificate> {
let bytes = self.0.into_body().collect().await?;
let body: models::PublicCertificate = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) public_certificate_name: String,
pub(crate) public_certificate: models::PublicCertificate,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.public_certificate)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::PublicCertificate>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_public_certificate_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) public_certificate_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publicCertificates/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.public_certificate_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_publishing_profile_xml_with_secrets_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<bytes::Bytes> {
let bytes = self.0.into_body().collect().await?;
let body = bytes;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) publishing_profile_options: models::CsmPublishingProfileOptions,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/publishxml",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.publishing_profile_options)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<bytes::Bytes>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod reset_slot_configuration_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/resetSlotConfig",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restart_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) soft_restart: Option<bool>,
pub(crate) synchronous: Option<bool>,
}
impl RequestBuilder {
#[doc = "Specify true to apply the configuration settings and restarts the app only if necessary. By default, the API always restarts and reprovisions the app."]
pub fn soft_restart(mut self, soft_restart: bool) -> Self {
self.soft_restart = Some(soft_restart);
self
}
#[doc = "Specify true to block until the app is restarted. By default, it is set to false, and the API responds immediately (asynchronous)."]
pub fn synchronous(mut self, synchronous: bool) -> Self {
self.synchronous = Some(synchronous);
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/restart",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(soft_restart) = &this.soft_restart {
req.url_mut()
.query_pairs_mut()
.append_pair("softRestart", &soft_restart.to_string());
}
if let Some(synchronous) = &this.synchronous {
req.url_mut().query_pairs_mut().append_pair("synchronous", &synchronous.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_from_backup_blob_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) request: models::RestoreRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/restoreFromBackupBlob",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_from_deleted_app_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) restore_request: models::DeletedAppRestoreRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/restoreFromDeletedApp",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.restore_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod restore_snapshot_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) restore_request: models::SnapshotRestoreRequest,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/restoreSnapshot",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.restore_request)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_site_extensions_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfoCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfoCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SiteExtensionInfoCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_site_extension_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteExtensionInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod install_site_extension_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteExtensionInfo> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteExtensionInfo = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteExtensionInfo>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_site_extension_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_extension_id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/siteextensions/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.site_extension_id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_slot_differences_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SlotDifferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SlotDifferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SlotDifferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/slotsdiffs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod swap_slot_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/slotsswap",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_snapshots_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SnapshotCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SnapshotCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SnapshotCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/snapshots",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_snapshots_from_dr_secondary_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SnapshotCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SnapshotCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SnapshotCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/snapshotsdr",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_source_control_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_source_control_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_source_control: models::SiteSourceControl,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_source_control)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_source_control_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_source_control: models::SiteSourceControl,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_source_control)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_source_control_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) additional_flags: Option<String>,
}
impl RequestBuilder {
pub fn additional_flags(mut self, additional_flags: impl Into<String>) -> Self {
self.additional_flags = Some(additional_flags.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(additional_flags) = &this.additional_flags {
req.url_mut().query_pairs_mut().append_pair("additionalFlags", additional_flags);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start_network_trace_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/startNetworkTrace",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod stop_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod stop_network_trace_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/stopNetworkTrace",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_repository_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/sync",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_function_triggers_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/syncfunctiontriggers",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_triggered_web_jobs_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredWebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredWebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TriggeredWebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_triggered_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredWebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredWebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TriggeredWebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_triggered_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_triggered_web_job_history_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredJobHistoryCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredJobHistoryCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TriggeredJobHistoryCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/history",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_triggered_web_job_history_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredJobHistory> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredJobHistory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) id: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/history/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . web_job_name , & this . id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TriggeredJobHistory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod run_triggered_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/triggeredwebjobs/{}/run",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_usages_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmUsageQuotaCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmUsageQuotaCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only information specified in the filter (using OData syntax). For example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[Hour|Minute|Day]'."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CsmUsageQuotaCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/usages",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_vnet_connections_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::VnetInfoResource>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::VnetInfoResource> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::VnetInfoResource>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_vnet_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_vnet_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) connection_envelope: models::VnetInfoResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) connection_envelope: models::VnetInfoResource,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_vnet_connection_slot {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_vnet_connection_gateway_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_vnet_connection_gateway_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) connection_envelope: models::VnetGateway,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_connection_gateway_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) connection_envelope: models::VnetGateway,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . slot , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_web_jobs_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/webjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_web_job_slot {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) slot: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slots/{}/webjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.slot,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_slot_differences_from_production {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SlotDifferenceCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SlotDifferenceCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SlotDifferenceCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slotsdiffs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod swap_slot_with_production {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) slot_swap_entity: models::CsmSlotEntity,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/slotsswap",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.slot_swap_entity)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_snapshots {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SnapshotCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SnapshotCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SnapshotCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/snapshots",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_snapshots_from_dr_secondary {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SnapshotCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::SnapshotCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::SnapshotCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/snapshotsdr",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_source_control {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_source_control {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_source_control: models::SiteSourceControl,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_source_control)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_source_control {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::SiteSourceControl> {
let bytes = self.0.into_body().collect().await?;
let body: models::SiteSourceControl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) site_source_control: models::SiteSourceControl,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.site_source_control)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::SiteSourceControl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_source_control {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) additional_flags: Option<String>,
}
impl RequestBuilder {
pub fn additional_flags(mut self, additional_flags: impl Into<String>) -> Self {
self.additional_flags = Some(additional_flags.into());
self
}
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sourcecontrols/web",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(additional_flags) = &this.additional_flags {
req.url_mut().query_pairs_mut().append_pair("additionalFlags", additional_flags);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/start",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod start_network_trace {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::NetworkTrace>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::NetworkTrace> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) duration_in_seconds: Option<i32>,
pub(crate) max_frame_length: Option<i32>,
pub(crate) sas_url: Option<String>,
}
impl RequestBuilder {
#[doc = "The duration to keep capturing in seconds."]
pub fn duration_in_seconds(mut self, duration_in_seconds: i32) -> Self {
self.duration_in_seconds = Some(duration_in_seconds);
self
}
#[doc = "The maximum frame length in bytes (Optional)."]
pub fn max_frame_length(mut self, max_frame_length: i32) -> Self {
self.max_frame_length = Some(max_frame_length);
self
}
#[doc = "The Blob URL to store capture file."]
pub fn sas_url(mut self, sas_url: impl Into<String>) -> Self {
self.sas_url = Some(sas_url.into());
self
}
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/startNetworkTrace",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(duration_in_seconds) = &this.duration_in_seconds {
req.url_mut()
.query_pairs_mut()
.append_pair("durationInSeconds", &duration_in_seconds.to_string());
}
if let Some(max_frame_length) = &this.max_frame_length {
req.url_mut()
.query_pairs_mut()
.append_pair("maxFrameLength", &max_frame_length.to_string());
}
if let Some(sas_url) = &this.sas_url {
req.url_mut().query_pairs_mut().append_pair("sasUrl", sas_url);
}
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::NetworkTrace>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod stop {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/stop",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod stop_network_trace {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/stopNetworkTrace",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_repository {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/sync",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod sync_function_triggers {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/syncfunctiontriggers",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_triggered_web_jobs {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredWebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredWebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TriggeredWebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_triggered_web_job {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredWebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredWebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TriggeredWebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_triggered_web_job {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_triggered_web_job_history {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredJobHistoryCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredJobHistoryCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::TriggeredJobHistoryCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/history",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_triggered_web_job_history {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::TriggeredJobHistory> {
let bytes = self.0.into_body().collect().await?;
let body: models::TriggeredJobHistory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) id: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/history/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name,
&this.id
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::TriggeredJobHistory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod run_triggered_web_job {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/triggeredwebjobs/{}/run",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod list_usages {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::CsmUsageQuotaCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::CsmUsageQuotaCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "Return only information specified in the filter (using OData syntax). For example: $filter=(name.value eq 'Metric1' or name.value eq 'Metric2') and startTime eq 2014-01-01T00:00:00Z and endTime eq 2014-12-31T23:59:59Z and timeGrain eq duration'[Hour|Minute|Day]'."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::CsmUsageQuotaCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/usages",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod list_vnet_connections {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<Vec<models::VnetInfoResource>> {
let bytes = self.0.into_body().collect().await?;
let body: Vec<models::VnetInfoResource> = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<Vec<models::VnetInfoResource>>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod get_vnet_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_vnet_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) connection_envelope: models::VnetInfoResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_connection {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetInfoResource> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetInfoResource = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) connection_envelope: models::VnetInfoResource,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetInfoResource>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod delete_vnet_connection {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.vnet_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Delete);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_vnet_connection_gateway {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod create_or_update_vnet_connection_gateway {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) connection_envelope: models::VnetGateway,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Put);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod update_vnet_connection_gateway {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::VnetGateway> {
let bytes = self.0.into_body().collect().await?;
let body: models::VnetGateway = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) vnet_name: String,
pub(crate) gateway_name: String,
pub(crate) connection_envelope: models::VnetGateway,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/virtualNetworkConnections/{}/gateways/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . vnet_name , & this . gateway_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Patch);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.connection_envelope)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::VnetGateway>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_web_jobs {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebJobCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebJobCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::WebJobCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/webjobs",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name
))?;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get_web_job {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WebJob> {
let bytes = self.0.into_body().collect().await?;
let body: models::WebJob = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) web_job_name: String,
pub(crate) subscription_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core::Url::parse(&format!(
"{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/webjobs/{}",
this.client.endpoint(),
&this.subscription_id,
&this.resource_group_name,
&this.name,
&this.web_job_name
))?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WebJob>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod workflows {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Regenerates the callback URL access key for request triggers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `key_type`: The access key type."]
pub fn regenerate_access_key(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
key_type: impl Into<models::RegenerateActionParameter>,
) -> regenerate_access_key::RequestBuilder {
regenerate_access_key::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
key_type: key_type.into(),
}
}
#[doc = "Validates the workflow definition."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `validate`: The workflow."]
pub fn validate(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
validate: impl Into<models::Workflow>,
) -> validate::RequestBuilder {
validate::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
validate: validate.into(),
}
}
}
pub mod regenerate_access_key {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) key_type: models::RegenerateActionParameter,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/regenerateAccessKey" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.key_type)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod validate {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) validate: models::Workflow,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/validate" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
req.insert_header("content-type", "application/json");
let req_body = azure_core::to_json(&this.validate)?;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod workflow_runs {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a list of workflow runs."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
top: None,
filter: None,
}
}
#[doc = "Gets a workflow run."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
}
}
#[doc = "Cancels a workflow run."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
pub fn cancel(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
) -> cancel::RequestBuilder {
cancel::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) top: Option<i32>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "The number of items to be included in the result."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The filter to apply on the operation. Options for filters include: Status, StartTime, and ClientTrackingId."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WorkflowRunListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRun> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRun = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowRun>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod cancel {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/cancel" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod workflow_run_actions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a list of workflow run actions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
top: None,
filter: None,
}
}
#[doc = "Gets a workflow run action."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
}
}
#[doc = "Lists a workflow run expression trace."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
pub fn list_expression_traces(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
) -> list_expression_traces::RequestBuilder {
list_expression_traces::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunActionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunActionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) top: Option<i32>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "The number of items to be included in the result."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The filter to apply on the operation. Options for filters include: Status."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WorkflowRunActionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunAction> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunAction = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowRunAction>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_expression_traces {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ExpressionTraces> {
let bytes = self.0.into_body().collect().await?;
let body: models::ExpressionTraces = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ExpressionTraces, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/listExpressionTraces" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod workflow_run_action_repetitions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Get all of a workflow run action repetitions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
}
}
#[doc = "Get a workflow run action repetition."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
#[doc = "* `repetition_name`: The workflow repetition."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
repetition_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
repetition_name: repetition_name.into(),
}
}
#[doc = "Lists a workflow run expression trace."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
#[doc = "* `repetition_name`: The workflow repetition."]
pub fn list_expression_traces(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
repetition_name: impl Into<String>,
) -> list_expression_traces::RequestBuilder {
list_expression_traces::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
repetition_name: repetition_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunActionRepetitionDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunActionRepetitionDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
}
impl RequestBuilder {
pub fn into_stream(
self,
) -> azure_core::Pageable<models::WorkflowRunActionRepetitionDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/repetitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunActionRepetitionDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunActionRepetitionDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
pub(crate) repetition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/repetitions/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name , & this . repetition_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowRunActionRepetitionDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_expression_traces {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::ExpressionTraces> {
let bytes = self.0.into_body().collect().await?;
let body: models::ExpressionTraces = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
pub(crate) repetition_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::ExpressionTraces, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/repetitions/{}/listExpressionTraces" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name , & this . repetition_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
}
pub mod workflow_run_action_repetitions_request_histories {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List a workflow run repetition request history."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
#[doc = "* `repetition_name`: The workflow repetition."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
repetition_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
repetition_name: repetition_name.into(),
}
}
#[doc = "Gets a workflow run repetition request history."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
#[doc = "* `repetition_name`: The workflow repetition."]
#[doc = "* `request_history_name`: The request history name."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
repetition_name: impl Into<String>,
request_history_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
repetition_name: repetition_name.into(),
request_history_name: request_history_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RequestHistoryListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::RequestHistoryListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
pub(crate) repetition_name: String,
}
impl RequestBuilder {
pub fn into_stream(self) -> azure_core::Pageable<models::RequestHistoryListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/repetitions/{}/requestHistories" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name , & this . repetition_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::RequestHistory> {
let bytes = self.0.into_body().collect().await?;
let body: models::RequestHistory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
pub(crate) repetition_name: String,
pub(crate) request_history_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/repetitions/{}/requestHistories/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name , & this . repetition_name , & this . request_history_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::RequestHistory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod workflow_run_action_scope_repetitions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "List the workflow run action scoped repetitions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
}
}
#[doc = "Get a workflow run action scoped repetition."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `run_name`: The workflow run name."]
#[doc = "* `action_name`: The workflow action name."]
#[doc = "* `repetition_name`: The workflow repetition."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
run_name: impl Into<String>,
action_name: impl Into<String>,
repetition_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
run_name: run_name.into(),
action_name: action_name.into(),
repetition_name: repetition_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunActionRepetitionDefinitionCollection> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunActionRepetitionDefinitionCollection = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
}
impl RequestBuilder {
pub fn into_stream(
self,
) -> azure_core::Pageable<models::WorkflowRunActionRepetitionDefinitionCollection, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/scopeRepetitions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowRunActionRepetitionDefinition> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowRunActionRepetitionDefinition = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) run_name: String,
pub(crate) action_name: String,
pub(crate) repetition_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/runs/{}/actions/{}/scopeRepetitions/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . run_name , & this . action_name , & this . repetition_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(
self,
) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowRunActionRepetitionDefinition>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod workflow_triggers {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a list of workflow triggers."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
top: None,
filter: None,
}
}
#[doc = "Gets a workflow trigger."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
}
}
#[doc = "Get the callback URL for a workflow trigger."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
pub fn list_callback_url(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
) -> list_callback_url::RequestBuilder {
list_callback_url::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
}
}
#[doc = "Runs a workflow trigger."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
pub fn run(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
) -> run::RequestBuilder {
run::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
}
}
#[doc = "Get the trigger schema as JSON."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
pub fn get_schema_json(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
) -> get_schema_json::RequestBuilder {
get_schema_json::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowTriggerListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowTriggerListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) top: Option<i32>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "The number of items to be included in the result."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The filter to apply on the operation."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WorkflowTriggerListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowTrigger> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowTrigger = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowTrigger>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod list_callback_url {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowTriggerCallbackUrl> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowTriggerCallbackUrl = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/listCallbackUrl" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowTriggerCallbackUrl>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod run {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/run" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
pub mod get_schema_json {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::JsonSchema> {
let bytes = self.0.into_body().collect().await?;
let body: models::JsonSchema = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/schemas/json" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::JsonSchema>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}
pub mod workflow_trigger_histories {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a list of workflow trigger histories."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
top: None,
filter: None,
}
}
#[doc = "Gets a workflow trigger history."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
#[doc = "* `history_name`: The workflow trigger history name. Corresponds to the run name for triggers that resulted in a run."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
history_name: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
history_name: history_name.into(),
}
}
#[doc = "Resubmits a workflow run based on the trigger history."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `trigger_name`: The workflow trigger name."]
#[doc = "* `history_name`: The workflow trigger history name. Corresponds to the run name for triggers that resulted in a run."]
pub fn resubmit(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
trigger_name: impl Into<String>,
history_name: impl Into<String>,
) -> resubmit::RequestBuilder {
resubmit::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
trigger_name: trigger_name.into(),
history_name: history_name.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowTriggerHistoryListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowTriggerHistoryListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
pub(crate) top: Option<i32>,
pub(crate) filter: Option<String>,
}
impl RequestBuilder {
#[doc = "The number of items to be included in the result."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
#[doc = "The filter to apply on the operation. Options for filters include: Status, StartTime, and ClientTrackingId."]
pub fn filter(mut self, filter: impl Into<String>) -> Self {
self.filter = Some(filter.into());
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WorkflowTriggerHistoryListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/histories" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
if let Some(filter) = &this.filter {
req.url_mut().query_pairs_mut().append_pair("$filter", filter);
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowTriggerHistory> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowTriggerHistory = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
pub(crate) history_name: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/histories/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name , & this . history_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowTriggerHistory>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
pub mod resubmit {
use super::models;
pub struct Response(azure_core::Response);
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) trigger_name: String,
pub(crate) history_name: String,
}
impl RequestBuilder {
#[doc = "only the first response will be fetched as long running operations are not supported yet"]
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/triggers/{}/histories/{}/resubmit" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . trigger_name , & this . history_name)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Post);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.insert_header(azure_core::headers::CONTENT_LENGTH, "0");
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
}
}
}
pub mod workflow_versions {
use super::models;
pub struct Client(pub(crate) super::Client);
impl Client {
#[doc = "Gets a list of workflow versions."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
pub fn list(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
) -> list::RequestBuilder {
list::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
top: None,
}
}
#[doc = "Gets a workflow version."]
#[doc = ""]
#[doc = "Arguments:"]
#[doc = "* `subscription_id`: Your Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000)."]
#[doc = "* `resource_group_name`: Name of the resource group to which the resource belongs."]
#[doc = "* `name`: Site name."]
#[doc = "* `workflow_name`: The workflow name."]
#[doc = "* `version_id`: The workflow versionId."]
pub fn get(
&self,
subscription_id: impl Into<String>,
resource_group_name: impl Into<String>,
name: impl Into<String>,
workflow_name: impl Into<String>,
version_id: impl Into<String>,
) -> get::RequestBuilder {
get::RequestBuilder {
client: self.0.clone(),
subscription_id: subscription_id.into(),
resource_group_name: resource_group_name.into(),
name: name.into(),
workflow_name: workflow_name.into(),
version_id: version_id.into(),
}
}
}
pub mod list {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowVersionListResult> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowVersionListResult = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) top: Option<i32>,
}
impl RequestBuilder {
#[doc = "The number of items to be included in the result."]
pub fn top(mut self, top: i32) -> Self {
self.top = Some(top);
self
}
pub fn into_stream(self) -> azure_core::Pageable<models::WorkflowVersionListResult, azure_core::error::Error> {
let make_request = move |continuation: Option<String>| {
let this = self.clone();
async move {
let mut url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/versions" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name)) ? ;
let rsp = match continuation {
Some(value) => {
url.set_path("");
url = url.join(&value)?;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
let has_api_version_already =
req.url_mut().query_pairs().any(|(k, _)| k == azure_core::query_param::API_VERSION);
if !has_api_version_already {
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
None => {
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
if let Some(top) = &this.top {
req.url_mut().query_pairs_mut().append_pair("$top", &top.to_string());
}
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
this.client.send(&mut req).await?
}
};
let rsp = match rsp.status() {
azure_core::StatusCode::Ok => Ok(Response(rsp)),
status_code => Err(azure_core::error::Error::from(azure_core::error::ErrorKind::HttpResponse {
status: status_code,
error_code: None,
})),
};
rsp?.into_body().await
}
};
azure_core::Pageable::new(make_request)
}
}
}
pub mod get {
use super::models;
pub struct Response(azure_core::Response);
impl Response {
pub async fn into_body(self) -> azure_core::Result<models::WorkflowVersion> {
let bytes = self.0.into_body().collect().await?;
let body: models::WorkflowVersion = serde_json::from_slice(&bytes)?;
Ok(body)
}
pub fn into_raw_response(self) -> azure_core::Response {
self.0
}
pub fn as_raw_response(&self) -> &azure_core::Response {
&self.0
}
}
impl From<Response> for azure_core::Response {
fn from(rsp: Response) -> Self {
rsp.into_raw_response()
}
}
impl AsRef<azure_core::Response> for Response {
fn as_ref(&self) -> &azure_core::Response {
self.as_raw_response()
}
}
#[derive(Clone)]
pub struct RequestBuilder {
pub(crate) client: super::super::Client,
pub(crate) subscription_id: String,
pub(crate) resource_group_name: String,
pub(crate) name: String,
pub(crate) workflow_name: String,
pub(crate) version_id: String,
}
impl RequestBuilder {
#[doc = "Send the request and returns the response."]
pub fn send(self) -> futures::future::BoxFuture<'static, azure_core::Result<Response>> {
Box::pin({
let this = self.clone();
async move {
let url = azure_core :: Url :: parse (& format ! ("{}/subscriptions/{}/resourceGroups/{}/providers/Microsoft.Web/sites/{}/hostruntime/runtime/webhooks/workflow/api/management/workflows/{}/versions/{}" , this . client . endpoint () , & this . subscription_id , & this . resource_group_name , & this . name , & this . workflow_name , & this . version_id)) ? ;
let mut req = azure_core::Request::new(url, azure_core::Method::Get);
let credential = this.client.token_credential();
let token_response = credential.get_token(&this.client.scopes().join(" ")).await?;
req.insert_header(
azure_core::headers::AUTHORIZATION,
format!("Bearer {}", token_response.token.secret()),
);
req.url_mut()
.query_pairs_mut()
.append_pair(azure_core::query_param::API_VERSION, "2022-03-01");
let req_body = azure_core::EMPTY_BODY;
req.set_body(req_body);
Ok(Response(this.client.send(&mut req).await?))
}
})
}
#[doc = "Send the request and return the response body."]
pub fn into_future(self) -> futures::future::BoxFuture<'static, azure_core::Result<models::WorkflowVersion>> {
Box::pin(async move { self.send().await?.into_body().await })
}
}
}
}