use crate::prelude::*;
use crate::responses::ListAttachmentsResponse;
use crate::DocumentClientRequired;
use crate::{DocumentClient, ResourceType};
use azure_sdk_core::errors::{check_status_extract_headers_and_body, AzureError};
use azure_sdk_core::prelude::*;
use futures::stream::{unfold, Stream};
use hyper::StatusCode;
use std::convert::TryInto;
#[derive(Debug)]
pub struct ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
document_client: &'a dyn DocumentClient<C, D, COLL>,
if_match_condition: Option<IfMatchCondition<'b>>,
user_agent: Option<&'b str>,
activity_id: Option<&'b str>,
consistency_level: Option<ConsistencyLevel<'b>>,
continuation: Option<&'b str>,
max_item_count: i32,
a_im: bool,
}
impl<'a, 'b, C, D, COLL> ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
pub(crate) fn new(
document_client: &'a dyn DocumentClient<C, D, COLL>,
) -> ListAttachmentsBuilder<'a, 'b, C, D, COLL> {
ListAttachmentsBuilder {
document_client,
if_match_condition: None,
user_agent: None,
activity_id: None,
consistency_level: None,
continuation: None,
max_item_count: -1,
a_im: false,
}
}
}
impl<'a, 'b, C, D, COLL> Clone for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
fn clone(&self) -> Self {
Self {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: self.consistency_level.clone(),
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> DocumentClientRequired<'a, C, D, COLL>
for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn document_client(&self) -> &'a dyn DocumentClient<C, D, COLL> {
self.document_client
}
}
impl<'a, 'b, C, D, COLL> IfMatchConditionOption<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn if_match_condition(&self) -> Option<IfMatchCondition<'b>> {
self.if_match_condition
}
}
impl<'a, 'b, C, D, COLL> UserAgentOption<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn user_agent(&self) -> Option<&'b str> {
self.user_agent
}
}
impl<'a, 'b, C, D, COLL> ActivityIdOption<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn activity_id(&self) -> Option<&'b str> {
self.activity_id
}
}
impl<'a, 'b, C, D, COLL> ConsistencyLevelOption<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn consistency_level(&self) -> Option<ConsistencyLevel<'b>> {
self.consistency_level.clone()
}
}
impl<'a, 'b, C, D, COLL> ContinuationOption<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn continuation(&self) -> Option<&'b str> {
self.continuation
}
}
impl<'a, 'b, C, D, COLL> MaxItemCountOption for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn max_item_count(&self) -> i32 {
self.max_item_count
}
}
impl<'a, 'b, C, D, COLL> AIMOption for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
#[inline]
fn a_im(&self) -> bool {
self.a_im
}
}
impl<'a, 'b, C, D, COLL> IfMatchConditionSupport<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_if_match_condition(self, if_match_condition: IfMatchCondition<'b>) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: Some(if_match_condition),
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: self.consistency_level,
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> UserAgentSupport<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_user_agent(self, user_agent: &'b str) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: Some(user_agent),
activity_id: self.activity_id,
consistency_level: self.consistency_level,
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> ActivityIdSupport<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_activity_id(self, activity_id: &'b str) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: Some(activity_id),
consistency_level: self.consistency_level,
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> ConsistencyLevelSupport<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_consistency_level(self, consistency_level: ConsistencyLevel<'b>) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: Some(consistency_level),
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> ContinuationSupport<'b> for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_continuation(self, continuation: &'b str) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: self.consistency_level,
continuation: Some(continuation),
max_item_count: self.max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> MaxItemCountSupport for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_max_item_count(self, max_item_count: i32) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: self.consistency_level,
continuation: self.continuation,
max_item_count,
a_im: self.a_im,
}
}
}
impl<'a, 'b, C, D, COLL> AIMSupport for ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
type O = ListAttachmentsBuilder<'a, 'b, C, D, COLL>;
#[inline]
fn with_a_im(self, a_im: bool) -> Self::O {
ListAttachmentsBuilder {
document_client: self.document_client,
if_match_condition: self.if_match_condition,
user_agent: self.user_agent,
activity_id: self.activity_id,
consistency_level: self.consistency_level,
continuation: self.continuation,
max_item_count: self.max_item_count,
a_im,
}
}
}
impl<'a, 'b, C, D, COLL> ListAttachmentsBuilder<'a, 'b, C, D, COLL>
where
C: CosmosClient,
D: DatabaseClient<C>,
COLL: CollectionClient<C, D>,
{
pub async fn execute(&self) -> Result<ListAttachmentsResponse, AzureError> {
let mut req = self.document_client.cosmos_client().prepare_request(
&format!(
"dbs/{}/colls/{}/docs/{}/attachments",
self.document_client.database_client().database_name(),
self.document_client.collection_client().collection_name(),
self.document_client.document_name().name()
),
hyper::Method::GET,
ResourceType::Attachments,
);
req = IfMatchConditionOption::add_header(self, req);
req = UserAgentOption::add_header(self, req);
req = ActivityIdOption::add_header(self, req);
req = ConsistencyLevelOption::add_header(self, req);
req = ContinuationOption::add_header(self, req);
req = MaxItemCountOption::add_header(self, req);
req = AIMOption::add_header(self, req);
req = crate::add_partition_keys_header(self.document_client.partition_keys(), req);
let req = req.body(hyper::Body::empty())?;
let (headers, whole_body) = check_status_extract_headers_and_body(
self.document_client.hyper_client().request(req),
StatusCode::OK,
)
.await?;
debug!("\nheaders == {:?}", headers);
debug!("\nwhole body == {:#?}", whole_body);
Ok((&headers, &whole_body as &[u8]).try_into()?)
}
pub fn stream(&self) -> impl Stream<Item = Result<ListAttachmentsResponse, AzureError>> + '_ {
#[derive(Debug, Clone, PartialEq)]
enum States {
Init,
Continuation(String),
};
unfold(
Some(States::Init),
move |continuation_token: Option<States>| {
async move {
debug!("continuation_token == {:?}", &continuation_token);
let response = match continuation_token {
Some(States::Init) => self.execute().await,
Some(States::Continuation(continuation_token)) => {
self.clone()
.with_continuation(&continuation_token)
.execute()
.await
}
None => return None,
};
let response = match response {
Ok(response) => response,
Err(err) => return Some((Err(err), None)),
};
let continuation_token = match &response.continuation_token {
Some(ct) => Some(States::Continuation(ct.to_owned())),
None => None,
};
Some((Ok(response), continuation_token))
}
},
)
}
}