use anyhow::Result;
use crate::Client;
#[derive(Clone, Debug)]
pub struct Meta {
pub client: Client,
}
impl Meta {
#[doc(hidden)]
pub fn new(client: Client) -> Self {
Self { client }
}
#[doc = "Get OpenAPI schema.\n\n```rust,no_run\nasync fn example_meta_get_schema() -> \
anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let \
result: serde_json::Value = client.meta().get_schema().await?;\n \
println!(\"{:?}\", result);\n Ok(())\n}\n```"]
#[tracing::instrument]
pub async fn get_schema<'a>(&'a self) -> Result<serde_json::Value, crate::types::error::Error> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, ""),
);
req = req.bearer_auth(&self.client.token);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(text.to_string(), err),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
#[doc = "Get ip address information.\n\n```rust,no_run\nasync fn example_meta_get_ipinfo() -> \
anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let \
result: kittycad::types::IpAddrInfo = client.meta().get_ipinfo().await?;\n \
println!(\"{:?}\", result);\n Ok(())\n}\n```"]
#[tracing::instrument]
pub async fn get_ipinfo<'a>(
&'a self,
) -> Result<crate::types::IpAddrInfo, crate::types::error::Error> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, "_meta/ipinfo"),
);
req = req.bearer_auth(&self.client.token);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(text.to_string(), err),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
#[doc = "List all active announcements.\n\nNo authentication is required. Results are ordered \
newest first, with the announcement ID breaking ties.\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\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn \
example_meta_get_announcements_stream() -> anyhow::Result<()> {\n let client = \
kittycad::Client::new_from_env();\n let mut meta = client.meta();\n let mut \
stream = meta.get_announcements_stream(Some(4 as u32));\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```"]
#[tracing::instrument]
pub async fn get_announcements<'a>(
&'a self,
limit: Option<u32>,
page_token: Option<String>,
) -> Result<crate::types::AnnouncementResultsPage, crate::types::error::Error> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, "announcements"),
);
req = req.bearer_auth(&self.client.token);
let mut query_params = vec![];
if let Some(p) = limit {
query_params.push(("limit", format!("{}", p)));
}
if let Some(p) = page_token {
query_params.push(("page_token", p));
}
req = req.query(&query_params);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(text.to_string(), err),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
#[doc = "List all active announcements.\n\nNo authentication is required. Results are ordered \
newest first, with the announcement ID breaking ties.\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\n```rust,no_run\nuse futures_util::TryStreamExt;\nasync fn \
example_meta_get_announcements_stream() -> anyhow::Result<()> {\n let client = \
kittycad::Client::new_from_env();\n let mut meta = client.meta();\n let mut \
stream = meta.get_announcements_stream(Some(4 as u32));\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```"]
#[tracing::instrument]
#[cfg(not(feature = "js"))]
pub fn get_announcements_stream<'a>(
&'a self,
limit: Option<u32>,
) -> impl futures::Stream<Item = Result<crate::types::Announcement, crate::types::error::Error>>
+ Unpin
+ '_ {
use futures::{StreamExt, TryFutureExt, TryStreamExt};
use crate::types::paginate::Pagination;
let pagination_url_path = ("announcements").to_string();
let mut pagination_query_params: Vec<(&str, String)> = Vec::new();
if let Some(p) = limit.as_ref() {
pagination_query_params.push(("limit", format!("{}", p)));
}
let stream = self
.get_announcements(limit, None)
.map_ok(move |result| {
let items = futures::stream::iter(result.items().into_iter().map(Ok));
let next_pages = futures::stream::try_unfold(
(None, result),
move |(prev_page_token, new_result)| {
let pagination_url_path = pagination_url_path.clone();
let pagination_query_params = pagination_query_params.clone();
async move {
if new_result.has_more_pages()
&& !new_result.items().is_empty()
&& prev_page_token != new_result.next_page_token()
{
async {
let mut req = self.client.client.request(
http::Method::GET,
format!(
"{}/{}",
self.client.base_url,
pagination_url_path.clone()
),
);
req = req.bearer_auth(&self.client.token);
let query_params = pagination_query_params.clone();
req = req.query(&query_params);
let mut request = req.build()?;
request =
new_result.next_page_with_param(request, "page_token")?;
let resp = self.client.client.execute(request).await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(
text.to_string(),
err,
),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
.map_ok(|result: crate::types::AnnouncementResultsPage| {
Some((
futures::stream::iter(result.items().into_iter().map(Ok)),
(new_result.next_page_token(), result),
))
})
.await
} else {
Ok(None)
}
}
},
)
.try_flatten();
items.chain(next_pages)
})
.try_flatten_stream();
#[cfg(target_arch = "wasm32")]
{
stream.boxed_local()
}
#[cfg(not(target_arch = "wasm32"))]
{
stream.boxed()
}
}
#[doc = "Authorize an inbound auth request from our Community page.\n\n**Parameters:**\n\n- \
`sig: &'astr`: The signature for the given payload (required)\n- `sso: &'astr`: The \
nonce and redirect URL sent to us by Discourse (required)\n\n```rust,no_run\nasync fn \
example_meta_community_sso() -> anyhow::Result<()> {\n let client = \
kittycad::Client::new_from_env();\n client\n .meta()\n \
.community_sso(\"some-string\", \"some-string\")\n .await?;\n Ok(())\n}\n```"]
#[tracing::instrument]
pub async fn community_sso<'a>(
&'a self,
sig: &'a str,
sso: &'a str,
) -> Result<(), crate::types::error::Error> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, "community/sso"),
);
req = req.bearer_auth(&self.client.token);
let query_params = vec![("sig", sig.to_string()), ("sso", sso.to_string())];
req = req.query(&query_params);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
Ok(())
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
#[doc = "Return pong.\n\n```rust,no_run\nasync fn example_meta_ping() -> anyhow::Result<()> \
{\n let client = kittycad::Client::new_from_env();\n let result: \
kittycad::types::Pong = client.meta().ping().await?;\n println!(\"{:?}\", \
result);\n Ok(())\n}\n```"]
#[tracing::instrument]
pub async fn ping<'a>(&'a self) -> Result<crate::types::Pong, crate::types::error::Error> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, "ping"),
);
req = req.bearer_auth(&self.client.token);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(text.to_string(), err),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
#[doc = "Get the pricing for our subscriptions.\n\nThis is the ultimate source of truth for the pricing of our subscriptions.\n\n```rust,no_run\nasync fn example_meta_get_pricing_subscriptions() -> anyhow::Result<()> {\n let client = kittycad::Client::new_from_env();\n let result: std::collections::HashMap<String, Vec<kittycad::types::ZooProductSubscription>> =\n client.meta().get_pricing_subscriptions().await?;\n println!(\"{:?}\", result);\n Ok(())\n}\n```"]
#[tracing::instrument]
pub async fn get_pricing_subscriptions<'a>(
&'a self,
) -> Result<
std::collections::HashMap<String, Vec<crate::types::ZooProductSubscription>>,
crate::types::error::Error,
> {
let mut req = self.client.client.request(
http::Method::GET,
format!("{}/{}", self.client.base_url, "pricing/subscriptions"),
);
req = req.bearer_auth(&self.client.token);
let resp = req.send().await?;
let status = resp.status();
if status.is_success() {
let text = resp.text().await.unwrap_or_default();
serde_json::from_str(&text).map_err(|err| {
crate::types::error::Error::from_serde_error(
format_serde_error::SerdeError::new(text.to_string(), err),
status,
)
})
} else {
let text = resp.text().await.unwrap_or_default();
Err(crate::types::error::Error::Server {
body: text.to_string(),
status,
})
}
}
}