azure_storage_queue 0.5.0

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
//
// Code generated by Microsoft (R) Rust Code Generator. DO NOT EDIT.

use crate::generated::models::{
    ListQueuesResponse, QueueServiceClientGetPropertiesOptions,
    QueueServiceClientGetStatisticsOptions, QueueServiceClientListQueuesOptions,
    QueueServiceClientSetPropertiesOptions, QueueServiceProperties, QueueServiceStats,
};
use azure_core::{
    error::CheckSuccessOptions,
    fmt::SafeDebug,
    http::{
        pager::{PagerContinuation, PagerResult, PagerState},
        ClientOptions, Method, NoFormat, Pager, Pipeline, PipelineSendOptions, RawResponse,
        Request, RequestContent, Response, Url, UrlExt, XmlFormat,
    },
    tracing, xml, Result,
};

#[tracing::client]
pub struct QueueServiceClient {
    pub(crate) endpoint: Url,
    pub(crate) pipeline: Pipeline,
    pub(crate) version: String,
}

/// Options used when creating a `QueueServiceClient`
#[derive(Clone, SafeDebug)]
pub struct QueueServiceClientOptions {
    /// Allows customization of the client.
    pub client_options: ClientOptions,
    /// Specifies the version of the operation to use for this request.
    pub version: String,
}

impl QueueServiceClient {
    /// Returns the Url associated with this client.
    pub fn endpoint(&self) -> &Url {
        &self.endpoint
    }

    /// Retrieves properties of a storage account's Queue service, including properties for Storage Analytics and
    /// CORS (Cross-Origin Resource Sharing) rules.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Queues.QueueServiceClient.getProperties")]
    pub async fn get_properties(
        &self,
        options: Option<QueueServiceClientGetPropertiesOptions<'_>>,
    ) -> Result<Response<QueueServiceProperties, XmlFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder
            .append_pair("comp", "properties")
            .append_pair("restype", "service");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Get);
        request.insert_header("accept", "application/xml");
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Retrieves statistics related to replication for the Queue service. It is only available on the secondary
    /// location endpoint when read-access geo-redundant replication is enabled for the storage account.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Queues.QueueServiceClient.getStatistics")]
    pub async fn get_statistics(
        &self,
        options: Option<QueueServiceClientGetStatisticsOptions<'_>>,
    ) -> Result<Response<QueueServiceStats, XmlFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder
            .append_pair("comp", "stats")
            .append_pair("restype", "service");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Get);
        request.insert_header("accept", "application/xml");
        request.insert_header("x-ms-version", &self.version);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[200],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }

    /// Returns a list of queues.
    ///
    /// # Arguments
    ///
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Queues.QueueServiceClient.getQueues")]
    pub fn list_queues(
        &self,
        options: Option<QueueServiceClientListQueuesOptions<'_>>,
    ) -> Result<Pager<ListQueuesResponse, XmlFormat>> {
        let options = options.unwrap_or_default().into_owned();
        let pipeline = self.pipeline.clone();
        let mut first_url = self.endpoint.clone();
        let mut query_builder = first_url.query_builder();
        query_builder.append_pair("comp", "list");
        if let Some(include) = options.include.as_ref() {
            query_builder.set_pair(
                "include",
                include
                    .iter()
                    .map(|i| i.to_string())
                    .collect::<Vec<String>>()
                    .join(","),
            );
        }
        if let Some(marker) = options.marker.as_ref() {
            query_builder.set_pair("marker", marker);
        }
        if let Some(maxresults) = options.maxresults {
            query_builder.set_pair("maxresults", maxresults.to_string());
        }
        if let Some(prefix) = options.prefix.as_ref() {
            query_builder.set_pair("prefix", prefix);
        }
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let version = self.version.clone();
        Ok(Pager::new(
            move |marker: PagerState, pager_options| {
                let mut url = first_url.clone();
                if let PagerState::More(marker) = marker {
                    let mut query_builder = url.query_builder();
                    query_builder.set_pair("marker", marker.as_ref());
                    query_builder.build();
                }
                let mut request = Request::new(url, Method::Get);
                request.insert_header("accept", "application/xml");
                request.insert_header("x-ms-version", &version);
                let pipeline = pipeline.clone();
                Box::pin(async move {
                    let rsp = pipeline
                        .send(
                            &pager_options.context,
                            &mut request,
                            Some(PipelineSendOptions {
                                check_success: CheckSuccessOptions {
                                    success_codes: &[200],
                                },
                                ..Default::default()
                            }),
                        )
                        .await?;
                    let (status, headers, body) = rsp.deconstruct();
                    let res: ListQueuesResponse = xml::from_xml(&body)?;
                    let rsp = RawResponse::from_bytes(status, headers, body).into();
                    Ok(match res.next_marker {
                        Some(next_marker) if !next_marker.is_empty() => PagerResult::More {
                            response: rsp,
                            continuation: PagerContinuation::Token(next_marker),
                        },
                        _ => PagerResult::Done { response: rsp },
                    })
                })
            },
            Some(options.method_options),
        ))
    }

    /// Sets properties for a storage account's Queue service endpoint, including properties for Storage Analytics
    /// and CORS (Cross-Origin Resource Sharing) rules.
    ///
    /// # Arguments
    ///
    /// * `queue_service_properties` - The storage service properties to set.
    /// * `options` - Optional parameters for the request.
    #[tracing::function("Storage.Queues.QueueServiceClient.setProperties")]
    pub async fn set_properties(
        &self,
        queue_service_properties: RequestContent<QueueServiceProperties, XmlFormat>,
        options: Option<QueueServiceClientSetPropertiesOptions<'_>>,
    ) -> Result<Response<(), NoFormat>> {
        let options = options.unwrap_or_default();
        let ctx = options.method_options.context.to_borrowed();
        let mut url = self.endpoint.clone();
        let mut query_builder = url.query_builder();
        query_builder
            .append_pair("comp", "properties")
            .append_pair("restype", "service");
        if let Some(timeout) = options.timeout {
            query_builder.set_pair("timeout", timeout.to_string());
        }
        query_builder.build();
        let mut request = Request::new(url, Method::Put);
        request.insert_header("content-type", "application/xml");
        request.insert_header("x-ms-version", &self.version);
        request.set_body(queue_service_properties);
        let rsp = self
            .pipeline
            .send(
                &ctx,
                &mut request,
                Some(PipelineSendOptions {
                    check_success: CheckSuccessOptions {
                        success_codes: &[202],
                    },
                    ..Default::default()
                }),
            )
            .await?;
        Ok(rsp.into())
    }
}

/// Default value for [`QueueServiceClientOptions::version`].
pub(crate) const DEFAULT_VERSION: &str = "2026-04-06";

impl Default for QueueServiceClientOptions {
    fn default() -> Self {
        Self {
            client_options: ClientOptions::default(),
            version: String::from(DEFAULT_VERSION),
        }
    }
}