xt_oss/oss/api/bucket/
versions.rs1use crate::oss::{self, entities::version::VersioningStatus};
2
3use self::builders::{
4 GetBucketVersioningBuilder, ListObjectVersionsBuilder, PutBucketVersioningBuilder,
5};
6
7pub mod builders {
8 use std::fmt;
9
10 use serde::{Deserialize, Serialize};
11
12 use crate::oss::{
13 self,
14 api::{self, ApiResponseFrom},
15 entities::version::{ListVersionsResult, VersioningConfiguration, VersioningStatus},
16 http,
17 };
18
19 pub struct PutBucketVersioningBuilder<'a> {
20 client: &'a oss::Client<'a>,
21 status: VersioningStatus,
22 }
23
24 impl<'a> PutBucketVersioningBuilder<'a> {
25 pub(crate) fn new(client: &'a oss::Client, status: VersioningStatus) -> Self {
26 Self { client, status }
27 }
28
29 pub async fn execute(&self) -> api::ApiResult {
30 let res = format!("/{}/?{}", self.client.bucket(), "versioning");
31 let url = format!("{}/?{}", self.client.base_url(), "versioning");
32
33 let config = VersioningConfiguration {
34 status: Some(self.status.to_owned()),
35 };
36
37 let data = oss::Bytes::from(quick_xml::se::to_string(&config).unwrap());
38
39 let resp = self
40 .client
41 .request
42 .task()
43 .with_url(&url)
44 .with_method(http::Method::PUT)
45 .with_resource(&res)
46 .with_body(data)
47 .execute_timeout(self.client.timeout())
48 .await?;
49 Ok(ApiResponseFrom(resp).to_empty().await)
50 }
51 }
52
53 pub struct GetBucketVersioningBuilder<'a> {
54 client: &'a oss::Client<'a>,
55 }
56
57 impl<'a> GetBucketVersioningBuilder<'a> {
58 pub(crate) fn new(client: &'a oss::Client) -> Self {
59 Self { client }
60 }
61 pub async fn execute(&self) -> api::ApiResult<VersioningConfiguration> {
62 let res = format!("/{}/?{}", self.client.bucket(), "versioning");
63 let url = format!("{}/?{}", self.client.base_url(), "versioning");
64 let resp = self
65 .client
66 .request
67 .task()
68 .with_url(&url)
69 .with_resource(&res)
70 .execute_timeout(self.client.timeout())
71 .await?;
72 Ok(ApiResponseFrom(resp).to_type().await)
73 }
74 }
75
76 #[derive(Debug, Serialize, Deserialize, Default)]
77 pub(crate) struct ListObjectVersionsQuery<'a> {
78 pub delimiter: Option<&'a str>,
79 #[serde(rename = "key-marker")]
80 pub key_marker: Option<&'a str>,
81 #[serde(rename = "version_id_marker")]
82 pub version_id_marker: Option<&'a str>,
83 #[serde(rename = "max-keys")]
84 pub max_keys: Option<u32>,
85 pub prefix: Option<&'a str>,
86 #[serde(rename = "encoding-type")]
87 pub encoding_type: Option<&'a str>,
88 }
89
90 impl<'a> fmt::Display for ListObjectVersionsQuery<'a> {
91 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
92 write!(f, "{}", serde_qs::to_string(self).unwrap())
93 }
94 }
95
96 pub struct ListObjectVersionsBuilder<'a> {
97 client: &'a oss::Client<'a>,
98 query: ListObjectVersionsQuery<'a>,
99 }
100
101 impl<'a> ListObjectVersionsBuilder<'a> {
102 pub(crate) fn new(client: &'a oss::Client) -> Self {
103 Self {
104 client,
105 query: ListObjectVersionsQuery::default(),
106 }
107 }
108
109 pub fn with_delimiter(mut self, value: &'a str) -> Self {
110 self.query.delimiter = Some(value);
111 self
112 }
113
114 pub fn with_key_marker(mut self, value: &'a str) -> Self {
115 self.query.key_marker = Some(value);
116 self
117 }
118
119 pub fn with_max_keys(mut self, value: u32) -> Self {
120 self.query.max_keys = Some(value);
121 self
122 }
123
124 pub fn with_prefix(mut self, value: &'a str) -> Self {
125 self.query.prefix = Some(value);
126 self
127 }
128
129 pub fn with_version_id_marker(mut self, value: &'a str) -> Self {
130 self.query.version_id_marker = Some(value);
131 self
132 }
133
134 pub fn with_encoding_type(mut self, value: &'a str) -> Self {
135 self.query.encoding_type = Some(value);
136 self
137 }
138
139 pub async fn execute(&self) -> api::ApiResult<ListVersionsResult> {
140 let query = self.query.to_string();
141 let res = format!("/{}/?versions", self.client.bucket());
142 let url = format!("{}/?versions&{}", self.client.base_url(), query);
143
144 let resp = self
145 .client
146 .request
147 .task()
148 .with_url(&url)
149 .with_resource(&res)
150 .execute_timeout(self.client.timeout())
151 .await?;
152 Ok(ApiResponseFrom(resp).to_type().await)
153 }
154 }
155}
156
157#[allow(non_snake_case)]
159impl<'a> oss::Client<'a> {
160 pub fn PutBucketVersioning(&self, status: VersioningStatus) -> PutBucketVersioningBuilder {
165 PutBucketVersioningBuilder::new(self, status)
166 }
167 pub fn GetBucketVersioning(&self) -> GetBucketVersioningBuilder {
172 GetBucketVersioningBuilder::new(self)
173 }
174
175 pub fn ListObjectVersions(&self) -> ListObjectVersionsBuilder {
181 ListObjectVersionsBuilder::new(self)
182 }
183}