1use anyhow::Result;
2
3use crate::Client;
4#[derive(Clone, Debug)]
5pub struct ApiTokens {
6 pub client: Client,
7}
8
9impl ApiTokens {
10 #[doc(hidden)]
11 pub fn new(client: Client) -> Self {
12 Self { client }
13 }
14
15 #[doc = "List API tokens for your user.\n\nThis endpoint requires authentication by any Zoo user. It returns the API tokens for the authenticated user.\n\nThe API tokens are returned in order of creation, with the most recently created API tokens first.\n\n**Parameters:**\n\n- `limit: Option<u32>`: Maximum number of items returned by a single call\n- `page_token: Option<String>`: Token returned by previous call to retrieve the subsequent page\n- `sort_by: Option<crate::types::CreatedAtSortMode>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_api_tokens_list_for_user_stream() -> anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let mut api_tokens = client.api_tokens();\n let mut stream = api_tokens.list_for_user_stream(\n Some(4 as u32),\n Some(kittycad::types::CreatedAtSortMode::CreatedAtDescending),\n );\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
16 #[tracing::instrument]
17 pub async fn list_for_user<'a>(
18 &'a self,
19 limit: Option<u32>,
20 page_token: Option<String>,
21 sort_by: Option<crate::types::CreatedAtSortMode>,
22 ) -> Result<crate::types::ApiTokenResultsPage, crate::types::error::Error> {
23 let mut req = self.client.client.request(
24 http::Method::GET,
25 format!("{}/{}", self.client.base_url, "user/api-tokens"),
26 );
27 req = req.bearer_auth(&self.client.token);
28 let mut query_params = vec![];
29 if let Some(p) = limit {
30 query_params.push(("limit", format!("{}", p)));
31 }
32
33 if let Some(p) = page_token {
34 query_params.push(("page_token", p));
35 }
36
37 if let Some(p) = sort_by {
38 query_params.push(("sort_by", format!("{}", p)));
39 }
40
41 req = req.query(&query_params);
42 let resp = req.send().await?;
43 let status = resp.status();
44 if status.is_success() {
45 let text = resp.text().await.unwrap_or_default();
46 serde_json::from_str(&text).map_err(|err| {
47 crate::types::error::Error::from_serde_error(
48 format_serde_error::SerdeError::new(text.to_string(), err),
49 status,
50 )
51 })
52 } else {
53 let text = resp.text().await.unwrap_or_default();
54 Err(crate::types::error::Error::Server {
55 body: text.to_string(),
56 status,
57 })
58 }
59 }
60
61 #[doc = "List API tokens for your user.\n\nThis endpoint requires authentication by any Zoo user. It returns the API tokens for the authenticated user.\n\nThe API tokens are returned in order of creation, with the most recently created API tokens first.\n\n**Parameters:**\n\n- `limit: Option<u32>`: Maximum number of items returned by a single call\n- `page_token: Option<String>`: Token returned by previous call to retrieve the subsequent page\n- `sort_by: Option<crate::types::CreatedAtSortMode>`\n\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn example_api_tokens_list_for_user_stream() -> anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let mut api_tokens = client.api_tokens();\n let mut stream = api_tokens.list_for_user_stream(\n Some(4 as u32),\n Some(kittycad::types::CreatedAtSortMode::CreatedAtDescending),\n );\n loop {\n match stream.try_next().await {\n Ok(Some(item)) => {\n println!(\"{:?}\", item);\n }\n Ok(None) => {\n break;\n }\n Err(err) => {\n return Err(err.into());\n }\n }\n }\n\n Ok(())\n}\n```"]
62 #[tracing::instrument]
63 #[cfg(not(feature = "js"))]
64 pub fn list_for_user_stream<'a>(
65 &'a self,
66 limit: Option<u32>,
67 sort_by: Option<crate::types::CreatedAtSortMode>,
68 ) -> impl futures::Stream<Item = Result<crate::types::ApiToken, crate::types::error::Error>>
69 + Unpin
70 + '_ {
71 use futures::{StreamExt, TryFutureExt, TryStreamExt};
72
73 use crate::types::paginate::Pagination;
74 self.list_for_user(limit, None, sort_by)
75 .map_ok(move |result| {
76 let items = futures::stream::iter(result.items().into_iter().map(Ok));
77 let next_pages = futures::stream::try_unfold(
78 (None, result),
79 move |(prev_page_token, new_result)| async move {
80 if new_result.has_more_pages()
81 && !new_result.items().is_empty()
82 && prev_page_token != new_result.next_page_token()
83 {
84 async {
85 let mut req = self.client.client.request(
86 http::Method::GET,
87 format!("{}/{}", self.client.base_url, "user/api-tokens"),
88 );
89 req = req.bearer_auth(&self.client.token);
90 let mut request = req.build()?;
91 request = new_result.next_page(request)?;
92 let resp = self.client.client.execute(request).await?;
93 let status = resp.status();
94 if status.is_success() {
95 let text = resp.text().await.unwrap_or_default();
96 serde_json::from_str(&text).map_err(|err| {
97 crate::types::error::Error::from_serde_error(
98 format_serde_error::SerdeError::new(
99 text.to_string(),
100 err,
101 ),
102 status,
103 )
104 })
105 } else {
106 let text = resp.text().await.unwrap_or_default();
107 Err(crate::types::error::Error::Server {
108 body: text.to_string(),
109 status,
110 })
111 }
112 }
113 .map_ok(|result: crate::types::ApiTokenResultsPage| {
114 Some((
115 futures::stream::iter(result.items().into_iter().map(Ok)),
116 (new_result.next_page_token(), result),
117 ))
118 })
119 .await
120 } else {
121 Ok(None)
122 }
123 },
124 )
125 .try_flatten();
126 items.chain(next_pages)
127 })
128 .try_flatten_stream()
129 .boxed()
130 }
131
132 #[doc = "Create a new API token for your user.\n\nThis endpoint requires authentication by any \
133 Zoo user. It creates a new API token for the authenticated \
134 user.\n\n**Parameters:**\n\n- `label: Option<String>`: An optional label for the API \
135 token.\n\n```rust,no_run\nasync fn example_api_tokens_create_for_user() -> \
136 anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let \
137 result: kittycad::types::ApiToken = client\n .api_tokens()\n \
138 .create_for_user(Some(\"some-string\".to_string()))\n .await?;\n \
139 println!(\"{:?}\", result);\n Ok(())\n}\n```"]
140 #[tracing::instrument]
141 pub async fn create_for_user<'a>(
142 &'a self,
143 label: Option<String>,
144 ) -> Result<crate::types::ApiToken, crate::types::error::Error> {
145 let mut req = self.client.client.request(
146 http::Method::POST,
147 format!("{}/{}", self.client.base_url, "user/api-tokens"),
148 );
149 req = req.bearer_auth(&self.client.token);
150 let mut query_params = vec![];
151 if let Some(p) = label {
152 query_params.push(("label", p));
153 }
154
155 req = req.query(&query_params);
156 let resp = req.send().await?;
157 let status = resp.status();
158 if status.is_success() {
159 let text = resp.text().await.unwrap_or_default();
160 serde_json::from_str(&text).map_err(|err| {
161 crate::types::error::Error::from_serde_error(
162 format_serde_error::SerdeError::new(text.to_string(), err),
163 status,
164 )
165 })
166 } else {
167 let text = resp.text().await.unwrap_or_default();
168 Err(crate::types::error::Error::Server {
169 body: text.to_string(),
170 status,
171 })
172 }
173 }
174
175 #[doc = "Get an API token for your user.\n\nThis endpoint requires authentication by any Zoo \
176 user. It returns details of the requested API token for the \
177 user.\n\n**Parameters:**\n\n- `token: &'astr`: The API token. \
178 (required)\n\n```rust,no_run\nasync fn example_api_tokens_get_for_user() -> \
179 anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let \
180 result: kittycad::types::ApiToken = \
181 client.api_tokens().get_for_user(\"some-string\").await?;\n println!(\"{:?}\", \
182 result);\n Ok(())\n}\n```"]
183 #[tracing::instrument]
184 pub async fn get_for_user<'a>(
185 &'a self,
186 token: &'a str,
187 ) -> Result<crate::types::ApiToken, crate::types::error::Error> {
188 let mut req = self.client.client.request(
189 http::Method::GET,
190 format!(
191 "{}/{}",
192 self.client.base_url,
193 "user/api-tokens/{token}".replace("{token}", token)
194 ),
195 );
196 req = req.bearer_auth(&self.client.token);
197 let resp = req.send().await?;
198 let status = resp.status();
199 if status.is_success() {
200 let text = resp.text().await.unwrap_or_default();
201 serde_json::from_str(&text).map_err(|err| {
202 crate::types::error::Error::from_serde_error(
203 format_serde_error::SerdeError::new(text.to_string(), err),
204 status,
205 )
206 })
207 } else {
208 let text = resp.text().await.unwrap_or_default();
209 Err(crate::types::error::Error::Server {
210 body: text.to_string(),
211 status,
212 })
213 }
214 }
215
216 #[doc = "Delete an API token for your user.\n\nThis endpoint requires authentication by any \
217 Zoo user. It deletes the requested API token for the user.\n\nThis endpoint does not \
218 actually delete the API token from the database. It merely marks the token as \
219 invalid. We still want to keep the token in the database for historical \
220 purposes.\n\n**Parameters:**\n\n- `token: &'astr`: The API token. \
221 (required)\n\n```rust,no_run\nasync fn example_api_tokens_delete_for_user() -> \
222 anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n \
223 client.api_tokens().delete_for_user(\"some-string\").await?;\n Ok(())\n}\n```"]
224 #[tracing::instrument]
225 pub async fn delete_for_user<'a>(
226 &'a self,
227 token: &'a str,
228 ) -> Result<(), crate::types::error::Error> {
229 let mut req = self.client.client.request(
230 http::Method::DELETE,
231 format!(
232 "{}/{}",
233 self.client.base_url,
234 "user/api-tokens/{token}".replace("{token}", token)
235 ),
236 );
237 req = req.bearer_auth(&self.client.token);
238 let resp = req.send().await?;
239 let status = resp.status();
240 if status.is_success() {
241 Ok(())
242 } else {
243 let text = resp.text().await.unwrap_or_default();
244 Err(crate::types::error::Error::Server {
245 body: text.to_string(),
246 status,
247 })
248 }
249 }
250}